code:
//=============================================================================
// OriginalTimer.js
// ----------------------------------------------------------------------------
// Copyright (c) 2016 fftfantt
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 0.1.0 2016/2/15 β版
// 1.0.0 2016/2/21 初版
// 1.0.1 2016/2/21 TimerSaveがYESでも再実行されない不具合修正
// 1.0.2 2016/2/21 初期化関連の処理の見直し
// 1.0.3 2016/3/26 タイマースタート時に即時でカウントしないよう変更
// 1.0.4 2016/4/03 戦闘終了後にエラーになってしまう不具合を解消
// 1.1.0 2016/4/03 タイマーの終了後に指定のスイッチをONにするコマンド追加
// 1.2.0 2016/4/03 タイマーのカウントをリセットするコマンド追加
// 1.2.1 2016/4/03 タイマー値の取得で設定値が取れない不具合修正
// 1.3.0 2016/6/09 設定時間操作、実時間操作のコマンド追加
// ----------------------------------------------------------------------------
// [HomePage]: https://googledrive.com/host/0BxiSZT-B8lvFOUFhVTF6VjNnUGc/index.html
// [Twitter] : https://twitter.com/fftfantt/
// [GitHub]  : https://github.com/fftfantt/
//=============================================================================
/*:
 * @plugindesc オリジナルタイマー
 * @author fftfantt
 *
 * @param TimerSave
 * @desc タイマーの値をセーブデータに含めるか YES or NO
 * @default NO
 * @help
 *
 * ■説明
 * このプラグインは1日から1/100秒単位でカウントできるオリジナルタイマーを実装します。
 * カウントダウンのほか、カウントアップにも対応しています。
 * 動的テキスト表示部分のロジックについては、トリアコンタン様の「DTextPicture.js」
 * を参考にさせていただいております。この場をお借りして感謝申し上げます。
 *
 * ■利用規約
 * 当プラグインはMITライセンスのもとで公開されています。
 * https://osdn.jp/projects/opensource/wiki/licenses%2FMIT_license
 * ヘッダーのライセンス表記のみ残してください。
 * 商用利用、年齢制限のあるゲームへの使用、改変が可能です。
 * クレジットは不要です。
 * 当プラグインの不具合に損害の責任についても、MITライセンスの表記どおりです。
 *
 * ■使い方の概要
 * イベントのコマンド追加からプラグインコマンドを選択し、以下のようなプラグイン
 * コマンドでタイマーを設定後開始してください。
 * こちらにも詳しい使い方が記載されています。
 * https://github.com/fftfantt/RPGMakerMV/wiki/OriginalTimer.js
 *
 * ■タイマーの設定
 * 　◆パラメータ
 * 　　引数1：タイマーの設定を行う場合の引数 [設定 or SET]
 * 　　引数2：タイマーの種類[アップ or ダウン or UP or DOWN]
 * 　　引数3：設定時間 (1d1h1m1s1x1c のように記載)[日 or d  時間 or h  分 or m  秒 or s x(1/10秒) c(1/100秒)]
 * 　　引数4：ピクチャ番号[1～100]
 * 　　引数5：フォントサイズ
 * 　　引数6：画面Ｘ
 * 　　引数7：画面Ｙ
 * 　　引数8：表示モード[表示 or 非表示 or DISPLAY or HIDE]
 * 　　引数9：表示形式[D日 HH時MM分SS.XC秒 や HH:MM:SS:XC で自由に]
 * 　◆コマンド例
 * 　　オリジナルタイマー 設定 ダウン 2d1h30m 99 24 10 10 表示 D日 HH時MM分SS.XC秒
 * 　　ORIGINALTIMER SET DOWN 1h30m 99 24 10 10 DISPLAY HH:MM:SS:XC
 * 　　オリジナルタイマー 設定 アップ 1h30m 10 24 630 10 非表示 HH:MM:SS.XC
 * 　　ORIGINALTIMER SET UP 1h30m 10 24 630 10 HIDE HH:MM:SS.XC
 *
 * ■タイマーの開始
 * 　◆パラメータ
 * 　　引数1：タイマーを開始もしくは再開する場合の引数 [開始 or 再開 or START]
 * 　◆コマンド例
 * 　　オリジナルタイマー 開始
 * 　　ORIGINALTIMER START
 *
 * ■タイマーの停止
 * 　◆パラメータ
 * 　　引数1：タイマーを停止する場合の引数 [停止 or STOP]
 * 　◆コマンド例
 * 　　オリジナルタイマー 停止
 * 　　ORIGINALTIMER STOP
 *
 * ■タイマーの表示
 * 　◆パラメータ
 * 　　引数1：タイマーを表示する場合の引数 [表示 or DISPLAY]
 * 　◆コマンド例
 * 　　オリジナルタイマー 表示
 * 　　ORIGINALTIMER DISPLAY
 *
 * ■タイマーの非表示
 * 　◆パラメータ
 * 　　引数1：タイマーを非表示にする場合の引数 [非表示 or HIDE]
 * 　◆コマンド例
 * 　　オリジナルタイマー 非表示
 * 　　ORIGINALTIMER HIDE
 *
 * ■タイマーの初期化
 * 　　引数1：タイマーを初期化する場合の引数 [初期化 or INITIALIZE]
 * 　◆コマンド例
 * 　　オリジナルタイマー 初期化
 * 　　ORIGINALTIMER INITIALIZE
 *
 * ■タイマー値の取得
 * 　　引数1：タイマーに関する値を取得する場合の引数 [取得 or GET]
 * 　　引数2：取得する値の種類 [状態 or STATE or 値 or VALUE etc]
 * 　　引数3：値を格納する変数
 * 　◆コマンド例
 * 　　オリジナルタイマー 取得 状態 1
 * 　　ORIGINALTIMER GET STATE 1
 * 　　オリジナルタイマー 取得 値 1
 * 　　ORIGINALTIMER GET VALUE 1
 * 　　オリジナルタイマー 取得 日 1
 * 　　ORIGINALTIMER GET DAY 1
 * 　　オリジナルタイマー 取得 時 1
 * 　　ORIGINALTIMER GET HR 1
 * 　　オリジナルタイマー 取得 分 1
 * 　　ORIGINALTIMER GET MIN 1
 * 　　オリジナルタイマー 取得 秒 1
 * 　　ORIGINALTIMER GET SEC 1
 * 　　オリジナルタイマー 取得 コンマ秒 1
 * 　　ORIGINALTIMER GET HSEC 1
 *
 * ■タイマー終了後のスイッチ操作
 * 　　引数1：タイマー終了後にスイッチを操作する場合の引数 [スイッチ or SWITCH]
 * 　　引数2：操作の種類  [オン or ON or オフ or OFF or リバース or REVERSE]
 * 　　引数3：操作するスイッチ番号
 * 　◆コマンド例
 * 　　オリジナルタイマー スイッチ オン 1
 * 　　ORIGINALTIMER SWITCH ON 1
 * 　　オリジナルタイマー スイッチ オフ 2
 * 　　ORIGINALTIMER SWITCH OFF 2
 * 　　オリジナルタイマー スイッチ リバース 3
 * 　　ORIGINALTIMER SWITCH REVERSE 3
 *
 * ■タイマーカウントのリセット
 * 　　引数1：タイマーカウントのリセットを行う場合の引数 [リセット or RESET]
 * 　◆コマンド例
 * 　　オリジナルタイマー リセット
 * 　　ORIGINALTIMER RESET
 *
 *
 * ■タイマー設定時間の操作
 *    引数1：タイマー設定時間の操作を行う場合の引数 [設定時間操作 or LIMITCHANGE]
 *    引数2：設定時間の増減[増加 or 減少 or UP or DOWN]
 *    引数3：設定時間 (1d1h1m1s1x1c のように記載)[日 or d  時間 or h  分 or m  秒 or s x(1/10秒) c(1/100秒)]
 * 　◆コマンド例
 *     オリジナルタイマー 設定時間操作 増加 3m
 *     オリジナルタイマー 設定時間操作 減少 10s
 * 　　ORIGINALTIMER LIMITCHANGE UP 3m
 * 　　ORIGINALTIMER LIMITCHANGE DOWN 3m
 *
 * ■タイマー実時間の操作
 *    引数1：タイマー実時間の操作を行う場合の引数 [実時間操作 or TIMECHANGE]
 *    引数2：実時間の増減[進行 or 逆行 or UP or DOWN]
 *    引数3：設定時間 (1d1h1m1s1x1c のように記載)[日 or d  時間 or h  分 or m  秒 or s x(1/10秒) c(1/100秒)]
 * 　◆コマンド例
 *     オリジナルタイマー 実時間操作 進行 3m
 *     オリジナルタイマー 実時間操作 逆行 10s
 * 　　ORIGINALTIMER TIMECHANGE UP 3m
 * 　　ORIGINALTIMER TIMECHANGE DOWN 3m
 *
 */

(function () {

  var parameters = PluginManager.parameters('OriginalTimer');
  var TimerSave = parameters['TimerSave'].toUpperCase();

  var OriginalTimer = null;
  var SetFlag = false;
  var RunFlag = false;
  var DisplayMode = '';
  var Count = 0;
  var CountUnit = 0;
  var CountTime = 0;
  var CommndType = '';
  var TimerType = '';
  var TimerLimit = 0;
  var day = 0;
  var hr = 0;
  var min = 0;
  var sec = 0;
  var Hsec = 0;
  var TimerText = '';
  var ShowText = '';

  var pictureId = 0;
  var fontsize = 32;
  var name = '';
  var origin = 0;
  var x = 0;
  var y = 0;
  var scaleX = 100;
  var scaleY = 100;
  var opacity = 255;
  var blendMode = 0;

  var SwitchState = '';
  var SwitchNumber = 0;

  var prevMsec = 0;

  function getCurrentMsec() {
    return SceneManager._currentTime || Date.now();
  }

  //=============================================================================
  // Game_Interpreter_pluginCommand
  //  プラグインコマンドが実行されたときに処理されます
  //=============================================================================

  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);

    if (command === "オリジナルタイマー" || command.toUpperCase() === "ORIGINALTIMER") {
      if ($gameTimer !== null) {
        if (!Object.prototype.hasOwnProperty.call($gameTimer, '_fftfanttOriginalTimer_Run')) {
          if (TimerSave == 'YES') Game_Timer.prototype.fftfanttOriginalTimer_Initialize();
        }
      }
      CommndType = args[0];

      if (CommndType == '設定' || CommndType.toUpperCase() == 'SET') {
        if (RunFlag) {
          console.log('オリジナルタイマーは実行中です');
          return;
        }
        SetFlag = true;
        if (TimerSave == 'YES') {
          Game_Timer.prototype.fftfanttOriginalTimer_Initialize();
          $gameTimer._fftfanttOriginalTimer_Set = true;
        }
        TimerSet(args);
      }
      if (CommndType == '開始' || CommndType == '再開' || CommndType.toUpperCase() == 'START') {
        if (RunFlag) {
          if ($gameTemp.isPlaytest()) console.log('オリジナルタイマーは実行中です');
          return;
        }
        if (!SetFlag) {
          if (!$gameTemp.isPlaytest()) console.log('タイマーが設定されていません');
          return;
        }
        RunFlag = true;
        if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_Run = true;
        prevMsec = getCurrentMsec();
        TimerRun();
        OriginalTimer = setInterval(TimerRun, CountUnit);
      }

      if (CommndType == '停止' || CommndType.toUpperCase() == 'STOP') {
        clearInterval(OriginalTimer);
        RunFlag = false;
        if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_Run = false;
      }

      if (CommndType == '表示' || CommndType.toUpperCase() == 'DISPLAY') {
        opacity = 255
        if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_DisplayMode = '表示';
        return;
      }

      if (CommndType == '非表示' || CommndType.toUpperCase() == 'HIDE') {
        opacity = 0;
        if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_DisplayMode = '非表示';
        return;
      }

      if (CommndType == '初期化' || CommndType.toUpperCase() == 'INITIALIZE') {
        if (TimerSave == 'YES') {
          Game_Timer.prototype.fftfanttOriginalTimer_Initialize();
        }
        TimerInitialize();
        return;
      }

      if (CommndType == '取得' || CommndType.toUpperCase() == 'GET') {
        TimerGet(args);
      }

      if (CommndType == 'スイッチ' || CommndType.toUpperCase() == 'SWITCH') {
        if (!SetFlag) {
          if (!$gameTemp.isPlaytest()) console.log('タイマーが設定されていません');
          return;
        }
        SwitchState = args[1]
        switch (args[1]) {
          case 'オン':
            SwitchState = 'ON';
            break;
          case 'オフ':
            SwitchState = 'OFF';
            break;
          case 'リバース':
            SwitchState = 'REVERSE';
            break;
        }
        SwitchNumber = parseInt(args[2], 10);
        if (TimerSave == 'YES') {
          $gameTimer._fftfanttOriginalTimer_SwitchState = SwitchState
          $gameTimer._fftfanttOriginalTimer_SwitchNumber = SwitchNumber
        }
      }

      if (CommndType == 'リセット' || CommndType.toUpperCase() == 'RESET') {
        if (!SetFlag) {
          if (!$gameTemp.isPlaytest()) console.log('タイマーが設定されていません');
          return;
        }
        Count = 0;
        if (!RunFlag && pictureId !== 0) $gameScreen.erasePicture(pictureId);
      }

      if (CommndType == '設定時間操作' || CommndType.toUpperCase() == 'LIMITCHANGE') {
        if (!SetFlag) {
          if (!$gameTemp.isPlaytest()) console.log('タイマーが設定されていません');
          return;
        }
        var timer_tmp_array = args[2].match(/((\d+)(d|日))?((\d+)(h|時間))?((\d+)(m|分間?))?((\d+)(s|秒間?))?((\d+)(x))?((\d+)(c))?/);
        if (args[1] == '増加' || args[1] == 'UP') {
          if (timer_tmp_array[2]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[2], 10) * 8640000;
          if (timer_tmp_array[5]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[5], 10) * 360000;
          if (timer_tmp_array[8]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[8], 10) * 6000;
          if (timer_tmp_array[11]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[11], 10) * 100;
          if (timer_tmp_array[14]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[14], 10) * 10;
          if (timer_tmp_array[17]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[17], 10);
        }
        else if (args[1] == '減少' || args[1] == 'DOWN') {
          if (timer_tmp_array[2]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[2], 10) * 8640000;
          if (timer_tmp_array[5]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[5], 10) * 360000;
          if (timer_tmp_array[8]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[8], 10) * 6000;
          if (timer_tmp_array[11]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[11], 10) * 100;
          if (timer_tmp_array[14]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[14], 10) * 10;
          if (timer_tmp_array[17]) TimerLimit = TimerLimit - parseInt(timer_tmp_array[17], 10);
          if (TimerLimit < 0) TimerLimit = 0;
        }
        if (!RunFlag && pictureId !== 0) $gameScreen.erasePicture(pictureId);
      }

      if (CommndType == '実時間操作' || CommndType.toUpperCase() == 'TIMECHANGE') {
        if (!SetFlag) {
          if (!$gameTemp.isPlaytest()) console.log('タイマーが設定されていません');
          return;
        }
        var timer_tmp_array = args[2].match(/((\d+)(d|日))?((\d+)(h|時間))?((\d+)(m|分間?))?((\d+)(s|秒間?))?((\d+)(x))?((\d+)(c))?/);
        if (args[1] == '進行' || args[1].toUpperCase() == 'UP') {
          if (timer_tmp_array[2]) Count = Count + parseInt(timer_tmp_array[2], 10) * 8640000;
          if (timer_tmp_array[5]) Count = Count + parseInt(timer_tmp_array[5], 10) * 360000;
          if (timer_tmp_array[8]) Count = Count + parseInt(timer_tmp_array[8], 10) * 6000;
          if (timer_tmp_array[11]) Count = Count + parseInt(timer_tmp_array[11], 10) * 100;
          if (timer_tmp_array[14]) Count = Count + parseInt(timer_tmp_array[14], 10) * 10;
          if (timer_tmp_array[17]) Count = Count + parseInt(timer_tmp_array[17], 10);
          if (Count > TimerLimit) Count = TimerLimit;
        }
        else if (args[1] == '逆行' || args[1].toUpperCase() == 'DOWN') {
          if (timer_tmp_array[2]) Count = Count - parseInt(timer_tmp_array[2], 10) * 8640000;
          if (timer_tmp_array[5]) Count = Count - parseInt(timer_tmp_array[5], 10) * 360000;
          if (timer_tmp_array[8]) Count = Count - parseInt(timer_tmp_array[8], 10) * 6000;
          if (timer_tmp_array[11]) Count = Count - parseInt(timer_tmp_array[11], 10) * 100;
          if (timer_tmp_array[14]) Count = Count - parseInt(timer_tmp_array[14], 10) * 10;
          if (timer_tmp_array[17]) Count = Count - parseInt(timer_tmp_array[17], 10);
          if (Count < 0) Count = 0;
        }
        if (!RunFlag && pictureId !== 0) $gameScreen.erasePicture(pictureId);
      }

    }
  };

  //=============================================================================
  // TimerInitialize
  //  プラグインコマンドで指定された値をセットします
  //=============================================================================

  function TimerInitialize() {
    OriginalTimer = null;
    SetFlag = false;
    RunFlag = false;
    DisplayMode = '';
    Count = 0;
    CountUnit = 0;
    CountTime = 0;
    CommndType = '';
    TimerType = '';
    TimerLimit = 0;
    day = 0;
    hr = 0;
    min = 0;
    sec = 0;
    Hsec = 0;
    TimerText = '';
    ShowText = '';
    pictureId = 0;
    fontsize = 32;
    name = '';
    origin = 0;
    x = 0;
    y = 0;
    scaleX = 100;
    scaleY = 100;
    opacity = 255;
    blendMode = 0;
    SwitchState = '';
    SwitchNumber = 0;
    if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
  };

  //=============================================================================
  // TimerSet
  //  プラグインコマンドで指定された値をセットします
  //=============================================================================

  function TimerSet(args) {
    if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
    TimerType = args[1];
    var timer_tmp_array = args[2].match(/((\d+)(d|日))?((\d+)(h|時間))?((\d+)(m|分間?))?((\d+)(s|秒間?))?((\d+)(x))?((\d+)(c))?/);
    TimerLimit = 0;
    if (timer_tmp_array[2]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[2], 10) * 8640000;
    if (timer_tmp_array[5]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[5], 10) * 360000;
    if (timer_tmp_array[8]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[8], 10) * 6000;
    if (timer_tmp_array[11]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[11], 10) * 100;
    if (timer_tmp_array[14]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[14], 10) * 10;
    if (timer_tmp_array[17]) TimerLimit = TimerLimit + parseInt(timer_tmp_array[17], 10);
    pictureId = parseInt(args[3], 10);
    fontsize = parseInt(args[4], 10);
    x = parseInt(args[5], 10);
    y = parseInt(args[6], 10);
    DisplayMode = args[7];
    if (DisplayMode == '非表示' || DisplayMode.toUpperCase() == 'HIDE') {
      opacity = 0;
      if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_DisplayMode = '非表示';
    } else {
      opacity = 255;
      if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_DisplayMode = '表示';
    }
    TimerText = args[8];
    if (args.length > 8) {
      for (var i = 9; i < args.length; i++) {
        TimerText = TimerText + ' ' + args[i];
      }
    }
    TimerText = TimerText.toUpperCase();
    Count = 0;
    CountUnit = 1000;
    if (~TimerText.indexOf('X') || ~args[2].indexOf('x')) CountUnit = 100;
    if (~TimerText.indexOf('C') || ~args[2].indexOf('x')) CountUnit = 10;
    if (TimerSave == 'YES') {
      $gameTimer._fftfanttOriginalTimer_TimerType = TimerType;
      $gameTimer._fftfanttOriginalTimer_TimerLimit = args[2];
      $gameTimer._fftfanttOriginalTimer_TimerText = TimerText;
      $gameTimer._fftfanttOriginalTimer_PctureId = pictureId;
      $gameTimer._fftfanttOriginalTimer_FontSize = fontsize;
      $gameTimer._fftfanttOriginalTimer_X = x;
      $gameTimer._fftfanttOriginalTimer_Y = y;
      $gameTimer._fftfanttOriginalTimer_DisplayMode = DisplayMode;
      $gameTimer._fftfanttOriginalTimer_TimerText = TimerText;
      $gameTimer._fftfanttOriginalTimer_Set = true;
    }
  }

  //=============================================================================
  // TimerRun
  //  タイマー実行時の処理
  //=============================================================================

  function TimerRun() {
    if (Count >= TimerLimit) {
      RunFlag = false;
      if (SwitchNumber > 0) {
        if (SwitchState = 'ON') SwitchState = true;
        if (SwitchState = 'OFF') SwitchState = false;
        if (SwitchState = 'REVERSE') {
          console.log(SwitchState)
          if ($gameSwitches._data[SwitchNumber] == null) SwitchState = false;
          SwitchState = !$gameSwitches._data[SwitchNumber]
        }
        $gameSwitches.setValue(SwitchNumber, SwitchState);
      }
      if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
      if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_Run = false;
    }
    if (!RunFlag) {
      clearInterval(OriginalTimer);
      return;
    }
    var now = getCurrentMsec();
    // NB: SceneManager.updateMain と同じ判定である事
    var fTime = (now - prevMsec) / 1000;
    if (fTime > 0.25) fTime = 0.25;
    Count = Count + Math.max(0, fTime * 100);
    prevMsec = now;
    if (TimerType == 'アップ' || TimerType.toUpperCase() == 'UP') {
      CountTime = Math.round(Count);
    } else {
      CountTime = TimerLimit - Math.round(Count);
    }
    day = parseInt(Math.floor(CountTime / 8640000), 10);
    hr = parseInt((CountTime % 8640000) / 360000, 10);
    min = parseInt((CountTime % 360000) / 6000, 10);
    sec = parseInt((CountTime % 6000) / 100, 10);
    Hsec = CountTime % 100;
    ShowText = TimerText;
    ShowText = ShowText.replace("D", day);
    ShowText = ShowText.replace("HH", ("0" + hr).slice(-2));
    ShowText = ShowText.replace("H", hr);
    ShowText = ShowText.replace("MM", ("0" + min).slice(-2));
    ShowText = ShowText.replace("M", min);
    ShowText = ShowText.replace("SS", ("0" + sec).slice(-2));
    ShowText = ShowText.replace("S", sec);
    ShowText = ShowText.replace("X", ("0" + Hsec).slice(-2).substr(0, 1));
    ShowText = ShowText.replace("C", ("0" + Hsec).slice(-2).substr(1, 1));
    name = 'OriginalTimer' + Date.now().toString();
    $gameScreen.showPicture(pictureId, name, origin, x, y, scaleX, scaleY, opacity, blendMode);
    if (TimerSave == 'YES') $gameTimer._fftfanttOriginalTimer_Count = Count;
  };

  //=============================================================================
  // TimerGet
  //  プラグインコマンドで指定されたタイマーの値を取得します
  //=============================================================================

  function TimerGet(args) {
    var GetType = args[1].toUpperCase
    if (args[1] == '表示値' || args[1].toUpperCase() == 'DISPLAYVALUE') {
      $gameVariables._data[parseInt(args[2], 10)] = ShowText;
      return;
    }
    if (args[1] == '値' || args[1].toUpperCase() == 'VALUE') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(CountTime, 10);
      return;
    }
    if (args[1] == 'セット値' || args[1].toUpperCase() == 'SETVALUE') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(TimerLimit, 10);
      return;
    }
    if (args[1] == '日' || args[1].toUpperCase() == 'DAY' || args[1].toUpperCase() == 'D') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(day, 10);
      return;
    }
    if (args[1] == '時' || args[1].toUpperCase() == 'HR' || args[1].toUpperCase() == 'H') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(hr, 10);
      return;
    }
    if (args[1] == '分' || args[1].toUpperCase() == 'MIN' || args[1].toUpperCase() == 'M') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(min, 10);
      return;
    }
    if (args[1] == '秒' || args[1].toUpperCase() == 'SEC' || args[1].toUpperCase() == 'S') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(sec, 10);
      return;
    }
    if (args[1] == 'コンマ秒' || args[1].toUpperCase() == 'HSEC' || args[1].toUpperCase() == 'XC') {
      $gameVariables._data[parseInt(args[2], 10)] = parseInt(Hsec, 10);
      return;
    }
    if (args[1] == '状態') {
      if (RunFlag) {
        $gameVariables._data[parseInt(args[2], 10)] = '実行中';
      } else {
        $gameVariables._data[parseInt(args[2], 10)] = '停止中'
      }
      return;
    }
    if (args[1].toUpperCase() == 'STATE') {
      if (RunFlag) {
        $gameVariables._data[parseInt(args[2], 10)] = 'RUN';
      } else {
        $gameVariables._data[parseInt(args[2], 10)] = 'STOP';
      }
      return;
    }
  }

  //=============================================================================
  // Sprite_Picture
  //  画像の動的生成を追加定義します。
  //=============================================================================

  var _Sprite_Picture_loadBitmap = Sprite_Picture.prototype.loadBitmap;
  Sprite_Picture.prototype.loadBitmap = function () {
    if (this.picture()._name == name) {
      this.fftfanttOriginalTimer_UpdateShowText();
    } else {
      _Sprite_Picture_loadBitmap.call(this);
    }
  };

  Sprite_Picture.prototype.fftfanttOriginalTimer_UpdateShowText = function (bitmap) {
    this.bitmap = new Bitmap(ShowText.length * fontsize + x, (fontsize + y) * 1.0);
    this.bitmap.fontSize = fontsize;
    this.bitmap.clear();
    this.bitmap.drawText(ShowText, x, y, 0, 0, "left");
  };

  //=============================================================================
  // Scene_Save
  //  TimerSaveがNOの場合、セーブ前にオリジナルタイマーのオブジェクトを削除します
  //=============================================================================

  var _Scene_Save_onSavefileOk = Scene_Save.prototype.onSavefileOk;
  Scene_Save.prototype.onSavefileOk = function () {
    if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
    if (TimerSave !== 'YES') {
      delete $gameTimer._fftfanttOriginalTimer_Count;
      delete $gameTimer._fftfanttOriginalTimer_Set;
      delete $gameTimer._fftfanttOriginalTimer_Run;
      delete $gameTimer._fftfanttOriginalTimer_Display;
      delete $gameTimer._fftfanttOriginalTimer_TimerType;
      delete $gameTimer._fftfanttOriginalTimer_TimerLimit;
      delete $gameTimer._fftfanttOriginalTimer_PctureId;
      delete $gameTimer._fftfanttOriginalTimer_FontSize;
      delete $gameTimer._fftfanttOriginalTimer_X;
      delete $gameTimer._fftfanttOriginalTimer_Y;
      delete $gameTimer._fftfanttOriginalTimer_DisplayMode;
      delete $gameTimer._fftfanttOriginalTimer_TimerText;
      delete $gameTimer._fftfanttOriginalTimer_SwitchState;
      delete $gameTimer._fftfanttOriginalTimer_SwitchNumber;
    }
    _Scene_Save_onSavefileOk.call(this);
  };

  //=============================================================================
  // Scene_Base
  //  戦闘終了後にピクチャが呼び出せないエラーを回避します
  //=============================================================================

  var _Scene_Base_prototype_isReady = Scene_Base.prototype.isReady;
  Scene_Base.prototype.isReady = function () {
    if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
    return _Scene_Base_prototype_isReady.call(this);
  };

  //=============================================================================
  // Scene_Load
  //  ロード時にタイマーを再実行するための処理追加定義します
  //=============================================================================

  var _Scene_Load_onLoadSuccess = Scene_Load.prototype.onLoadSuccess;
  Scene_Load.prototype.onLoadSuccess = function () {
    _Scene_Load_onLoadSuccess.call(this);
    Game_Timer.prototype.fftfanttOriginalTimer_Reinitiation();
  };

  //=============================================================================
  // Game_Timer
  //  オリジナルタイマー用のメソッドを追加定義します
  //=============================================================================

  Game_Timer.prototype.fftfanttOriginalTimer_Initialize = function () {
    if (TimerSave !== 'YES') return;
    if (pictureId !== 0) $gameScreen.erasePicture(pictureId);
    this._fftfanttOriginalTimer_Count = 0;
    this._fftfanttOriginalTimer_Set = false;
    this._fftfanttOriginalTimer_Run = false;
    this._fftfanttOriginalTimer_TimerType = '';
    this._fftfanttOriginalTimer_TimerLimit = 0;
    this._fftfanttOriginalTimer_PctureId = 0;
    this._fftfanttOriginalTimer_FontSize = 0;
    this._fftfanttOriginalTimer_X = 0;
    this._fftfanttOriginalTimer_Y = 0;
    this._fftfanttOriginalTimer_DisplayMode = '';
    this._fftfanttOriginalTimer_TimerText = '';
    this._fftfanttOriginalTimer_SwitchNumber = 0;
    this._fftfanttOriginalTimer_SwitchState = '';
  };

  Game_Timer.prototype.fftfanttOriginalTimer_Reinitiation = function () {
    if (TimerSave !== 'YES') return;
    if ($gameTimer == null) return;
    if (!Object.prototype.hasOwnProperty.call($gameTimer, '_fftfanttOriginalTimer_Set')) return;
    if (!$gameTimer._fftfanttOriginalTimer_Set) return;
    var args = [];
    args[0] = '設定';
    args[1] = $gameTimer._fftfanttOriginalTimer_TimerType;
    args[2] = $gameTimer._fftfanttOriginalTimer_TimerLimit;
    args[3] = $gameTimer._fftfanttOriginalTimer_PctureId;
    args[4] = $gameTimer._fftfanttOriginalTimer_FontSize;
    args[5] = $gameTimer._fftfanttOriginalTimer_X;
    args[6] = $gameTimer._fftfanttOriginalTimer_Y;
    args[7] = $gameTimer._fftfanttOriginalTimer_DisplayMode;
    args[8] = $gameTimer._fftfanttOriginalTimer_TimerText;
    SetFlag = $gameTimer._fftfanttOriginalTimer_Set
    RunFlag = $gameTimer._fftfanttOriginalTimer_Run
    SwitchState = $gameTimer._fftfanttOriginalTimer_SwitchState
    SwitchNumber = $gameTimer._fftfanttOriginalTimer_SwitchNumber
    TimerSet(args);
    Count = $gameTimer._fftfanttOriginalTimer_Count
    if (!RunFlag) return;
    clearInterval(OriginalTimer);
    prevMsec = getCurrentMsec();
    OriginalTimer = setInterval(TimerRun, CountUnit);
  };

})();


code:
//=============================================================================
// OverpassTile.js
//=============================================================================

/*:
 * @plugindesc Settings for bridges which characters can pass through.
 * @author Yoji Ojima
 *
 * @param Overpass Region ID
 * @desc The region ID for "overpass" such as bridges.
 * @default 255
 *
 * @param Gateway Region ID
 * @desc The region ID for "gateway" such as bridge ends.
 * @default 254
 *
 * @help
 *
 * This plugin uses region ID to determine a floor level.
 * In default, set 255 to bridge tiles and 254 to ends of them.
 *
 * Note: This plugin does not support the collision judgment modification
 *       between characters who are in different floors.
 */

/*:ja
 * @plugindesc キャラクターが下をくぐり抜けられる橋の設定です。
 * @author Yoji Ojima
 *
 * @param Overpass Region ID
 * @desc 橋などの立体交差部分に設定するリージョンIDです。
 * @default 255
 *
 * @param Gateway Region ID
 * @desc 橋の両端など、立体交差の入り口部分に設定するリージョンIDです。
 * @default 254
 *
 * @help
 *
 * このプラグインは、床の高さを決定するのにリージョンIDを使用します。
 * デフォルトでは橋の部分に255、その両端に254を設定してください。
 *
 * 注意：このプラグインは、異なる階層にいるキャラクター間の衝突判定修正は
 *       サポートしていません。
 */

(function () {

    var parameters = PluginManager.parameters('OverpassTile');
    var overpassRegionId = Number(parameters['Overpass Region ID'] || 255);
    var gatewayRegionId = Number(parameters['Gateway Region ID'] || 254);

    var _Tilemap_isOverpassPosition = Tilemap.prototype._isOverpassPosition;
    Tilemap.prototype._isOverpassPosition = function (mx, my) {
        var regionId = this._readMapData(mx, my, 5);
        if (regionId === overpassRegionId) {
            return true;
        } else {
            return _Tilemap_isOverpassPosition.call(this, mx, my);
        }
    };

    var _Game_CharacterBase_screenZ = Game_CharacterBase.prototype.screenZ;
    Game_CharacterBase.prototype.screenZ = function () {
        if (this._higherLevel) {
            return 5;
        } else {
            return _Game_CharacterBase_screenZ.call(this);
        }
    };

    var _Game_CharacterBase_isMapPassable =
        Game_CharacterBase.prototype.isMapPassable;
    Game_CharacterBase.prototype.isMapPassable = function (x, y, d) {
        if (_Game_CharacterBase_isMapPassable.call(this, x, y, d)) {
            var x2 = $gameMap.roundXWithDirection(x, d);
            var y2 = $gameMap.roundYWithDirection(y, d);
            var d2 = this.reverseDir(d);
            var regionId1 = $gameMap.regionId(x, y);
            var regionId2 = $gameMap.regionId(x2, y2);
            if (this._higherLevel && regionId1 !== gatewayRegionId) {
                return (regionId2 === gatewayRegionId ||
                    regionId2 === overpassRegionId);
            }
            if (!this._higherLevel && regionId1 === overpassRegionId) {
                if (regionId2 === overpassRegionId) {
                    var bit1 = (1 << (d / 2 - 1)) & 0x0f;
                    var bit2 = (1 << (d2 / 2 - 1)) & 0x0f;
                    var flags = $gameMap.tilesetFlags();
                    var tileId1 = $gameMap.tileId(x, y, 0);
                    var tileId2 = $gameMap.tileId(x, y, 1);
                    var tileId3 = $gameMap.tileId(x2, y2, 0);
                    var tileId4 = $gameMap.tileId(x2, y2, 1);
                    if ((flags[tileId1] | flags[tileId2]) & bit1) {
                        return false;
                    }
                    if ((flags[tileId3] | flags[tileId4]) & bit2) {
                        return false;
                    }
                }
                return regionId2 !== gatewayRegionId;
            }
            return true;
        } else {
            return false;
        }
    };

    var _Game_CharacterBase_refreshBushDepth =
        Game_CharacterBase.prototype.refreshBushDepth;
    Game_CharacterBase.prototype.refreshBushDepth = function () {
        _Game_CharacterBase_refreshBushDepth.call(this);
        var regionId = this.regionId();
        if (regionId === gatewayRegionId) {
            this._higherLevel = true;
        } else if (regionId !== overpassRegionId) {
            this._higherLevel = false;
        }
    };

})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// PD_DelayTitle.js
//=============================================================================

/*:
 * @plugindesc タイトル画面の各画像の表示にディレイとフェードイン機能を追加します。
 * @author Shio_inu
 *
 *
 * @param Delay BG1
 * @desc 背景1を表示開始するフレーム数です。
 * @default 0
 *
 * @param Fade BG1
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay BG2
 * @desc 背景1を表示開始するフレーム数です。
 * @default 60
 *
 * @param Fade BG2
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Title
 * @desc タイトルを表示開始するフレーム数です。
 * @default 120
 *
 * @param Fade Title
 * @desc タイトルのフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Command
 * @desc コマンドを表示するフレーム数です。
 * @default 180
 *
 * @param Pass To Decide
 * @desc 決定キーで演出をスキップできるかの設定です。1:スキップ出来る　0:スキップ出来ない
 * @default 1
 *
 * @help last update : 09th Jan 2016 v1.00
 *
 */

/*:ja
 * @plugindesc タイトル画面の各画像の表示にディレイとフェードイン機能を追加します。
 * @author しおいぬ
 *
 * @param Delay BG1
 * @desc 背景1を表示開始するフレーム数です。
 * @default 0
 *
 * @param Fade BG1
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay BG2
 * @desc 背景1を表示開始するフレーム数です。
 * @default 60
 *
 * @param Fade BG2
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Title
 * @desc タイトルを表示開始するフレーム数です。
 * @default 120
 *
 * @param Fade Title
 * @desc タイトルのフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Command
 * @desc コマンドを表示するフレーム数です。
 * @default 180
 *
 * @param Pass To Decide
 * @desc 決定キーで演出をスキップできるかの設定です。1:スキップ出来る　0:スキップ出来ない
 * @default 1
 * @help last update : 2016/01/09 v1.00
 *
 */
(function () {

    var parameters = PluginManager.parameters('PD_DelayTitle');
    var delayBG1 = Number(parameters['Delay BG1'] || 0);
    var fadeBG1 = Number(parameters['Fade BG1'] || 60);
    var delayBG2 = Number(parameters['Delay BG2'] || 0);
    var fadeBG2 = Number(parameters['Fade BG2'] || 60);
    var delayTitle = Number(parameters['Delay Title'] || 120);
    var fadeTitle = Number(parameters['Fade Title'] || 60);
    var delayCommand = Number(parameters['Delay Command'] || 180);
    var passToDecide = Boolean(parameters['Pass To Decide'] || false);

    var endFrame = Math.max(delayBG1 + fadeBG1, delayBG2 + fadeBG2, delayTitle + fadeTitle, delayCommand);

    Scene_Title.prototype.create = function () {
        Scene_Base.prototype.create.call(this);
        this.createBackground();
        this.createForeground();
        this.createWindowLayer();
        this.createCommandWindow();
        this._frame = 0;
    };

    Scene_Title.prototype.update = function () {
        Scene_Base.prototype.update.call(this);
        //スキップ
        if (passToDecide && (Input.isTriggered('ok') || TouchInput.isPressed()) && this._frame < endFrame) {
            this.skip();
        }
        //フェード開始確認
        if (this._frame === delayBG1) {
            if (fadeBG1 === 0) {
                this._backSprite1.opacity = 255;
            } else {
                this._backSprite1.opacity = 1;
            }
        }
        if (this._frame === delayBG2) {
            if (fadeBG2 === 0) {
                this._backSprite2.opacity = 255;
            } else {
                this._backSprite2.opacity = 1;
            }
        }
        if ($dataSystem.optDrawTitle && this._frame === delayTitle) {
            if (fadeTitle === 0) {
                this._gameTitleSprite.opacity = 255;
            } else {
                this._gameTitleSprite.opacity = 1;
            }
        }
        if (this._frame === delayCommand) {
            this._commandWindow.open();
        }
        //フェード処理
        if (this._backSprite1.opacity > 0 && this._backSprite1.opacity < 255) {
            this._backSprite1.opacity += 255 / fadeBG1;
        }
        if (this._backSprite2.opacity > 0 && this._backSprite2.opacity < 255) {
            this._backSprite2.opacity += 255 / fadeBG2;
        }
        if ($dataSystem.optDrawTitle && this._gameTitleSprite.opacity > 0 && this._gameTitleSprite.opacity < 255) {
            this._gameTitleSprite.opacity += 255 / fadeTitle;
        }

        this._frame++;
    }
    Scene_Title.prototype.createBackground = function () {
        this._spritebutton = new Sprite
        this._backSprite1 = new Sprite(ImageManager.loadTitle1($dataSystem.title1Name));
        this._backSprite2 = new Sprite(ImageManager.loadTitle2($dataSystem.title2Name));
        this._backSprite1.opacity = 0;
        this._backSprite2.opacity = 0;
        this.addChild(this._backSprite1);
        this.addChild(this._backSprite2);
    };

    Scene_Title.prototype.drawGameTitle = function () {
        var x = 20;
        var y = Graphics.height / 4;
        var maxWidth = Graphics.width - x * 2;
        var text = $dataSystem.gameTitle;
        this._gameTitleSprite.bitmap.outlineColor = 'black';
        this._gameTitleSprite.bitmap.outlineWidth = 8;
        this._gameTitleSprite.bitmap.fontSize = 72;
        this._gameTitleSprite.bitmap.drawText(text, x, y, maxWidth, 48, 'center');
        this._gameTitleSprite.opacity = 0;
    };

    Scene_Title.prototype.skip = function () {
        this._backSprite1.opacity = 255;
        this._backSprite2.opacity = 255;
        if ($dataSystem.optDrawTitle) {
            this._gameTitleSprite.opacity = 255;
        }
        this._commandWindow.open();
        this._frame = endFrame + 1;
    };
})();


code:
//=============================================================================
// ParallelPreload.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 2.0.1 2017/05/27 競合の可能性のある記述（Objectクラスへのプロパティ追加）をリファクタリング
// 2.0.0 2016/08/05 本体v1.3.0対応（1.2.0では使えなくなります）
//                  素材のプリロード時に発生するエラー(対象が存在しない等)を抑制するよう仕様変更
// 1.1.2 2016/07/23 コードのリファクタリングとヘルプの修正
// 1.1.1 2016/04/29 ログ出力を無効化するパラメータを追加
// 1.1.0 2016/04/28 音声素材の並列プリロードに対応
//                  他のプラグインの影響等で、特定のシーンでプリロードが止まってしまう問題を修正
// 1.0.1 2016/04/25 色相が0以外の画像がすべて0で表示されてしまう問題を修正
//                  色相に関する制約の説明を追加
//                  ブラウザプレー時、戦闘アニメの表示速度が著しく低下する問題を修正
//                  バトルテストとイベントテストが実行できなくなる問題を修正
// 1.0.0 2016/04/23 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 並列プリロードプラグイン
 * @author トリアコンタン
 *
 * @param 素材一覧データ
 * @desc 「/data」以下に配置するJSONファイル名
 * @default MV_Project
 *
 * @param ロード間隔
 * @desc ファイルをロードする間隔(フレーム単位)です。0に指定すると全てロードしてからゲーム開始します。(ブラウザ時は除く)
 * @default 0
 *
 * @param ログ出力
 * @desc ロードしたファイルパスをログに出力します。(テストプレー時のみ)
 * @default OFF
 *
 * @help ゲーム開始時に画像素材を並列ロードします。
 * 可能な限り負荷を分散、軽減するように設計されています。
 *
 * ロードする素材の一覧はfftfantt氏制作の「素材一覧用JSON作成プログラム」を
 * 使用してください。(2016/04/28時点でMITライセンス)
 * 同プログラムから必要な素材の一覧が作成されたJSONファイル
 * 「MV_Project.json」を作成して「/data」以下に配置します。
 * 作成する際は、「拡張子をつける」チェックを外してください。
 *
 * ・使い方
 * https://github.com/fftfantt/RPGMakerMV/wiki/JSON_Maker_for_MV
 *
 * ・本体
 * https://raw.githubusercontent.com/fftfantt/RPGMakerMV/master/JSON_Maker_for_MV.zip
 *
 * ブラウザから実行する場合、画像のロードが完了してから次のロードを開始します。
 * そのため、大量の画像を指定するとロード完了までに時間が掛かり
 * 効果が薄くなります。
 *
 * chromeでプレーする場合、大量に画像をロードすると処理速度が著しく低下します。
 * （本プラグインなしでも一定時間プレーすると発生する本体側の問題です）
 * その場合、下記を参考に対策プラグインの導入をお願いします。(本体ver1.2.0の場合)
 *
 * http://fanblogs.jp/tabirpglab/archive/422/0
 *
 * プリロードできるのは、色相が0の画像データのみです。
 * どうしても色相を変えた画像をロードしたい場合は「MV_Project.json」を
 * 該当箇所を以下の通り直接編集する必要があります。
 *
 * 例：色相が「100」の「Bat.png」をプリロードしたい場合
 * "Bat" -> "Bat:100"
 *
 * 注意！
 * このプラグインを適用したゲームをモバイルネットワークでプレーすると、
 * 通信量が膨大になる恐れがあります。必要に応じて注意喚起ください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

var $dataMaterials = null;

(function () {
    'use strict';
    var pluginName = 'ParallelPreload';

    var getParamString = function (paramNames) {
        var value = getParamOther(paramNames);
        return value === null ? '' : value;
    };

    var getParamNumber = function (paramNames, min, max) {
        var value = getParamOther(paramNames);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(value, 10) || 0).clamp(min, max);
    };

    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON';
    };

    var getParamOther = 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 iterate = function (that, handler) {
        Object.keys(that).forEach(function (key, index) {
            handler.call(that, key, that[key], index);
        });
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramMaterialListData = getParamString(['MaterialListData', '素材一覧データ']) + '.json';
    var paramLoadInterval = getParamNumber(['LoadInterval', 'ロード間隔']);
    var paramOutputLog = getParamBoolean(['OutputLog', 'ログ出力']);

    var localLoadComplete = false;
    var localIntervalCount = 0;

    //=============================================================================
    // DataManager
    //  ロード対象素材スタックの作成を追加定義します。
    //=============================================================================
    DataManager._databaseFiles.push(
        { name: '$dataMaterials', src: paramMaterialListData }
    );
    DataManager.materialFilePaths = null;

    var _DataManager_loadDataFile = DataManager.loadDataFile;
    DataManager.loadDataFile = function (name, src) {
        if (name === '$dataMaterials' && (this.isBattleTest() || this.isEventTest())) {
            arguments[1] = paramMaterialListData;
        }
        _DataManager_loadDataFile.apply(this, arguments);
    };

    var _DataManager_onLoad = DataManager.onLoad;
    DataManager.onLoad = function (object) {
        _DataManager_onLoad.apply(this, arguments);
        if (object === $dataMaterials) {
            this.initParallelPreload();
        }
    };

    DataManager.initParallelPreload = function () {
        this.materialFilePaths = [];
        iterate($dataMaterials, function (key, value) {
            for (var i = 0, n = value.length; i < n; i++) {
                this.materialFilePaths.push([key, value[i]]);
            }
        }.bind(this));
    };

    DataManager.loadMaterial = function () {
        var filePathInfo = this.materialFilePaths.shift();
        if (filePathInfo) {
            if (Utils.isOptionValid('test') && paramOutputLog) {
                console.log('Load material : ' + filePathInfo[0] + '/' + filePathInfo[1]);
            }
            var loadImageHandler = ImageManager.loadHandlers[filePathInfo[0]];
            if (loadImageHandler) this.loadImage(loadImageHandler, filePathInfo);
            var loadAudioHandler = AudioManager.loadHandlers[filePathInfo[0]];
            if (loadAudioHandler) this.loadAudio(loadAudioHandler, filePathInfo);
        } else {
            localLoadComplete = true;
        }
    };

    DataManager.loadImage = function (loadHandler, filePathInfo) {
        var key = filePathInfo[1].split(':');
        var hue = key.length > 1 ? parseInt(key[1], 10) : 0;
        var bitmap = ImageManager[loadHandler](key[0], hue);
        if (bitmap.isReady()) return;
        bitmap._isNeedLagDraw = true;
        bitmap._lagDrawHue = hue;
        if (Utils.isNwjs()) {
            localIntervalCount = paramLoadInterval;
        } else {
            localIntervalCount = Infinity;
            bitmap.addLoadListener(function () {
                localIntervalCount = paramLoadInterval;
            }.bind(this));
        }
    };

    DataManager.loadAudio = function (loadHandler, filePathInfo) {
        if (AudioManager.shouldUseHtml5Audio()) return;
        var audio = AudioManager[loadHandler](filePathInfo[0], filePathInfo[1]);
        if (Utils.isNwjs()) {
            localIntervalCount = paramLoadInterval;
        } else {
            localIntervalCount = Infinity;
            audio.addLoadListener(function () {
                localIntervalCount = paramLoadInterval;
            }.bind(this));
        }
    };

    //=============================================================================
    // SceneManager
    //  ロード処理を実行します。
    //=============================================================================
    var _SceneManager_updateScene = SceneManager.updateScene;
    SceneManager.updateScene = function () {
        _SceneManager_updateScene.apply(this, arguments);
        if (!localLoadComplete && DataManager.materialFilePaths) this.updateParallelPreload();
    };

    SceneManager.updateParallelPreload = function () {
        while (localIntervalCount <= 0 && !localLoadComplete) {
            DataManager.loadMaterial();
        }
        localIntervalCount--;
    };

    //=============================================================================
    // ImageManager
    //  ロード処理を実行します。
    //=============================================================================
    ImageManager.loadHandlers = {
        animations: 'loadAnimation',
        battlebacks1: 'loadBattleback1',
        battlebacks2: 'loadBattleback2',
        enemies: 'loadEnemy',
        characters: 'loadCharacter',
        faces: 'loadFace',
        parallaxes: 'loadParallax',
        pictures: 'loadPicture',
        sv_actors: 'loadSvActor',
        sv_enemies: 'loadSvEnemy',
        system: 'loadSystem',
        tilesets: 'loadTileset',
        titles1: 'loadTitle1',
        titles2: 'loadTitle2'
    };

    var _ImageManager_loadNormalBitmap = ImageManager.loadNormalBitmap;
    ImageManager.loadNormalBitmap = function (path, hue) {
        var bitmap = _ImageManager_loadNormalBitmap.apply(this, arguments);
        if (!bitmap.isReady()) bitmap._isNeedLagDraw = false;
        return bitmap;
    };

    var _ImageManager_isReady = ImageManager.isReady;
    ImageManager.isReady = function () {
        var result = _ImageManager_isReady.apply(this, arguments);
        if (result) return true;
        for (var key in this.cache._inner) {
            if (!this.cache._inner.hasOwnProperty(key)) continue;
            var bitmap = this.cache._inner[key].item;
            if (!bitmap.isReady() && !bitmap._isNeedLagDraw) {
                return false;
            }
        }
        return true;
    };

    var _ImageManager_isReady2 = ImageManager.isReady;
    ImageManager.isReady = function () {
        var result = false;
        try {
            result = _ImageManager_isReady2.apply(this, arguments);
        } catch (e) {
            for (var key in this.cache._inner) {
                if (!this.cache._inner.hasOwnProperty(key)) continue;
                var bitmap = this.cache._inner[key].item;
                if (bitmap.isError() && bitmap._isNeedLagDraw) {
                    bitmap.eraseError();
                    delete this.cache._inner[key];
                }
            }
            result = _ImageManager_isReady2.apply(this, arguments);
        }
        return result;
    };

    //=============================================================================
    // AudioManager
    //  ロード用のメソッド名を定義します。
    //=============================================================================
    AudioManager.loadHandlers = {
        bgm: 'createBuffer',
        bgs: 'createBuffer',
        se: 'createBuffer',
        me: 'createBuffer'
    };

    //=============================================================================
    // Bitmap
    //  ロードと描画のタイミングを分離します。
    //=============================================================================
    var _Bitmap__onLoad = Bitmap.prototype._onLoad;
    Bitmap.prototype._onLoad = function () {
        if (!this._isNeedLagDraw) {
            _Bitmap__onLoad.apply(this, arguments);
        } else {
            this._isLoading = false;
            this.resize(this._image.width, this._image.height);
            this._callLoadListeners();
        }
    };

    Bitmap.prototype.drawImage = function () {
        this._context.drawImage(this._image, 0, 0);
        if (this._lagDrawHue !== 0) {
            this.rotateHue(this._lagDrawHue);
        }
        this._setDirty();
        this._isNeedLagDraw = false;
    };

    Bitmap.prototype.drawImageIfNeed = function () {
        if (this._isNeedLagDraw) {
            if (this.isReady()) {
                this.drawImage();
            } else {
                this._isNeedLagDraw = false;
            }
        }
    };

    var _Bitmap_blt = Bitmap.prototype.blt;
    Bitmap.prototype.blt = function (source, sx, sy, sw, sh, dx, dy, dw, dh) {
        source.drawImageIfNeed();
        _Bitmap_blt.apply(this, arguments);
    };

    var _Bitmap_bltImage = Bitmap.prototype.bltImage;
    Bitmap.prototype.bltImage = function (source, sx, sy, sw, sh, dx, dy, dw, dh) {
        source.drawImageIfNeed();
        _Bitmap_bltImage.apply(this, arguments);
    };

    Bitmap.prototype.eraseError = function () {
        this._hasError = false;
        this._isLoading = false;
    };

    //=============================================================================
    // Sprite
    //  Bitmapのロード完了時に描画処理を実行します。
    //=============================================================================
    var _Sprite__onBitmapLoad = Sprite.prototype._onBitmapLoad;
    Sprite.prototype._onBitmapLoad = function () {
        if (this._bitmap) this._bitmap.drawImageIfNeed();
        _Sprite__onBitmapLoad.apply(this, arguments);
    };

    //=============================================================================
    // TilingSprite
    //  Bitmapのロード完了時に描画処理を実行します。
    //=============================================================================
    var _TilingSprite__onBitmapLoad = TilingSprite.prototype._onBitmapLoad;
    TilingSprite.prototype._onBitmapLoad = function () {
        if (this._bitmap) this._bitmap.drawImageIfNeed();
        _TilingSprite__onBitmapLoad.apply(this, arguments);
    };

    //=============================================================================
    // Spriteset_Map
    //  タイルセットはすぐに描画します。
    //=============================================================================
    var _Spriteset_Map_loadTileset = Spriteset_Map.prototype.loadTileset;
    Spriteset_Map.prototype.loadTileset = function () {
        _Spriteset_Map_loadTileset.apply(this, arguments);
        if (this._tileset) {
            this._tilemap.bitmaps.forEach(function (bitmap) {
                bitmap.drawImageIfNeed();
            });
        }
    };
})();


code:
// --------------------------------------------------------------------------
//
// PickupSkill
//
// Copyright (c) kotonoha*
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
//
// 2016/09/23 ver1.0 プラグイン公開
//
// --------------------------------------------------------------------------
/*:
 * @plugindesc 任意のスキルを直接コマンドから選択出来る様にするプラグイン
 * @author kotonoha*
 *
 * @help 任意のスキルを直接コマンドから選択出来る様にするプラグイン
 *
 * @param PickupSkillName
 * @desc コマンドに配置するスキル名
 * @default スキル
 *
 * @param PickupSkillId
 * @desc コマンドで発動するスキルID
 * @default 0
 *
 * @param PickupTarget
 * @desc コマンドのターゲット指定 (0:しない / 1:敵単体 / 2:味方単体)
 * ※全体化・ランダム・使用者対象のスキルは0を指定
 * @default 0
 *
 * @help アクターのメモ欄に
 * <PickupSkill>
 * と入力したキャラクターのコマンド欄に設定したスキルが表示されます。
 *
 */

(function () {

	var parameters = PluginManager.parameters('PickupSkill');
	var PickupSkillName = String(parameters['PickupSkillName']);
	var PickupSkillId = Number(parameters['PickupSkillId'] || 0);
	var PickupTarget = Number(parameters['PickupTarget'] || 0);

	Window_ActorCommand.prototype.makeCommandList = function () {
		if (this._actor) {
			this.addAttackCommand();
			if ($dataActors[this._actor._actorId].note.match(/<PickupSkill>/i)) {
				this.addPickupCommand();
			}
			this.addSkillCommands();
			this.addGuardCommand();
			this.addItemCommand();
		}
	};

	var _Scene_Battle_prototype_createActorCommandWindow = Scene_Battle.prototype.createActorCommandWindow;
	Scene_Battle.prototype.createActorCommandWindow = function () {
		_Scene_Battle_prototype_createActorCommandWindow.call(this);
		this._actorCommandWindow.setHandler('Pickup', this.commandPickup.bind(this));
	};

	Window_ActorCommand.prototype.addPickupCommand = function () {
		this.addCommand(PickupSkillName, 'Pickup', this._actor.canPickup());
	};

	Game_BattlerBase.prototype.canPickup = function () {
		return this.canUse($dataSkills[PickupSkillId]);
	};

	Scene_Battle.prototype.commandPickup = function () {
		BattleManager.inputtingAction().setPickup();
		if (PickupTarget === 0) {
			this.selectNextCommand();
		} else if (PickupTarget === 1) {
			this.selectEnemySelection();
		} else {
			this.selectActorSelection();
		}
	};

	Game_Action.prototype.setPickup = function () {
		this.setSkill(PickupSkillId);
	};

})();


code:
//=============================================================================
// PictureAnimation.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.4.0 2016/09/03 アニメーションに合わせて指定したSEを演奏する機能を追加
// 1.3.2 2016/05/11 クロスフェードを指定していた場合に2回目のアニメ表示でエラーになる場合がある問題を修正
// 1.3.1 2016/03/15 ピクチャ上に戦闘アニメを表示するプラグイン「PictureOnAnimation」との競合を解消
//                  原点を中央したピクチャにクロスフェードを行うと表示位置がずれる問題を修正
// 1.3.0 2016/02/28 セル番号を変数と連動する機能を追加
//                  処理の負荷を少し軽減
// 1.2.3 2016/02/07 戦闘画面でもピクチャのアニメーションができるように修正
// 1.2.2 2016/01/24 空のピクチャを表示しようとした際にエラーが発生する現象を修正
// 1.2.1 2016/01/16 同じ画像を指定してピクチャ表示→アニメーション準備→ピクチャ表示の順で実行した
//                  場合にエラーが発生する現象の修正
// 1.2.0 2016/01/04 セルのパターンを自由に指定できる機能を追加
//                  セルの最大数を100から200に拡大
// 1.1.2 2015/12/24 クロスフェードによる画像切替に対応しました
// 1.1.1 2015/12/21 ピクチャのファイル名を連番方式で指定できる機能を追加
//                  アニメーションの強制終了の機能を追加
// 1.0.0 2015/12/19 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc ピクチャのアニメーションプラグイン
 * @author トリアコンタン
 *
 * @help 指定したフレーム間隔でピクチャをアニメーションします。
 * アニメーションしたいセル画像（※）を用意の上
 * 以下のコマンドを入力してください。
 *
 * 1. ピクチャのアニメーション準備（プラグインコマンド）
 * 2. ピクチャの表示（通常のイベントコマンド）
 * 3. ピクチャのアニメーション開始（プラグインコマンド）
 * 4. ピクチャのアニメーション終了（プラグインコマンド）
 *
 * ※配置方法は以下の3通りがあります。
 *  縦　：セルを縦に並べて全体を一つのファイルにします。
 *  横　：セルを横に並べて全体を一つのファイルにします。
 *  連番：連番のセル画像を複数用意します。(original部分は任意の文字列)
 *   original00.png(ピクチャの表示で指定するオリジナルファイル)
 *   original01.png
 *   original02.png...
 *
 * 要注意！　配置方法の連番を使う場合、デプロイメント時に
 * 未使用ファイルとして除外される可能性があります。
 * その場合、削除されたファイルを入れ直す等の対応が必要です。
 *
 * また、単にアニメーションさせる以外にも、プラグインコマンドから
 * セル番号を直接指定したり、変数の値とセル番号を連動させたりできます。
 * 紙芝居のような演出や、条件次第で立ち絵の表示状態を変化させたりする場合に
 * 有効です。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 *  PA_INIT or
 *  ピクチャのアニメーション準備 [セル数] [フレーム数] [セル配置方法] [フェード時間]
 *  　ピクチャをアニメーション対象にする準備をします。
 *  　「ピクチャの表示」の直前に実行してください。
 *  　セル数　　　：アニメーションするセル画の数（最大200枚）
 *  　フレーム数　：アニメーション間隔のフレーム数（最低でも1を設定）
 *  　セル配置方向：セルの配置（縦 or 横 or 連番）
 *  　フェード時間：画像切替に掛かるフレーム数（0にするとフェードしない）
 *  使用例：PA_INIT 4 10 連番 20
 *
 *  PA_START or
 *  ピクチャのアニメーション開始 [ピクチャ番号] [アニメーションタイプ] [カスタムパターン配列]
 *  　指定したピクチャ番号のピクチャをアニメーションを開始します。
 *  　一周するとアニメーションは自動で止まります。
 *
 *  　アニメーションのタイプは以下の3パターンがあります。
 *  　　例：セル数が 4 の場合
 *  　　　タイプ1: 1→2→3→4→1→2→3→4...
 *  　　　タイプ2: 1→2→3→4→3→2→1→2...
 *  　　　タイプ3: 好きな順番を配列で指定（セルの最小値は 1 です）
 *  使用例：PA_START 1 2
 *  　　　　PA_START 1 3 [1,2,1,3,1,4]
 *
 *  PA_START_LOOP or
 *  ピクチャのループアニメーション開始 [ピクチャ番号] [アニメーションタイプ] [カスタムパターン配列]
 *  　指定したピクチャ番号のピクチャをアニメーションを開始します。
 *  　明示的に終了するまでアニメーションが続きます。
 *  使用例：PA_START_LOOP 1 2
 *  　　　　PA_START_LOOP 1 3 [1,2,1,3,1,4]
 *
 *  PA_STOP or
 *  ピクチャのアニメーション終了 [ピクチャ番号]
 *  　指定したピクチャ番号のピクチャをアニメーションを終了します。
 *  　一番上のセルに戻った時点でアニメーションが止まります。
 *  使用例：PA_STOP 1
 *
 *  PA_STOP_FORCE or
 *  ピクチャのアニメーション強制終了 [ピクチャ番号]
 *  　指定したピクチャ番号のピクチャをアニメーションを終了します。
 *  　現在表示しているセルでアニメーションが止まります。
 *  使用例：PA_STOP_FORCE 1
 *
 *  PA_SET_CELL or
 *  ピクチャのアニメーションセル設定 [ピクチャ番号] [セル番号] [ウェイトあり]
 *  　アニメーションのセルを直接設定します。（セルの最小値は 1 です）
 *  　任意のタイミングでアニメーションしたい場合に有効です。
 *  　ウェイトありを設定すると、クロスフェード中はイベントの実行を待機します。
 *  使用例：PA_SET_CELL 1 3 ウェイトあり
 *
 *  PA_PROG_CELL or
 *  ピクチャのアニメーションセル進行 [ピクチャ番号] [ウェイトあり]
 *  　アニメーションのセルをひとつ先に進めます。
 *  　任意のタイミングでアニメーションしたい場合に有効です。
 *  　ウェイトありを設定すると、クロスフェード中はイベントの実行を待機します。
 *  使用例：PA_PROG_CELL 1 ウェイトあり
 *
 *  PA_SET_VARIABLE or
 *  ピクチャのアニメーションセル変数の設定 [ピクチャ番号] [変数番号]
 *  　アニメーションのセルを指定した変数と連動させます。
 *  　変数の値が変化すると表示しているセルも自動的に変化します。
 *  使用例：PA_SET_VARIABLE 1 2
 *
 *  PA_SOUND or
 *  ピクチャのアニメーション効果音予約 [セル番号]
 *  　アニメーションのセルが切り替わったタイミングで効果音を演奏します。
 *  　このコマンドの直後にイベントコマンド「SEの演奏」を実行すると
 *  　その場でSEは演奏されず、ピクチャのアニメーション開始後に指定のタイミングで
 *  　演奏されるようになります。
 *  　必ずピクチャのアニメーション開始前に実行してください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function () {
    'use strict';
    var settings = {
        /* maxCellAnimation:セル数の最大値 */
        maxCellAnimation: 200
    };

    //=============================================================================
    // ローカル関数
    //  プラグインパラメータやプラグインコマンドパラメータの整形やチェックをします
    //=============================================================================
    var getCommandName = function (command) {
        return (command || '').toUpperCase();
    };

    var getArgArrayString = function (args, upperFlg) {
        var values = getArgString(args, upperFlg);
        return (values || '').split(',');
    };

    var getArgArrayNumber = function (args, min, max) {
        var values = getArgArrayString(args, false);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        for (var i = 0; i < values.length; i++) values[i] = (parseInt(values[i], 10) || 0).clamp(min, max);
        return values;
    };

    var getArgString = function (arg, upperFlg) {
        arg = convertEscapeCharacters(arg);
        return upperFlg ? arg.toUpperCase() : arg;
    };

    var getArgNumber = function (arg, min, max) {
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(convertEscapeCharacters(arg), 10) || 0).clamp(min, max);
    };

    var convertEscapeCharacters = function (text) {
        if (text == null) text = '';
        var window = SceneManager._scene._windowLayer.children[0];
        return window ? window.convertEscapeCharacters(text) : text;
    };

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        try {
            this.pluginCommandPictureAnimation(command, args);
        } catch (e) {
            if ($gameTemp.isPlaytest() && Utils.isNwjs()) {
                var window = require('nw.gui').Window.get();
                if (!window.isDevToolsOpen()) {
                    var devTool = window.showDevTools();
                    devTool.moveTo(0, 0);
                    devTool.resizeTo(Graphics.width, Graphics.height);
                    window.focus();
                }
            }
            console.log('プラグインコマンドの実行中にエラーが発生しました。');
            console.log('- コマンド名 　: ' + command);
            console.log('- コマンド引数 : ' + args);
            console.log('- エラー原因   : ' + e.toString());
        }
    };

    Game_Interpreter.prototype.pluginCommandPictureAnimation = function (command, args) {
        var pictureNum, animationType, picture, cellNumber, frameNumber, direction, fadeDuration, wait, customArray;
        switch (getCommandName(command)) {
            case 'PA_INIT':
            case 'ピクチャのアニメーション準備':
                cellNumber = getArgNumber(args[0], 1, settings.maxCellAnimation);
                frameNumber = getArgNumber(args[1], 1, 9999);
                direction = getArgString(args[2], true) || '縦';
                fadeDuration = getArgNumber(args[3], 0, 9999) || 0;
                $gameScreen.setPicturesAnimation(cellNumber, frameNumber, direction, fadeDuration);
                break;
            case 'PA_SOUND':
            case 'ピクチャのアニメーション効果音予約':
                cellNumber = getArgNumber(args[0], 1, settings.maxCellAnimation);
                this.reservePaSound(cellNumber);
                break;
            case 'PA_START':
            case 'ピクチャのアニメーション開始':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                animationType = getArgNumber(args[1], 1, 3);
                customArray = getArgArrayNumber(args[2], 1, settings.maxCellAnimation);
                picture = $gameScreen.picture(pictureNum);
                if (picture) picture.startAnimationFrame(animationType, false, customArray);
                break;
            case 'PA_START_LOOP':
            case 'ピクチャのループアニメーション開始':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                animationType = getArgNumber(args[1], 1, 3);
                customArray = getArgArrayNumber(args[2], 1, settings.maxCellAnimation);
                picture = $gameScreen.picture(pictureNum);
                if (picture) picture.startAnimationFrame(animationType, true, customArray);
                break;
            case 'PA_STOP':
            case 'ピクチャのアニメーション終了':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                picture = $gameScreen.picture(pictureNum);
                if (picture) picture.stopAnimationFrame(false);
                break;
            case 'PA_STOP_FORCE':
            case 'ピクチャのアニメーション強制終了':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                picture = $gameScreen.picture(pictureNum);
                if (picture) picture.stopAnimationFrame(true);
                break;
            case 'PA_SET_CELL':
            case 'ピクチャのアニメーションセル設定':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                cellNumber = getArgNumber(args[1], 1, settings.maxCellAnimation);
                wait = getArgString(args[2]);
                picture = $gameScreen.picture(pictureNum);
                if (picture) {
                    if (wait === 'ウェイトあり' || wait.toUpperCase() === 'WAIT') this.wait(picture._fadeDuration);
                    picture.cell = cellNumber;
                }
                break;
            case 'PA_PROG_CELL':
            case 'ピクチャのアニメーションセル進行':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                wait = getArgString(args[1]);
                picture = $gameScreen.picture(pictureNum);
                if (picture) {
                    if (wait === 'ウェイトあり' || wait.toUpperCase() === 'WAIT') this.wait(picture._fadeDuration);
                    picture.addCellCount();
                }
                break;
            case 'PA_SET_VARIABLE':
            case 'ピクチャのアニメーションセル変数の設定':
                pictureNum = getArgNumber(args[0], 1, $gameScreen.maxPictures());
                picture = $gameScreen.picture(pictureNum);
                if (picture) picture.linkToVariable(getArgNumber(args[1]));
                break;
        }
    };

    Game_Interpreter.prototype.reservePaSound = function (cellNumber) {
        this._paSoundFrame = cellNumber;
    };

    var _Game_Interpreter_command250 = Game_Interpreter.prototype.command250;
    Game_Interpreter.prototype.command250 = function () {
        if (this._paSoundFrame) {
            var se = this._params[0];
            AudioManager.loadStaticSe(se);
            $gameScreen.addPaSound(se, this._paSoundFrame);
            this._paSoundFrame = null;
            return true;
        }
        return _Game_Interpreter_command250.apply(this, arguments);
    };

    //=============================================================================
    // Game_Screen
    //  アニメーション関連の情報を追加で保持します。
    //=============================================================================
    Game_Screen.prototype.setPicturesAnimation = function (cellNumber, frameNumber, direction, fadeDuration) {
        this._paCellNumber = cellNumber;
        this._paFrameNumber = frameNumber;
        this._paDirection = direction;
        this._paFadeDuration = fadeDuration;
    };

    Game_Screen.prototype.addPaSound = function (sound, frame) {
        if (!this._paSounds) this._paSounds = [];
        this._paSounds[frame] = sound;
    };

    Game_Screen.prototype.clearPicturesAnimation = function () {
        this._paCellNumber = 1;
        this._paFrameNumber = 1;
        this._paDirection = '';
        this._paFadeDuration = 0;
        this._paSounds = null;
    };

    var _Game_Screen_showPicture = Game_Screen.prototype.showPicture;
    Game_Screen.prototype.showPicture = function (pictureId, name, origin, x, y,
        scaleX, scaleY, opacity, blendMode) {
        _Game_Screen_showPicture.apply(this, arguments);
        var realPictureId = this.realPictureId(pictureId);
        if (this._paCellNumber > 1) {
            this._pictures[realPictureId].setAnimationFrameInit(
                this._paCellNumber, this._paFrameNumber, this._paDirection, this._paFadeDuration, this._paSounds);
            this.clearPicturesAnimation();
        }
    };

    //=============================================================================
    // Game_Picture
    //  アニメーション関連の情報を追加で保持します。
    //=============================================================================
    var _Game_Picture_initialize = Game_Picture.prototype.initialize;
    Game_Picture.prototype.initialize = function () {
        _Game_Picture_initialize.call(this);
        this.initAnimationFrameInfo();
    };

    Game_Picture.prototype.initAnimationFrameInfo = function () {
        this._cellNumber = 1;
        this._frameNumber = 1;
        this._cellCount = 0;
        this._frameCount = 0;
        this._animationType = 0;
        this._customArray = null;
        this._loopFlg = false;
        this._direction = '';
        this._fadeDuration = 0;
        this._fadeDurationCount = 0;
        this._prevCellCount = 0;
        this._animationFlg = false;
        this._linkedVariable = 0;
        this._cellSes = [];
    };

    Game_Picture.prototype.direction = function () {
        return this._direction;
    };

    Game_Picture.prototype.cellNumber = function () {
        return this._cellNumber;
    };

    Game_Picture.prototype.prevCellCount = function () {
        return this._prevCellCount;
    };

    Game_Picture.prototype.isMulti = function () {
        var dir = this.direction();
        return dir === '連番' || dir === 'N';
    };

    /**
     * The cellCount of the Game_Picture (0 to cellNumber).
     *
     * @property cellCount
     * @type Number
     */
    Object.defineProperty(Game_Picture.prototype, 'cell', {
        get: function () {
            if (this._linkedVariable > 0) {
                return $gameVariables.value(this._linkedVariable) % this._cellNumber;
            }
            switch (this._animationType) {
                case 3:
                    return (this._customArray[this._cellCount] - 1).clamp(0, this._cellNumber - 1);
                case 2:
                    return this._cellNumber - 1 - Math.abs(this._cellCount - (this._cellNumber - 1));
                case 1:
                    return this._cellCount;
                default:
                    return this._cellCount;
            }
        },
        set: function (value) {
            var newCellCount = value % this.getCellNumber();
            if (this._cellCount !== newCellCount) {
                this._prevCellCount = this.cell;
                this._fadeDurationCount = this._fadeDuration;
            }
            this._cellCount = newCellCount;
        },
        configurable: true
    });

    Game_Picture.prototype.getCellNumber = function () {
        switch (this._animationType) {
            case 3:
                return this._customArray.length;
            case 2:
                return (this._cellNumber - 1) * 2;
            case 1:
                return this._cellNumber;
            default:
                return this._cellNumber;
        }
    };

    var _Game_Picture_update = Game_Picture.prototype.update;
    Game_Picture.prototype.update = function () {
        _Game_Picture_update.call(this);
        if (this.isFading()) {
            this.updateFading();
        } else if (this.hasAnimationFrame()) {
            this.updateAnimationFrame();
        }
    };

    Game_Picture.prototype.linkToVariable = function (variableNumber) {
        this._linkedVariable = variableNumber.clamp(1, $dataSystem.variables.length);
    };

    Game_Picture.prototype.updateAnimationFrame = function () {
        this._frameCount = (this._frameCount + 1) % this._frameNumber;
        if (this._frameCount === 0) {
            this.addCellCount();
            this.playCellSe();
            if (this._cellCount === 0 && !this._loopFlg) {
                this._animationFlg = false;
            }
        }
    };

    Game_Picture.prototype.updateFading = function () {
        this._fadeDurationCount--;
    };

    Game_Picture.prototype.prevCellOpacity = function () {
        if (this._fadeDuration === 0) return 0;
        return this.opacity() / this._fadeDuration * this._fadeDurationCount;
    };

    Game_Picture.prototype.addCellCount = function () {
        this.cell = this._cellCount + 1;
    };

    Game_Picture.prototype.playCellSe = function () {
        var se = this._cellSes[this.cell + 1];
        if (se) {
            AudioManager.playSe(se);
        }
    };

    Game_Picture.prototype.setAnimationFrameInit = function (cellNumber, frameNumber, direction, fadeDuration, cellSes) {
        this._cellNumber = cellNumber;
        this._frameNumber = frameNumber;
        this._frameCount = 0;
        this._cellCount = 0;
        this._direction = direction;
        this._fadeDuration = fadeDuration;
        this._cellSes = cellSes || [];
    };

    Game_Picture.prototype.startAnimationFrame = function (animationType, loopFlg, customArray) {
        this._animationType = animationType;
        this._customArray = customArray;
        this._animationFlg = true;
        this._loopFlg = loopFlg;
    };

    Game_Picture.prototype.stopAnimationFrame = function (forceFlg) {
        this._loopFlg = false;
        if (forceFlg) this._animationFlg = false;
    };

    Game_Picture.prototype.hasAnimationFrame = function () {
        return this._animationFlg;
    };

    Game_Picture.prototype.isFading = function () {
        return this._fadeDurationCount !== 0;
    };

    Game_Picture.prototype.isNeedFade = function () {
        return this._fadeDuration !== 0;
    };

    //=============================================================================
    // Sprite_Picture
    //  アニメーション関連の情報を追加で保持します。
    //=============================================================================
    var _Sprite_Picture_initialize = Sprite_Picture.prototype.initialize;
    Sprite_Picture.prototype.initialize = function (pictureId) {
        this._prevSprite = null;
        _Sprite_Picture_initialize.apply(this, arguments);
    };

    var _Sprite_Picture_update = Sprite_Picture.prototype.update;
    Sprite_Picture.prototype.update = function () {
        _Sprite_Picture_update.apply(this, arguments);
        var picture = this.picture();
        if (picture && picture.name()) {
            if (picture.isMulti() && !this._bitmaps) {
                this.loadAnimationBitmap();
            }
            if (this.isBitmapReady()) {
                this.updateAnimationFrame(this, picture.cell);
                if (picture.isNeedFade()) this.updateFading();
            }
        }
    };

    var _Sprite_Picture_updateBitmap = Sprite_Picture.prototype.updateBitmap;
    Sprite_Picture.prototype.updateBitmap = function () {
        _Sprite_Picture_updateBitmap.apply(this, arguments);
        if (!this.picture()) {
            this._bitmaps = null;
            if (this._prevSprite) {
                this._prevSprite.bitmap = null;
            }
        }
    };

    Sprite_Picture.prototype.updateFading = function () {
        if (!this._prevSprite) {
            this.makePrevSprite();
        }
        if (!this._prevSprite.bitmap) {
            this.makePrevBitmap();
        }
        var picture = this.picture();
        if (picture.isFading()) {
            this._prevSprite.visible = true;
            this.updateAnimationFrame(this._prevSprite, picture.prevCellCount());
            this._prevSprite.opacity = picture.prevCellOpacity();
        } else {
            this._prevSprite.visible = false;
        }
    };

    Sprite_Picture.prototype.updateAnimationFrame = function (sprite, cellCount) {
        switch (this.picture().direction()) {
            case '連番':
            case 'N':
                sprite.bitmap = this._bitmaps[cellCount];
                sprite.setFrame(0, 0, sprite.bitmap.width, sprite.bitmap.height);
                break;
            case '縦':
            case 'V':
                var height = sprite.bitmap.height / this.picture().cellNumber();
                var y = cellCount * height;
                sprite.setFrame(0, y, sprite.bitmap.width, height);
                break;
            case '横':
            case 'H':
                var width = sprite.bitmap.width / this.picture().cellNumber();
                var x = cellCount * width;
                sprite.setFrame(x, 0, width, this.bitmap.height);
                break;
        }
    };

    var _Sprite_Picture_loadBitmap = Sprite_Picture.prototype.loadBitmap;
    Sprite_Picture.prototype.loadBitmap = function () {
        _Sprite_Picture_loadBitmap.apply(this, arguments);
        this._bitmapReady = false;
        this._bitmaps = null;
    };

    Sprite_Picture.prototype.loadAnimationBitmap = function () {
        var cellNumber = this.picture().cellNumber();
        var cellDigit = cellNumber.toString().length;
        this._bitmaps = [this.bitmap];
        for (var i = 1; i < cellNumber; i++) {
            var filename = this._pictureName.substr(0, this._pictureName.length - cellDigit) + i.padZero(cellDigit);
            this._bitmaps[i] = ImageManager.loadPicture(filename);
        }
        this._bitmapReady = false;
    };

    Sprite_Picture.prototype.makePrevSprite = function () {
        this._prevSprite = new Sprite();
        this._prevSprite.visible = false;
        this.addChild(this._prevSprite);
    };

    Sprite_Picture.prototype.makePrevBitmap = function () {
        this._prevSprite.bitmap = this.bitmap;
        this._prevSprite.anchor.x = this.anchor.x;
        this._prevSprite.anchor.y = this.anchor.y;
    };

    Sprite_Picture.prototype.isBitmapReady = function () {
        if (!this.bitmap) return false;
        if (this._bitmapReady) return true;
        var result;
        if (this.picture().isMulti()) {
            result = this._bitmaps.every(function (bitmap) {
                return bitmap.isReady();
            });
        } else {
            result = this.bitmap.isReady();
        }
        this._bitmapReady = result;
        return result;
    };
})();


code:
//=============================================================================
// PictureLoop.js
//=============================================================================

/*:
 * @plugindesc ピクチャをランダム間隔で表示させます
 * @author riru
 *
 * @param Pictureloop Count1
 * @desc まばたき用ベース間隔。
 * @default 60
 *
 * @param Pictureloop Count2
 * @desc まばたき用ランダム間隔。ベース間隔＋この数値までのランダムで出た間隔でまばたきします
 * @default 100
 *
 * @help
 *
 * まばたきプラグイン ver 1.01
 *
 *＜使い方＞
 *イベントコマンド「スクリプト」で以下のように記述してください
 *LoopPicture(ピクチャ番号,閉じかけ目ピクチャネーム,閉じ目ピクチャネーム, 原点, x, y, X拡大率, Y拡大率, 不透明度, 合成方法);
 *
 *ピクチャ番号…イベントコマンド「ピクチャの表示」の番号と同じです。数字が多いほど上に表示されます。通常のピクチャと共有なので、同時に表示させたいピクチャと番号が被らないようにしてください
 *原点…〃表示位置と同じです。0で左上、1で中心が原点になりま
 *拡大率…100で原寸です。-をつけると反転します。
 *不透明度…0～255で設定できます。数字が低いほど透明になります
 *合成方法…ピクチャの表示の合成方法と同じです。0で通常、1で加算、2で乗算になります
 *※数字の場所は
 *
 *例：LoopPicture(1,"actor1tojikake","actortoji", 0, 10, 80, -100, 100, 255, 0);
 *ピクチャ名が長い場合は代入してもOKです
 *name = "actor1tojikake";
 *name2 = "actor1tojikake";
 *x = $gameVariables.value(5);
 *y = $gameVariables.value(6);
 *LoopPicture(7,name,name2, 0, x, y, 100, 100, 255, 0);
 *
 *瞬きをとめる場合は同じくイベントコマンドスクリプトで以下を記入
 *EraseLoopPicture(瞬きしているピクチャ番号);
 *例：EraseLoopPicture(7);
 * ＜規約＞
 * 有償無償問わず使用できます。改変もご自由にどうぞ。使用報告もいりません。２次配布は作成者を偽らなければOKです（ただし素材単品を有償でやりとりするのはNG）。
 *著作権は放棄していません。使用する場合は以下の作者とURLをreadmeなどどこかに記載してください
 *
 * ＜作者情報＞
 *作者：riru
 *HP：ガラス細工の夢幻
 *URL：http://garasuzaikunomugen.web.fc2.com/index.html
 *
 *＜更新情報＞
 *2015/11/21　1.00公開。
 *2015/12/23　1.01。バトル中では反映されない不具合を修正。
 */

var parameters = PluginManager.parameters('PictureLoop');
var PictureloopCount1 = Number(parameters['Pictureloop Count1'] || 60);
var PictureloopCount2 = Number(parameters['Pictureloop Count2'] || 100);

function LoopPicture(layer, name, name2, origin, x, y, scaleX, scaleY, opacity, blendMode) {
   $gameScreen.CreateLoopPictureCount(layer);
   $gameScreen.CreateLoopPicture(layer, name, name2, origin, x, y, scaleX, scaleY, opacity, blendMode);
};
LoopPictures = new Array(100);
LoopPictureCount_rand = new Array(100);
LoopPicture_v = 0;//現在瞬きしている数
//まばたき用ピクチャの消去
function EraseLoopPicture(layer) {
   if (typeof LoopPictures[layer] != null) LoopPicture_v -= 1;
   LoopPictureCount[layer] = null;
   LoopPictures[layer] = null;
   var realPictureId = $gameScreen.realPictureId(layer);
   if ($gameScreen._pictures[realPictureId] != null) $gameScreen.erasePicture(layer);
};
//ループピクチャの情報作成
Game_Screen.prototype.CreateLoopPicture = function (layer, name, name2, origin, x, y, scaleX, scaleY, opacity, blendMode) {
   LoopPictures[layer] = [layer, name, name2, origin, x, y, scaleX, scaleY, opacity, blendMode];
   LoopPicture_v += 1;
   LoopPictureCount_rand[layer] = [];
   LoopPictureCount_rand[layer] = (Math.floor((Math.random() * PictureloopCount2 + 1) + PictureloopCount1));//瞬きの間隔を作成
};
var picture_loop_flug = false;//まばたきしているか？

//ループピクチャの情報作成
var LoopPictureCount = [];//new Array();
Game_Screen.prototype.CreateLoopPictureCount = function (layer) {
   LoopPictureCount[layer] = 0;
   picture_loop_flug = true;//まばたきしているか？

};
//まばたき用ピクチャループ
Game_Screen.prototype.LoopPicture = function (layer, name, name2, origin, x, y, scaleX, scaleY, opacity, blendMode) {
   switch (LoopPictureCount[layer]) {
      case LoopPictureCount_rand[layer]:
         //閉じかけ目表示
         //  alert(layer);
         $gameScreen.showPicture(layer, name, origin, x, y, scaleX, scaleY, opacity, blendMode);
         break;
      case LoopPictureCount_rand[layer] + 10:
         //閉じかけ目表示
         $gameScreen.showPicture(layer, name, origin, x, y, scaleX, scaleY, opacity, blendMode);
         break;
      case LoopPictureCount_rand[layer] + 5:
         //閉じ目表示
         $gameScreen.showPicture(layer, name2, origin, x, y, scaleX, scaleY, opacity, blendMode);
         break;
      case LoopPictureCount_rand[layer] + 15:
         $gameScreen.erasePicture(layer);
         LoopPictureCount[layer] = 0;
         LoopPictureCount_rand[layer] = Math.floor((Math.random() * PictureloopCount2 + 1) + PictureloopCount1);//瞬きの間隔を作成
         break;
      default:
         break;
   }
};

//フレーム更新
var RiruPictureloop_Update = Game_Screen.prototype.update;
Game_Screen.prototype.update = function (sceneActive) {
   RiruPictureloop_Update.call(this, sceneActive);
   this.updateLooppicture();//riru追加
};
//まばたき更新
Game_Screen.prototype.updateLooppicture = function () {
   if (picture_loop_flug == true) {
      var j = 0;
      for (i = 1; i < 101; i++) {
         if (j == LoopPicture_v) break;
         if (LoopPictures[i] != null) {
            var layer = LoopPictures[i];
            if (LoopPictureCount[LoopPictures[i][0]] != null) {
               LoopPictureCount[LoopPictures[i][0]] += 1;
               this.LoopPicture(layer[0], layer[1], layer[2], layer[3], layer[4], layer[5], layer[6], layer[7], layer[8], layer[9], layer[10]);
            }
         }
      }
   }
};


code:
/*=============================================================================
 PluginCommonBase.js
----------------------------------------------------------------------------
 (C)2020 KADOKAWA
----------------------------------------------------------------------------
 Version(完成時に削除)
 0.0.7 2020/02/18 スキルの計算式が正常に機能しなくなる問題を修正。スクリプト中に制御文字を使用できる機能を一時的に削除
 0.0.6 2020/02/16 動的コモンイベントの機能を提供
 0.0.5 2020/02/16 全体をリファクタリング
 0.0.4 2020/02/12 パラメータの制御文字を変換しない設定を追加
 0.0.3 2020/01/28 配列やオブジェクト内の制御文字も正しく変換できるよう修正
 0.0.2 2020/01/13 MZコアスクリプトでプラグインコマンドの実行主体がGame_Interpreterに変更されたことに伴う修正
 0.0.1 2020/01/05 初版
=============================================================================*/

/*:
 * @target MZ
 * @plugindesc プラグイン解析共通基盤
 * @author トリアコンタン
 *
 * @help PluginCommonBase.js
 *
 * 本プラグインは他のプラグインから参照されることを前提としたベースプラグインです。
 * 本プラグインを導入すると様々な場面で以下の制御文字が使えるようになります。
 *
 * 利用可能な制御文字
 * \v[n]  : n番目の変数の値に変換されます。
 * \s[n]  : n番目のスイッチの値(true, false)に変換されます。
 * \ss[n] : n番目のセルフスイッチの値(true, false)に変換されます。
 *
 * 制御文字を利用可能な場面は以下の通りです。
 * ・文章の表示
 * ・メモ欄(※)
 * ・プラグインコマンド(※)
 * ・プラグインパラメータ(※)
 * ・スキルなどの説明欄
 * ・スキル、アイテムの計算式
 * ※ PluginCommonBase.jsをベースとして取り込んだプラグインのみ
 *
 * 以下は開発者向けの解説です。
 *
 * このプラグインをベースとして取り込むことで、パラメータの解析や
 * プラグインコマンド、メモ欄の取得時にパラメータ型および制御文字の変換を自動化します。
 * 制御文字の変換処理を共通化することで配下の全てのプラグインで一貫した
 * 制御文字の変換仕様を実現します。
 *
 * ・プラグインパラメータの型解析
 * プラグインパラメータを自動で型解析し変換します。
 * また、パラメータ取得時に制御文字の変換を自動で行います。
 * 以下のメソッドを呼んで戻り値を取得します。
 * 引数には必ず「document.currentScript」を指定します。
 *
 * PluginManagerEx.createParameter(document.currentScript);
 *
 * ・プラグインコマンドパラメータの型解析
 * プラグインコマンドパラメータを自動で型解析し変換します。
 * また、パラメータ取得時に制御文字の変換を自動で行います。
 * PluginManager.registerCommandの代わりに以下を使用します。
 * 引数には必ず「document.currentScript」を指定します。
 *
 * PluginManagerEx.registerCommand(document.currentScript, "command", args => {
 * });
 *
 * ・メモ欄の解析
 * 指定したオブジェクトからメモ欄情報を取得します。
 * 制御文字の変換を自動で行います。
 * 名称は複数指定することも可能です。
 *
 * PluginManagerEx.findMetaValue(obj, tagName1, tagName2...);
 *
 * ・動的コモンイベントの実行
 * 動的コモンイベントを実行できます。
 * 動的コモンイベントとは、スタック型の並列処理コモンイベントです。
 * 好きなだけ登録できて実行が終わったものから自働で破棄されます。
 * $gameMap.setupDynamicCommon(commonEventId);
 *
 * ・組み込み関数の追加
 * データベースを指定した条件で完全一致検索して一致した最初の1件を返します。
 * DataManager.searchDataItem(dataArray, columnName, columnValue);
 *
 * 全てのシステムSEを停止します。
 * AudioManager.stopAllStaticSe();
 *
 * 指定したシステムSEを停止します。
 * AudioManager.stopStaticSe(se);
 *
 */
(() => {
    'use strict';

    /**
     * PluginParam
     */
    class PluginParam {

        constructor(parameter, needParse = true) {
            if (needParse) {
                parameter = JSON.parse(JSON.stringify(parameter, this._paramReplacer));
            }
            this.setup(parameter);
        }

        setNoConvert(paramName) {
            this._noConvert.push(paramName);
        }

        setup(parameter) {
            this._parameter = parameter;
            for (const paramName in parameter) {
                if (!parameter.hasOwnProperty(paramName)) {
                    continue;
                }
                const subParam = parameter[paramName];
                if (this._isStructArray(subParam)) {
                    subParam.forEach((subParamItem, index) => {
                        subParam[index] = new PluginParam(subParamItem, false);
                    });
                } else if (this._isStruct(subParam)) {
                    parameter[paramName] = new PluginParam(subParam, false);
                }
                this._setAccessor(paramName);
            }
            this._noConvert = []
        }

        _setAccessor(paramName) {
            Object.defineProperty(this, paramName, {
                get() {
                    return this._convert(this._param(paramName), paramName);
                },
                set(value) {
                    this._parameter[paramName] = value;
                },
                configurable: true
            });
        }

        _convert(param, paramName) {
            if (this._isStruct(param) || this._isStructArray(param)) {
                return param;
            } else if (Array.isArray(param)) {
                return param.map(paramItem => this._convert(paramItem, paramName));
            }
            if (!this._noConvert.includes(paramName)) {
                return PluginManagerEx.convertVariables(param);
            } else {
                return param;
            }
        }

        _isStructArray(param) {
            return Array.isArray(param) && (param.length === 0 || this._isStruct(param));
        }

        _isStruct(param) {
            return Object.prototype.toString.call(param) === '[object Object]';
        }

        _param(name) {
            return this._parameter[name];
        }

        _paramReplacer(key, value) {
            if (value === 'null') {
                return value;
            }
            if (value[0] === '"' && value[value.length - 1] === '"') {
                return value;
            }
            try {
                return JSON.parse(value);
            } catch (e) {
                return value;
            }
        }
    }

    /**
     * PluginManagerEx
     */
    class PluginManagerEx {
        static convertVariables(text, data = null) {
            if (text !== String(text)) {
                return text;
            }
            text = this.convertEscapeCharacters(text, data);
            if (text === 'true') {
                return true;
            } else if (text === 'false') {
                return false;
            } else if (Number(text) === parseFloat(text)) {
                return parseFloat(text);
            } else {
                return text;
            }
        }

        static convertEscapeCharacters(text, data = null) {
            text = TextConverter.convertEscapeCharactersBase(text, data);
            text = this.convertEscapeCharactersEx(text, data);
            text = TextConverter.convertEscapeCharactersBase(text, data);
            return text;
        }

        // Additional Escape Characters
        static convertEscapeCharactersEx(text, data = null) {
            const key = this._selfSwitchKey;
            if (!key) {
                return text;
            }
            text = text.replace(/\x1bSS\[(.+)]/gi, (_, p1) => {
                key[2] = p1;
                return $gameSelfSwitches ? $gameSelfSwitches.value(key) : '';
            });
            return text;
        }

        static createParameter(currentScript) {
            const paramText = PluginManager.parameters(this.findPluginName(currentScript));
            return new PluginParam(paramText);
        }

        static createCommandArgs(args) {
            const hasObject = Object.keys(args).some(key => {
                return args[key].match(/^[\[{].*[}\]]$/);
            });
            if (hasObject) {
                return new PluginParam(args);
            }
            const newArgs = {};
            Object.keys(args).forEach(key => {
                newArgs[key] = this.convertVariables(args[key]);
            });
            return newArgs;
        }

        static findMetaValue(object, ...nameList) {
            let metaValue = null;
            const meta = object.meta;
            if (!meta) {
                throw new Error(`Not found meta property : ${object}`)
            }
            this.generateSelfSwitchKey(object.id);
            nameList.some(name => {
                metaValue = meta.hasOwnProperty(name) ? this.convertVariables(meta[name], object) : null;
                return metaValue !== null;
            });
            return metaValue;
        }

        static findPluginName(currentScript) {
            return currentScript.src.replace(/^.*\/(.*).js$/, function () {
                return arguments[1];
            });
        }

        static registerCommand(currentScript, commandName, funcName) {
            const pluginName = this.findPluginName(currentScript);
            const key = pluginName + ":" + commandName;
            const func = typeof funcName === 'function' ? funcName : Game_Interpreter.prototype[funcName];
            if (!func) {
                throw new Error(`Not found function Game_Interpreter : ${funcName}`)
            }
            PluginManager.registerCommand(pluginName, commandName, function (args) {
                func.call(this, PluginManagerEx.createCommandArgs(args, key));
            });
        }

        static isExistPlugin(pluginName) {
            return Object.keys(PluginManager.parameters(pluginName)).length > 0;
        }

        static generateSelfSwitchKey(eventId) {
            if (!$gameMap) {
                return;
            }
            this._selfSwitchKey = [$gameMap.mapId(), eventId, null];
        }

        static findClassName(object) {
            return object.constructor.toString().replace(/function\s+(.*)\s*\([\s\S]*/m, '$1');
        }
    }
    window.PluginManagerEx = PluginManagerEx;

    class TextConverter {
        // Copy of Window_Base.prototype.convertEscapeCharacters
        static convertEscapeCharactersBase(text, data = null) {
            text = text.replace(/\\/g, "\x1b");
            text = text.replace(/\x1b\x1b/g, "\\");
            text = text.replace(/\x1bV\[(\d+)]/gi, (_, p1) =>
                $gameVariables ? $gameVariables.value(parseInt(p1)) : ''
            );
            text = text.replace(/\x1bV\[(\d+)]/gi, (_, p1) =>
                $gameVariables ? $gameVariables.value(parseInt(p1)) : ''
            );
            text = text.replace(/\x1bN\[(\d+)]/gi, (_, p1) =>
                this.actorName(parseInt(p1))
            );
            text = text.replace(/\x1bP\[(\d+)]/gi, (_, p1) =>
                this.partyMemberName(parseInt(p1))
            );
            if ($dataSystem) {
                text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
            }
            return text;
        }

        static actorName(n) {
            const actor = n >= 1 && $gameActors ? $gameActors.actor(n) : null;
            return actor ? actor.name() : '';
        }

        static partyMemberName(n) {
            const actor = n >= 1 && $gameParty ? $gameParty.members()[n - 1] : null;
            return actor ? actor.name() : "";
        }
    }

    const _PluginManager_callCommand = PluginManager.callCommand;
    PluginManager.callCommand = function (self, pluginName, commandName, args) {
        PluginManagerEx.generateSelfSwitchKey(self.eventId());
        _PluginManager_callCommand.apply(this, arguments);
    };

    const _Window_Base_convertEscapeCharacters = Window_Base.prototype.convertEscapeCharacters;
    Window_Base.prototype.convertEscapeCharacters = function (text) {
        text = _Window_Base_convertEscapeCharacters.apply(this, arguments);
        return PluginManagerEx.convertEscapeCharacters(text);
    };

    /**
     * Game_Map
     * Support dynamic events.
     */
    const _Game_Map_setupEvents = Game_Map.prototype.setupEvents;
    Game_Map.prototype.setupEvents = function () {
        _Game_Map_setupEvents.apply(this, arguments);
        this._dynamicEvents = [];
    };

    Game_Map.prototype.setupDynamicCommon = function (id) {
        const event = $dataCommonEvents[id];
        if (event) {
            this.setupDynamicInterpreter(event.list);
        }
    };

    Game_Map.prototype.setupDynamicInterpreter = function (list) {
        const interpreter = new Game_Interpreter();
        interpreter.setup(list, 0);
        this._dynamicEvents.push(interpreter);
        this._dynamicEvents = this._dynamicEvents.filter(
            interpreter => interpreter.isRunning());
    };

    const _Game_Map_updateEvents = Game_Map.prototype.updateEvents;
    Game_Map.prototype.updateEvents = function () {
        _Game_Map_updateEvents.apply(this, arguments);
        this._dynamicEvents.forEach(interpreter => interpreter.update());
    };

    /**
     * DataManager.searchDataItem
     * Search database
     * @param dataArray target
     * @param columnName condition1
     * @param columnValue condition2
     * @returns {object} result
     */
    DataManager.searchDataItem = function (dataArray, columnName, columnValue) {
        let result = 0;
        dataArray.some(function (dataItem) {
            if (dataItem && dataItem[columnName] === columnValue) {
                result = dataItem;
                return true;
            }
            return false;
        });
        return result;
    };

    /**
     * AudioManager.stopAllStaticSe
     * Stop all system SE.
     */
    AudioManager.stopAllStaticSe = function () {
        this._staticBuffers.forEach(function (buffer) {
            buffer.stop();
        });
        this._staticBuffers = [];
    };

    /**
     * AudioManager.stopStaticSe
     * Stop system SE.
     */
    AudioManager.stopStaticSe = function (se) {
        if (!se.name) {
            return;
        }
        for (var i = 0; i < this._staticBuffers.length; i++) {
            var buffer = this._staticBuffers[i];
            if (buffer._reservedSeName === se.name) {
                buffer.stop();
                this.updateSeParameters(buffer, se);
                break;
            }
        }
    };
})();


code:
//
//  ポップアップメッセージ ver1.02
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported['PopupMessage'] = 1.02;

if (!Imported.CommonPopupCore) {
    console.error('CommonPopupCoreを導入してください。')
}

/*:
 * @plugindesc ver1.02/メッセージの表示をポップアップに変更する制御文字_pum[delay,x,y,action]を追加します。
 * @author Yana
 *
 * @param Pop Message FontSize
 * @desc ポップアップメッセージのデフォルトフォントサイズです。
 * @default 28
 *
 * @param Pop Message Count
 * @desc ポップアップメッセージの表示時間です。
 * @default 120
 *
 * @param Popup Pattern
 * @desc ポップアップパターンの初期設定です。
 * @default Down
 *
 * @help プラグインコマンドはありません。
 *
 * メッセージの表示のメッセージの中に_pum[delay,x,y,action,pattern]と記述することで、
 * メッセージをポップアップに変更します。
 * delayはディレイ値で、この値フレーム分待ってから、ポップアップを行います。
 * xは表示位置のX座標です。未指定の場合は、0が設定されます。
 * yは表示位置のY座標です。未指定の場合は、画面高さ-ポップアップの高さが設定されます。
 * actionはアクション形式です。1を指定すると、上から下にアクションします。
 * patternは動作パターンです。Normalで今まで通り、GrowUpでにょき、Stretchでうにょーんとなります。
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * このプラグインには「汎用ポップアップベース」のプラグインが必要です。
 * 汎用ポップアップベースより下に配置してください。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.03:
 * 各パラメータに制御文字が使用できるように変更。
 * ポップアップパターンのプラグインパラメータを追加。
 * ver1.02:
 * 動作パターンの設定を追加。
 * ver1.01:
 * 表示位置を調整する機能を追加。
 * ver1.00:
 * 公開
 */

(function () {

    'use strict';

    var parameters = PluginManager.parameters('PopupMessage');
    var popMesFontSize = Number(parameters['Pop Message FontSize'] || 28);
    var popMesCount = Number(parameters['Pop Message Count'] || 120);
    var popMesSlide = Number(parameters['Pop Message Slide'] || 60);
    var popupPattern = parameters['Popup Pattern'] || 0;
    var popMesRegExp = /_PUM\[(.+)\]/gi;

    var _pMes_GInterpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _pMes_GInterpreter_pluginCommand.call(this, command, args);
        if (command === 'PopupMessage') {
        }
    };

    var _pMes_GInterpreter_c101 = Game_Interpreter.prototype.command101;
    Game_Interpreter.prototype.command101 = function () {
        var texts = [];
        var pIndex = this._index;
        var param = { 'delay': null };
        while (this.nextEventCode() === 401) {
            this._index++;
            texts.push(this.currentCommand().parameters[0]);
        }
        var window = CommonPopupManager.window();
        for (var i = 0; i < texts.length; i++) {
            if (texts[i].match(popMesRegExp)) {
                var ary = [0, null, null, 0, popupPattern];
                var text = texts[i].replace(popMesRegExp, function () {
                    var arg = arguments[1].split(',');
                    ary[0] = Number(window.convertEscapeCharacters(arg[0]));
                    if (arg[1]) ary[1] = Number(window.convertEscapeCharacters(arg[1]));
                    if (arg[2]) ary[2] = Number(window.convertEscapeCharacters(arg[2]));
                    if (arg[3]) ary[3] = Number(window.convertEscapeCharacters(arg[3]));
                    if (arg[4]) ary[4] = arg[4];
                    return '';
                }.bind(this));
                texts[i] = text;
                CommonPopupManager.setPopupMessage(this._params, texts, ary);
                return true;
            }
        }
        this._index = pIndex;
        var result = _pMes_GInterpreter_c101.call(this);
        return result;
    };

    var _pMes_GMessage_add = Game_Message.prototype.add;
    Game_Message.prototype.add = function (text) {
        text = text.replace(popMesRegExp, '');
        _pMes_GMessage_add.call(this, text);
    };

    CommonPopupManager.setPopupMessage = function (params, texts, ary) {
        this._readyPopup = this._readyPopup || [];
        var bitmap = ImageManager.loadFace(params[0]);
        this.bltCheck(bitmap);
        this._readyPopup.push([params, texts, ary, 'pMessage']);
    };

    var _pMes_CPManager_makeBitmap = CommonPopupManager.makeBitmap;
    CommonPopupManager.makeBitmap = function (arg) {
        if (arg[3] === 'pMessage') {
            return ImageManager.loadFace(arg[0][0]);
        } else {
            return _pMes_CPManager_makeBitmap.call(this, arg);
        }
    };

    var _pMes_CPManager_startPopup = CommonPopupManager.startPopup;
    CommonPopupManager.startPopup = function (arg) {
        if (arg[3] === 'pMessage') {
            this.startPopupMessage(arg[0], arg[1], arg[2]);
        } else {
            _pMes_CPManager_startPopup.call(this, arg);
        }
    };

    CommonPopupManager.startPopupMessage = function (params, texts, arg) {
        var fontSize = popMesFontSize;
        var oneHeight = (fontSize + 8);
        var height = params[0] ? 144 : oneHeight * texts.length;
        var bitmap = new Bitmap(Graphics.boxWidth, height);
        var faceSize = params[0] === '' ? 0 : 144;
        var delay = arg[0];
        var x = arg[1];
        var y = arg[2];
        var action = arg[3];
        var pattern = arg[4];
        bitmap.fillRect(0, 0, bitmap.width / 2, bitmap.height, 'rgba(0,0,0,0.5)');
        bitmap.gradientFillRect(bitmap.width / 2, 0, bitmap.width / 2, bitmap.height, 'rgba(0,0,0,0.5)', 'rgba(0,0,0,0)');
        this.window().contents = bitmap;
        this.window().drawTextEx('\\FS[' + fontSize + ']', 0, 0);
        this.window().drawFace(params[0], params[1], 0, 0);
        var iFontSize = fontSize;
        for (var i = 0; i < texts.length; i++) {
            var text = '\\FS[' + iFontSize + ']' + texts[i];
            this.window().drawTextEx(text, 8 + faceSize, i * oneHeight);
            iFontSize = this.window().contents.fontSize;
        }
        var arg = this.setPopup([]);
        arg.bitmap = bitmap;
        if (pattern === 'GrowUp') {
            arg.x = 0;
            arg.y = Graphics.boxHeight;
            arg.moveX = 0;
            arg.anchorX = 0;
            arg.anchorY = 1.0;
            arg.pattern = -2;
        } else if (pattern === 'Stretch') {
            arg.x = 0;
            arg.y = Graphics.boxHeight - height;
            arg.moveX = 0;
            arg.anchorX = 0;
            arg.anchorY = 0;
            arg.pattern = -1;
        } else {
            arg.x = Graphics.boxWidth * -1;
            arg.y = Graphics.boxHeight - height;
            arg.moveX = Graphics.boxWidth;
            arg.anchorX = 0;
            arg.anchorY = 0;
        }
        if (x) { arg.x += x }
        if (y) { arg.y = y }
        if ($gameParty.inBattle()) { arg.y = Math.min(Graphics.boxHeight - 180, arg.y) }
        arg.moveY = 0;
        arg.count = popMesCount;
        arg.fixed = false;
        arg.slideCount = popMesSlide;
        if (action === 1) { arg.slideAction = 'Down' }
        arg.delay = delay;
        this._tempCommonSprites.setNullPos(arg);
    }
})();