code:
//=============================================================================
// CustomizeCritical.js
// ----------------------------------------------------------------------------
// (C)2020 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.4 2020/07/11 複数ヒットする攻撃の会心判定が、ヒットごとに行われていなかった問題を修正
// 1.1.3 2017/09/01 様子を見る等の一部の行動を敵キャラが実行するとエラーになる問題を修正（byツミオさま）
// 1.1.2 2017/07/09 ヘルプのメモ欄「<CC計算式:JavaScript計算式>」の記述例が誤っていたので修正
// 1.1.1 2017/05/31 1.1.0の修正でメニュー画面でスキルを使用するとエラーになる不具合を修正
// 1.1.0 2017/05/27 連続ヒットする攻撃の2ヒット目以降のダメージが正常に表示されない問題を修正。YEP_BattleEngineCore.jsとの競合を解消
// 1.0.0 2016/05/05 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 会心カスタマイズプラグイン
 * @author トリアコンタン
 *
 * @help 会心（クリティカルヒット）の確率とダメージ、演出をカスタマイズします。
 *
 * スキルのメモ欄に以下の通り記述してください。
 *
 * ・会心に専用計算式を適用します。書式はダメージ計算式と同様です。
 * 　計算式を適用した場合、デフォルトのダメージ3倍は無効になります。
 * <CC計算式:JavaScript計算式>
 * 例：<CC計算式:a.atk * 4> //攻撃力の4倍で相手の防御は無視
 *
 * ・会心の確率を加算します。元の確率に計算結果が加算されます。(百分率)
 * <CC確率加算:加算値>
 * 例：<CC確率加算:50> //元の確率+50%で発生
 *
 * ・会心の確率を変更します。元の確率は無視されます。(百分率)
 * <CC確率変更:変更値>
 * 例：<CC確率変更:\v[1]> //変数[1]の値の確率で発生
 *
 * ・会心発生時の専用の戦闘アニメを適用します。
 * <CCアニメ:戦闘アニメID>
 *
 * アクターもしくは敵キャラのメモ欄に以下の通り記述してください。
 * ただし、フロントビューの場合、敵キャラのアニメーションは表示されません。
 *
 * ・演出用の戦闘アニメを実行前に表示します。
 * <CC演出:戦闘アニメID>
 *
 * ・演出用の専用メッセージを実行前に表示します。
 * <CCメッセージ:メッセージ内容>
 *
 * ※ 敵全体あるいは複数回攻撃するスキルの場合、1回でも会心判定になった場合
 * 会心用の演出となります。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function() {
    'use strict';
    var pluginName    = 'CustomizeCritical';
    var metaTagPrefix = 'CC';

    var getArgString = function(arg, upperFlg) {
        arg = convertEscapeCharactersAndEval(arg, false);
        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(convertEscapeCharactersAndEval(arg, true), 10) || 0).clamp(min, max);
    };

    var convertEscapeCharactersAndEval = function(text, evalFlg) {
        if (text === null || text === undefined) {
            text = evalFlg ? '0' : '';
        }
        var window = SceneManager._scene._windowLayer.children[0];
        if (window) {
            var result = window.convertEscapeCharacters(text);
            return evalFlg ? eval(result) : result;
        } else {
            return text;
        }
    };

    var getMetaValue = function(object, name) {
        var metaTagName = metaTagPrefix + (name ? name : '');
        return object.meta.hasOwnProperty(metaTagName) ? object.meta[metaTagName] : undefined;
    };

    var getMetaValues = function(object, names) {
        if (!Array.isArray(names)) return getMetaValue(object, names);
        for (var i = 0, n = names.length; i < n; i++) {
            var value = getMetaValue(object, names[i]);
            if (value !== undefined) return value;
        }
        return undefined;
    };

    //=============================================================================
    // Game_Action
    //  会心をカスタマイズします。
    //=============================================================================
    var _Game_Action_evalDamageFormula      = Game_Action.prototype.evalDamageFormula;
    Game_Action.prototype.evalDamageFormula = function(target) {
        var item    = this.item();
        var formula = getMetaValues(item, ['計算式', 'Formula']);
        if (formula && target.result().critical) {
            try {
                var a     = this.subject();
                var b     = target;
                var v     = $gameVariables._data;
                var sign  = ([3, 4].contains(item.damage.type) ? -1 : 1);
                var value = Math.max(eval(getArgString(formula)), 0) * sign;
                if (isNaN(value)) value = 0;
                return value;
            } catch (e) {
                return 0;
            }
        } else {
            return _Game_Action_evalDamageFormula.apply(this, arguments);
        }
    };

    var _Game_Action_itemCri            = Game_Action.prototype.itemCri;
    Game_Action.prototype.itemCri = function(target) {
        var queue = this._criticalQueue;
        if (queue && queue.length > 0) {
            return queue.shift() ? 1.0 : 0.0;
        } else {
            return _Game_Action_itemCri.apply(this, arguments);
        }
    };

    Game_Action.prototype.judgeCritical = function(target) {
        var changeValue = getMetaValues(this.item(), ['確率変更', 'ProbChange']);
        var itemCritical;
        if (changeValue) {
            itemCritical = getArgNumber(changeValue, 0, 100) / 100;
        } else {
            var addValue = getMetaValues(this.item(), ['確率加算', 'ProbAdd']);
            itemCritical = _Game_Action_itemCri.apply(this, arguments) + (addValue ? getArgNumber(addValue) / 100 : 0);
        }
        this._criticalQueue.push(Math.random() < itemCritical);
    };

    Game_Action.prototype.initCriticalQueue = function() {
        this._criticalQueue = [];
    };

    Game_Action.prototype.isCritical = function() {
        if (!this._criticalQueue) {
            return false;
        }
        return this._criticalQueue.some(function(critical) {
            return critical;
        })
    };

    var _Game_Action_applyCritical      = Game_Action.prototype.applyCritical;
    Game_Action.prototype.applyCritical = function(damage) {
        var formula = getMetaValues(this.item(), ['計算式', 'Formula']);
        return formula ? damage : _Game_Action_applyCritical.apply(this, arguments);
    };

    //=============================================================================
    // Game_Battler
    //  データオブジェクトを取得します。
    //=============================================================================
    Game_Battler.prototype.getData = function() {
        return null;
    };

    Game_Actor.prototype.getData = function() {
        return this.actor();
    };

    Game_Enemy.prototype.getData = function() {
        return this.enemy();
    };

    //=============================================================================
    // BattleManager
    //  会心判定を事前に行います。
    //=============================================================================
    BattleManager.judgeCritical = function(action, targets) {
        action.initCriticalQueue();
        targets.forEach(function(target) {
            action.judgeCritical(target);
        });
    };

    //=============================================================================
    // Window_BattleLog
    //  会心の演出を追加定義します。
    //=============================================================================
    var _Window_BattleLog_startAction      = Window_BattleLog.prototype.startAction;
    Window_BattleLog.prototype.startAction = function(subject, action, targets) {
        this._noCritialAnimationId = 0;
        this._currentAction = action;
        BattleManager.judgeCritical(action, targets);
        if (action.isCritical()) {
            this.showCriticalEffect(subject, action, targets);
            var animationIdString = getMetaValues(action.item(), ['アニメ', 'Animation']);
            if (animationIdString) {
                this._noCritialAnimationId = action.item().animationId;
                action.item().animationId  = getArgNumber(animationIdString, 1);
            }
        }
        _Window_BattleLog_startAction.apply(this, arguments);
    };

    var _Window_BattleLog_endAction      = Window_BattleLog.prototype.endAction;
    Window_BattleLog.prototype.endAction = function(subject) {
        _Window_BattleLog_endAction.apply(this, arguments);
        if (this._noCritialAnimationId) {
            this._currentAction.item().animationId = this._noCritialAnimationId;
            this._noCritialAnimationId = 0;
        }
        this._currentAction = null;
    };

    Window_BattleLog.prototype.showCriticalEffect = function(subject, action, targets) {
        var animationIdString = getMetaValues(subject.getData(), ['演出', 'エフェクト']);
        if (animationIdString) {
            var animationId = getArgNumber(animationIdString, 1);
            var animation   = $dataAnimations[animationId];
            if (animation) {
                this.push('showAnimation', subject, targets.clone(), animationId);
                this.push('waitForFrame', animation.frames.length * 4);
            }
        }
        var message = getMetaValues(subject.getData(), ['メッセージ', 'Message']);
        if (message) {
            this.push('addText', message);
        }
    };

    Window_BattleLog.prototype.waitForFrame = function(frame) {
        this._waitCount = frame;
    };
})();


code:
//=============================================================================
// DTextPicture.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2017 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.9.0 2017/08/20 ウィンドウつきピクチャが重なったときにウィンドウがピクチャの下に表示される問題を修正
// 1.8.6 2017/06/28 フォント変更機能のヘルプが抜けていたので追加
// 1.8.5 2017/06/12 変数がマイナス値のときのゼロ埋め表示が正しく表示されない問題を修正
// 1.8.4 2017/05/10 プラグインを未適用のデータを読み込んだとき、最初の一回のみ動的文字列ピクチャが作成されない問題を修正
// 1.8.3 2017/04/19 自動翻訳プラグインに一部対応
// 1.8.2 2017/04/05 ピクチャの消去時にエラーが発生していた問題を修正
// 1.8.1 2017/03/30 拡大率と原点に対応していなかった問題を修正
// 1.8.0 2017/03/30 背景にウィンドウを表示できる機能を追加
// 1.7.1 2017/03/20 1.7.0で末尾がイタリック体の場合に、傾き部分が見切れてしまう問題を修正
// 1.7.0 2017/03/20 動的文字列を太字とイタリックにできる機能を追加
//                  複数行表示かつ制御文字でアイコンを指定した場合に高さが余分に計算されてしまう問題の修正
// 1.6.2 2016/12/13 動的ピクチャに対して、ピクチャの表示とピクチャの色調変更を同フレームで行うと画像が消える問題の修正
// 1.6.1 2016/11/03 一通りの競合対策
// 1.6.0 2016/11/03 インストールされているフォントをピクチャのフォントとして利用できる機能を追加
// 1.5.1 2016/10/27 1.5.0でアウトラインカラーを指定するとエラーになっていた現象を修正
// 1.5.0 2016/10/23 制御文字で表示した変数の内容をリアルタイム更新できる機能を追加
// 1.4.2 2016/07/02 スクリプトからダイレクトで実行した場合も制御文字が反映されるよう修正（ただし余分にエスケープする必要あり）
// 1.4.1 2016/06/29 制御文字「\{」で文字サイズを大きくした際、元のサイズに戻さないと正しいサイズで表示されない問題を修正
// 1.4.0 2016/06/28 D_TEXT実行後に画像を指定してピクチャを表示した場合は画像を優先表示するよう仕様変更
// 1.3.1 2016/06/07 描画文字が半角英数字のみかつフォントを未指定の場合に文字が描画されない不具合を修正
// 1.3.0 2016/06/03 制御文字\oc[c] \ow[n]に対応
// 1.2.2 2016/03/28 データベース情報を簡単に出力する制御文字を追加
// 1.2.1 2016/01/29 コマンド「D_TEXT_SETTING」の実装が「D_TEST_SETTING」になっていたので修正（笑）
// 1.2.0 2016/01/27 複数行表示に対応
//                  文字列の揃えと背景色を設定する機能を追加
//                  変数をゼロ埋めして表示する機能を追加
// 1.1.3 2015/12/10 戦闘画面でもピクチャを使用できるよう修正
//                  描画後にデバッグ画面等を開いて変数を修正した場合、再描画で変更が反映されてしまう問題を修正
// 1.1.2 2015/11/07 描画文字列に半角スペースが含まれていた場合も問題なく実行できるよう修正
// 1.1.0 2015/11/07 制御文字\C[n] \I[n] \{ \} に対応（\$と表示スピード制御系以外全部）
// 1.0.1 2015/11/07 RPGツクールMV（日本語版）に合わせてコメントの表記を変更
// 1.0.0 2015/11/06 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 動的文字列ピクチャ生成プラグイン
 * @author トリアコンタン
 *
 * @help 指定した文字列でピクチャを動的に生成するコマンドを提供します。
 * 文字列には各種制御文字（\v[n]等）も使用可能で、制御文字で表示した変数の値が
 * 変更されたときにリアルタイムでピクチャの内容を更新できます。
 *
 * 以下の手順で表示します。
 *  1 : プラグインコマンド[D_TEXT]で描画したい文字列と引数を指定（下記の例参照）
 *  2 : プラグインコマンド[D_TEXT_SETTING]で背景色や揃えを指定（任意）
 *  3 : イベントコマンド「ピクチャの表示」で「画像」を未選択に指定。
 * ※ 1の時点ではピクチャは表示されないので必ずセットで呼び出してください。
 * ※ ピクチャ表示前にD_TEXTを複数回実行すると、複数行表示できます。
 *
 * ※ ver1.4.0より、[D_TEXT]実行後に「ピクチャの表示」で「画像」を指定した場合は
 *    動的文字列ピクチャ生成を保留として通常通り「画像」ピクチャが表示される
 *    ように挙動が変更になりました。
 *
 * プラグインコマンド詳細
 *   イベントコマンド「プラグインコマンド」から実行。
 *   （引数の間は半角スペースで区切る）
 *
 *  D_TEXT [描画文字列] [文字サイズ] : 動的文字列ピクチャ生成の準備
 *  例：D_TEXT テスト文字列 32
 *
 * 表示後は通常のピクチャと同様に移動や回転、消去ができます。
 * また、変数やアクターの表示など制御文字にも対応しています。
 *
 *  D_TEXT_SETTING ALIGN [揃え] : 揃え（左揃え、中央揃え、右揃え）の設定
 *  0:左揃え 1:中央揃え 2:右揃え
 *
 *  例：D_TEXT_SETTING ALIGN 0
 *      D_TEXT_SETTING ALIGN CENTER
 *
 *  D_TEXT_SETTING BG_COLOR [背景色] : 背景色の設定(CSSの色指定と同様の書式)
 *
 *  例：D_TEXT_SETTING BG_COLOR black
 *      D_TEXT_SETTING BG_COLOR #336699
 *      D_TEXT_SETTING BG_COLOR rgba(255,255,255,0.5)
 *
 *  D_TEXT_SETTING REAL_TIME ON : 制御文字で表示した変数のリアルタイム表示
 *
 *  例：D_TEXT_SETTING REAL_TIME ON
 *
 *  リアルタイム表示を有効にしておくと、ピクチャの表示後に変数の値が変化したとき
 *  自動でピクチャの内容も更新されます。
 *
 *  D_TEXT_SETTING WINDOW ON : 背景にウィンドウを表示する
 *  例：D_TEXT_SETTING WINDOW ON
 *
 *  D_TEXT_SETTING FONT [フォント名] : 描画で使用するフォントを指定した名称に変更
 *  例：D_TEXT_SETTING FONT ＭＳ Ｐ明朝
 *
 * これらの設定はD_TEXTと同様、ピクチャを表示する前に行ってください。
 *
 * 対応制御文字一覧（イベントコマンド「文章の表示」と同一です）
 * \V[n]
 * \N[n]
 * \P[n]
 * \G
 * \C[n]
 * \I[n]
 * \{
 * \}
 *
 * 専用制御文字
 * \V[n,m,space or zero](m桁分の空白orゼロ埋めした変数の値)
 *  ※ space = 空白埋め   zero = ゼロ埋め
 * \item[n]   n 番のアイテム情報（アイコン＋名称）
 * \weapon[n] n 番の武器情報（アイコン＋名称）
 * \armor[n]  n 番の防具情報（アイコン＋名称）
 * \skill[n]  n 番のスキル情報（アイコン＋名称）
 * \state[n]  n 番のステート情報（アイコン＋名称）
 * \oc[c] アウトラインカラーを「c」に設定(例:\oc[red])
 * \ow[n] アウトライン幅を「n」に設定(例:\ow[5])
 * \f[b] フォントの太字化
 * \f[i] フォントのイタリック化
 * \f[n] フォントの太字とイタリックを通常に戻す
 * \fs[n] フォントサイズを n に指定する、0 を指定すると標準サイズに戻る
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function() {
  'use strict';

  var getCommandName = function(command) {
    return (command || '').toUpperCase();
  };

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

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

  var getArgBoolean = function(arg) {
    return (arg || '').toUpperCase() === 'ON';
  };

  var connectArgs = function(args, startIndex, endIndex) {
    if (arguments.length < 2) startIndex = 0;
    if (arguments.length < 3) endIndex = args.length;
    var text = '';
    for (var i = startIndex; i < endIndex; i++) {
      text += args[i];
      if (i < endIndex - 1) text += ' ';
    }
    return text;
  };

  var convertEscapeCharacters = function(text) {
    if (text === undefined || text === null) text = '';
    var window = SceneManager.getHiddenWindow();
    return window ? window.convertEscapeCharacters(text) : text;
  };

  var getUsingVariables = function(text) {
    var usingVariables = [];

    text = text.replace(/\\/g, '\x1b');
    text = text.replace(/\x1b\x1b/g, '\\');

    text = text.replace(/\x1bV\[(\d+)\,\s*(\d+),\s*(\w+)\]/gi, function() {
      var number = parseInt(arguments[1], 10);
      usingVariables.push(number);
      return $gameVariables.value(number);
    }.bind(this));

    text = text.replace(/\x1bV\[(\d+)\,\s*(\d+)\]/gi, function() {
      var number = parseInt(arguments[1], 10);
      usingVariables.push(number);
      return $gameVariables.value(number);
    }.bind(this));

    text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
      var number = parseInt(arguments[1], 10);
      usingVariables.push(number);
      return $gameVariables.value(number);
    }.bind(this));

    text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
      var number = parseInt(arguments[1], 10);
      usingVariables.push(number);
      return $gameVariables.value(number);
    }.bind(this));

    return usingVariables;
  };

  //=============================================================================
  // Game_Interpreter
  //  プラグインコマンド[D_TEXT]を追加定義します。
  //=============================================================================
  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function(command, args) {
    _Game_Interpreter_pluginCommand.apply(this, arguments);
    this.pluginCommandDTextPicture(command, args);
  };

  Game_Interpreter.textAlignMapper = {
    LEFT: 0,
    CENTER: 1,
    RIGHT: 2,
    左: 0,
    中央: 1,
    右: 2
  };

  Game_Interpreter.prototype.pluginCommandDTextPicture = function(command, args) {
    switch (getCommandName(command)) {
      case 'D_TEXT':
        if (isNaN(args[args.length - 1]) || args.length === 1) args.push($gameScreen.dTextSize || 28);
        var fontSize = getArgNumber(args.pop());
        $gameScreen.setDTextPicture(connectArgs(args), fontSize);
        break;
      case 'D_TEXT_SETTING':
        switch (getCommandName(args[0])) {
          case 'ALIGN':
            $gameScreen.dTextAlign = isNaN(args[1]) ?
              Game_Interpreter.textAlignMapper[getArgString(args[1], true)] : getArgNumber(args[1], 0, 2);
            break;
          case 'BG_COLOR':
            $gameScreen.dTextBackColor = getArgString(connectArgs(args, 1));
            break;
          case 'FONT':
            args.shift();
            $gameScreen.setDtextFont(getArgString(connectArgs(args)));
            break;
          case 'REAL_TIME':
            $gameScreen.dTextRealTime = getArgBoolean(args[1]);
            break;
          case 'WINDOW':
            $gameScreen.dWindowFrame = getArgBoolean(args[1]);
            break;
        }
        break;
    }
  };

  //=============================================================================
  // Game_Variables
  //  値を変更した変数の履歴を取得します。
  //=============================================================================
  var _Game_Variables_setValue = Game_Variables.prototype.setValue;
  Game_Variables.prototype.setValue = function(variableId, value) {
    if (this.value(variableId) !== value) {
      this._changedVariables = this.getChangedVariables();
      if (!this._changedVariables.contains(variableId)) {
        this._changedVariables.push(variableId);
      }
    }
    _Game_Variables_setValue.apply(this, arguments);
  };

  Game_Variables.prototype.getChangedVariables = function() {
    return this._changedVariables || [];
  };

  Game_Variables.prototype.clearChangedVariables = function() {
    return this._changedVariables = [];
  };

  //=============================================================================
  // Game_Screen
  //  動的ピクチャ用のプロパティを追加定義します。
  //=============================================================================
  var _Game_Screen_clear = Game_Screen.prototype.clear;
  Game_Screen.prototype.clear = function() {
    _Game_Screen_clear.call(this);
    this.clearDTextPicture();
  };

  Game_Screen.prototype.clearDTextPicture = function() {
    this.dTextValue = null;
    this.dTextOriginal = null;
    this.dTextRealTime = null;
    this.dTextSize = 0;
    this.dTextAlign = 0;
    this.dTextBackColor = null;
    this.dTextFont = null;
    this.dUsingVariables = null;
    this.dWindowFrame = null;
  };

  Game_Screen.prototype.setDTextPicture = function(value, size) {
    if (typeof TranslationManager !== 'undefined') {
      TranslationManager.translateIfNeed(value, function(translatedText) {
        value = translatedText;
      });
    }
    this.dUsingVariables = (this.dUsingVariables || []).concat(getUsingVariables(value));

    this.dTextValue = (this.dTextValue || '') + getArgString(value, false) + '\n';
    this.dTextOriginal = (this.dTextOriginal || '') + value + '\n';
    this.dTextSize = size;
  };

  Game_Screen.prototype.getDTextPictureInfo = function() {
    return {
      value: this.dTextValue,
      size: this.dTextSize || 0,
      align: this.dTextAlign || 0,
      color: this.dTextBackColor,
      font: this.dTextFont,
      usingVariables: this.dUsingVariables,
      realTime: this.dTextRealTime,
      originalValue: this.dTextOriginal,
      windowFrame: this.dWindowFrame
    };
  };

  Game_Screen.prototype.isSettingDText = function() {
    return !!this.dTextValue;
  };

  Game_Screen.prototype.setDtextFont = function(name) {
    this.dTextFont = name;
  };

  var _Game_Screen_updatePictures = Game_Screen.prototype.updatePictures;
  Game_Screen.prototype.updatePictures = function() {
    _Game_Screen_updatePictures.apply(this, arguments);
    $gameVariables.clearChangedVariables();
  };

  //=============================================================================
  // Game_Picture
  //  動的ピクチャ用のプロパティを追加定義し、表示処理を動的ピクチャ対応に変更します。
  //=============================================================================
  var _Game_Picture_initBasic = Game_Picture.prototype.initBasic;
  Game_Picture.prototype.initBasic = function() {
    _Game_Picture_initBasic.call(this);
    this.dTextValue = null;
    this.dTextInfo = null;
  };

  var _Game_Picture_show = Game_Picture.prototype.show;
  Game_Picture.prototype.show = function(name, origin, x, y, scaleX,
    scaleY, opacity, blendMode) {
    if ($gameScreen.isSettingDText() && !name) {
      arguments[0] = Date.now().toString();
      this.dTextInfo = $gameScreen.getDTextPictureInfo();
      $gameScreen.clearDTextPicture();
    } else {
      this.dTextInfo = null;
    }
    _Game_Picture_show.apply(this, arguments);
  };

  var _Game_Picture_update = Game_Picture.prototype.update;
  Game_Picture.prototype.update = function() {
    _Game_Picture_update.apply(this, arguments);
    if (this.dTextInfo && this.dTextInfo.realTime) {
      this.updateDTextVariable();
    }
  };

  Game_Picture.prototype.updateDTextVariable = function() {
    $gameVariables.getChangedVariables().forEach(function(variableId) {
      if (this.dTextInfo.usingVariables.contains(variableId)) {
        this._name = Date.now().toString();
        this.dTextInfo.value = getArgString(this.dTextInfo.originalValue, false);
      }
    }, this);
  };

  //=============================================================================
  // SceneManager
  //  文字描画用の隠しウィンドウを取得します。
  //=============================================================================
  SceneManager.getHiddenWindow = function() {
    if (!this._hiddenWindow) {
      this._hiddenWindow = new Window_Hidden(1, 1, 1, 1);
    }
    return this._hiddenWindow;
  };

  SceneManager.getSpriteset = function() {
    return this._scene._spriteset;
  };

  //=============================================================================
  // Window_Base
  //  文字列変換処理に追加制御文字を設定します。
  //=============================================================================
  var _Window_Base_convertEscapeCharacters = Window_Base.prototype.convertEscapeCharacters;
  Window_Base.prototype.convertEscapeCharacters = function(text) {
    text = _Window_Base_convertEscapeCharacters.call(this, text);
    text = text.replace(/\x1bV\[(\d+)\,\s*(\d+),\s*(\w+)\]/gi, function() {
      return this.getVariablePadZero($gameVariables.value(parseInt(arguments[1], 10)), arguments[2], arguments[3]);
    }.bind(this));
    text = text.replace(/\x1bITEM\[(\d+)\]/gi, function() {
      var item = $dataItems[getArgNumber(arguments[1], 1, $dataItems.length)];
      return item ? '\x1bi[' + item.iconIndex + ']' + item.name : '';
    }.bind(this));
    text = text.replace(/\x1bWEAPON\[(\d+)\]/gi, function() {
      var item = $dataWeapons[getArgNumber(arguments[1], 1, $dataWeapons.length)];
      return item ? '\x1bi[' + item.iconIndex + ']' + item.name : '';
    }.bind(this));
    text = text.replace(/\x1bARMOR\[(\d+)\]/gi, function() {
      var item = $dataArmors[getArgNumber(arguments[1], 1, $dataArmors.length)];
      return item ? '\x1bi[' + item.iconIndex + ']' + item.name : '';
    }.bind(this));
    text = text.replace(/\x1bSKILL\[(\d+)\]/gi, function() {
      var item = $dataSkills[getArgNumber(arguments[1], 1, $dataSkills.length)];
      return item ? '\x1bi[' + item.iconIndex + ']' + item.name : '';
    }.bind(this));
    text = text.replace(/\x1bSTATE\[(\d+)\]/gi, function() {
      var item = $dataStates[getArgNumber(arguments[1], 1, $dataStates.length)];
      return item ? '\x1bi[' + item.iconIndex + ']' + item.name : '';
    }.bind(this));
    return text;
  };

  String.prototype.padStart = function padStart(targetLength, padString) {
    targetLength = targetLength >> 0; //truncate if number or convert non-number to 0;
    padString = String((typeof padString !== 'undefined' ? padString : ' '));
    if (this.length > targetLength) {
      return String(this);
    } else {
      targetLength = targetLength - this.length;
      if (targetLength > padString.length) {
        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
      }
      return padString.slice(0, targetLength) + String(this);
    }
  };

  Window_Base.prototype.getVariablePadZero = function(value, digit, space) {
    if (space == "space") {
      var number = (value + "").padStart(digit)
      return number
    }
    return (value < 0 ? '-' : '') + Math.abs(value).padZero(digit);
  };

  //=============================================================================
  // Sprite_Picture
  //  画像の動的生成を追加定義します。
  //=============================================================================
  var _Sprite_Picture_update = Sprite_Picture.prototype.update;
  Sprite_Picture.prototype.update = function() {
    _Sprite_Picture_update.apply(this, arguments);
    if (this._frameWindow) {
      this.updateFrameWindow();
    }
  };

  Sprite_Picture.prototype.updateFrameWindow = function() {
    var padding = this._frameWindow.standardPadding();
    this._frameWindow.x = this.x - (this.anchor.x * this.width * this.scale.x) - padding;
    this._frameWindow.y = this.y - (this.anchor.y * this.height * this.scale.y) - padding;
    if (!this.visible) {
      this.removeFrameWindow();
      return;
    }
    if (!this._addFrameWindow) {
      this.addFrameWindow();
    }
    if (Graphics.frameCount % 2 === 0) {
      this.adjustScaleFrameWindow();
    }
  };

  Sprite_Picture.prototype.adjustScaleFrameWindow = function() {
    var padding = this._frameWindow.standardPadding();
    var newFrameWidth = Math.floor(this.width * this.scale.x + padding * 2);
    var newFrameHeight = Math.floor(this.height * this.scale.x + padding * 2);
    if (this._frameWindow.width !== newFrameWidth || this._frameWindow.height !== newFrameHeight) {
      this._frameWindow.move(this._frameWindow.x, this._frameWindow.y, newFrameWidth, newFrameHeight);
    }
  };

  Sprite_Picture.prototype.addFrameWindow = function() {
    var parent = this.parent;
    if (parent) {
      var index = parent.getChildIndex(this);
      parent.addChildAt(this._frameWindow, index);
      this._addFrameWindow = true;
    }
  };

  Sprite_Picture.prototype.removeFrameWindow = function() {
    var parent = this.parent;
    if (parent) {
      parent.removeChild(this._frameWindow);
      this._frameWindow = null;
      this._addFrameWindow = false;
    }
  };

  var _Sprite_Picture_loadBitmap = Sprite_Picture.prototype.loadBitmap;
  Sprite_Picture.prototype.loadBitmap = function() {
    this.dTextInfo = this.picture().dTextInfo;
    if (this.dTextInfo) {
      this.makeDynamicBitmap();
    } else {
      _Sprite_Picture_loadBitmap.apply(this, arguments);
    }
  };

  Sprite_Picture.prototype.makeDynamicBitmap = function() {
    this.textWidths = [];
    this.hiddenWindow = SceneManager.getHiddenWindow();
    this.hiddenWindow.resetFontSettings(this.dTextInfo);
    var bitmapVirtual = new Bitmap_Virtual();
    this._processText(bitmapVirtual);
    this.hiddenWindow.resetFontSettings(this.dTextInfo);
    this.bitmap = new Bitmap(bitmapVirtual.width, bitmapVirtual.height);
    this.bitmap.fontFace = this.hiddenWindow.contents.fontFace;
    if (this.dTextInfo.color) {
      this.bitmap.fillAll(this.dTextInfo.color);
    }
    this._processText(this.bitmap);
    this._colorTone = [0, 0, 0, 0];
    if (this._frameWindow) {
      this.removeFrameWindow();
    }
    if (this.dTextInfo.windowFrame) {
      var scaleX = this.picture().scaleX() / 100;
      var scaleY = this.picture().scaleY() / 100;
      this.makeFrameWindow(bitmapVirtual.width * scaleX, bitmapVirtual.height * scaleY);
    }
    this.hiddenWindow = null;
  };

  Sprite_Picture.prototype.makeFrameWindow = function(width, height) {
    var padding = this.hiddenWindow.standardPadding();
    this._frameWindow = new Window_Base(0, 0, width + padding * 2, height + padding * 2);
  };

  Sprite_Picture.prototype._processText = function(bitmap) {
    var textState = {
      index: 0,
      x: 0,
      y: 0,
      text: this.dTextInfo.value,
      left: 0,
      line: -1,
      height: 0
    };
    this._processNewLine(textState, bitmap);
    var textHeight = this.hiddenWindow.calcTextHeight(textState, false);
    var dTextheight = this.hiddenWindow.calcDTextHeight(textState, false);
    textState.height = textHeight > dTextheight ? textHeight : dTextheight;
    textState.index = 0;
    while (textState.text[textState.index]) {
      this._processCharacter(textState, bitmap);
    }
  };

  Sprite_Picture.prototype._processCharacter = function(textState, bitmap) {
    if (textState.text[textState.index] === '\x1b') {
      var code = this.hiddenWindow.obtainEscapeCode(textState);
      switch (code) {
        case 'C':
          bitmap.textColor = this.hiddenWindow.textColor(this.hiddenWindow.obtainEscapeParam(textState));
          break;
        case 'I':
          this._processDrawIcon(this.hiddenWindow.obtainEscapeParam(textState), textState, bitmap);
          break;
        case 'E':
          this._processDrawIcon(this.hiddenWindow.obtainEscapeParam(textState), textState, bitmap);
          textState.x-=4
          break;
        case '{':
          this.hiddenWindow.makeFontBigger();
          break;
        case '}':
          this.hiddenWindow.makeFontSmaller();
          break;
        case 'F':
          switch (this.hiddenWindow.obtainEscapeParamString(textState).toUpperCase()) {
            case 'I':
              bitmap.fontItalic = true;
              break;
            case 'B':
              bitmap.fontBoldFotDtext = true;
              break;
            case '/':
            case 'N':
              bitmap.fontItalic = false;
              bitmap.fontBoldFotDtext = false;
              break;
          }
          break;
        case 'OC':
          bitmap.outlineColor = this.hiddenWindow.obtainEscapeParamString(textState);
          break;
        case 'OW':
          bitmap.outlineWidth = this.hiddenWindow.obtainEscapeParam(textState);
          break;
        case 'FS':
          this.hiddenWindow.makeFontSize(this.dTextInfo, this.hiddenWindow.obtainEscapeParam(textState));
          break;

      }
    } else if (textState.text[textState.index] === '\n') {
      this._processNewLine(textState, bitmap);
    } else {
      var c = textState.text[textState.index++];
      var w = this.hiddenWindow.textWidth(c);

      bitmap.fontSize = this.hiddenWindow.contents.fontSize;
      bitmap.drawText(c, textState.x, textState.y, w * 2, textState.height, 'left');
      textState.x += w;
    }
  };

  Sprite_Picture.prototype._processNewLine = function(textState, bitmap) {
    if (bitmap instanceof Bitmap_Virtual)
      this.textWidths[textState.line] = textState.x;
    this.hiddenWindow.processNewLine(textState);
    textState.line++;
    if (bitmap instanceof Bitmap)
      textState.x = (bitmap.width - this.textWidths[textState.line]) / 2 * this.dTextInfo.align;
  };

  Sprite_Picture.prototype._processDrawIcon = function(iconIndex, textState, bitmap) {
    var iconBitmap = ImageManager.loadSystem('IconSet');
    var pw = Window_Base._iconWidth;
    var ph = Window_Base._iconHeight;
    var sx = iconIndex % 16 * pw;
    var sy = Math.floor(iconIndex / 16) * ph;
    bitmap.blt(iconBitmap, sx, sy, pw, ph, textState.x + 2, textState.y + (textState.height - ph) / 2);
    textState.x += Window_Base._iconWidth + 4;
  };

  //=============================================================================
  // Bitmap_Virtual
  //  サイズを計算するための仮想ビットマップクラス
  //=============================================================================
  function Bitmap_Virtual() {
    this.initialize.apply(this, arguments);
  }

  Bitmap_Virtual.prototype.initialize = function() {
    this.window = SceneManager.getHiddenWindow();
    this.width = 0;
    this.height = 0;
  };

  Bitmap_Virtual.prototype.drawText = function(text, x, y, maxWidth, lineHeight, align) {
    var baseWidth = this.window.textWidth(text);
    var fontSize = this.window.contents.fontSize;
    if (this.fontItalic) {
      baseWidth += Math.floor(fontSize / 6);
    }
    if (this.fontBoldFotDtext) {
      baseWidth += 2;
    }
    this.width = Math.max(x + baseWidth, this.width);
    this.height = Math.max(y + fontSize + 8, this.height);
  };

  Bitmap_Virtual.prototype.blt = function(source, sx, sy, sw, sh, dx, dy, dw, dh) {
    this.width = Math.max(dx + (dw || sw), this.width);
    this.height = Math.max(dy + (dh || sh), this.height);
  };

  //=============================================================================
  // Window_Hidden
  //  文字描画用の隠しウィンドウ
  //=============================================================================
  function Window_Hidden() {
    this.initialize.apply(this, arguments);
  }

  Window_Hidden.prototype.backOpacity = null;

  Window_Hidden.prototype = Object.create(Window_Base.prototype);
  Window_Hidden.prototype.constructor = Window_Hidden;

  Window_Hidden.prototype._createAllParts = function() {
    this._windowBackSprite = {};
    this._windowSpriteContainer = {};
    this._windowContentsSprite = new Sprite();
    this.addChild(this._windowContentsSprite);
  };

  Window_Hidden.prototype._refreshAllParts = function() {};

  Window_Hidden.prototype._refreshBack = function() {};

  Window_Hidden.prototype._refreshFrame = function() {};

  Window_Hidden.prototype._refreshCursor = function() {};

  Window_Hidden.prototype._refreshArrows = function() {};

  Window_Hidden.prototype._refreshPauseSign = function() {};

  Window_Hidden.prototype.updateTransform = function() {};

  Window_Hidden.prototype.resetFontSettings = function(dTextInfo) {
    if (dTextInfo) {
      var customFont = dTextInfo.font ? dTextInfo.font + ',' : '';
      this.contents.fontFace = customFont + this.standardFontFace();
      this.contents.fontSize = dTextInfo.size || this.standardFontSize();
    } else {
      Window_Base.prototype.resetFontSettings.apply(this, arguments);
    }

  };

  Window_Hidden.prototype.obtainEscapeParamString = function(textState) {
    var arr = /^\[.+?\]/.exec(textState.text.slice(textState.index));
    if (arr) {
      textState.index += arr[0].length;
      return arr[0].substring(1, arr[0].length - 1);
    } else {
      return '';
    }
  };

  Window_Hidden.prototype.makeFontSize = function(dTextInfo, fontSize){
    if((fontSize > 108 || fontSize < 12) && fontSize != 0) return;
    this.contents.fontSize = (fontSize == 0) ? dTextInfo.size || this.standardFontSize() : fontSize || this.contents.fontSize;
  }

  Window_Hidden.prototype.calcDTextHeight = function(textState, all) {
    var lastFontSize = this.contents.fontSize;
    var textHeight = 0;
    var lines = textState.text.slice(textState.index).split('\n');
    var maxLines = all ? lines.length : 1;

    for(var i = 0; i < maxLines; i++){
      var maxFontSize = this.contents.fontSize;
      var fs = lines[i].match(/\x1bfs\[(\d+)\]/g);
      if (fs) {
        for(var k = 0; k < fs.length; k++){
          var fontSize = (/(\d+)/.exec(fs[k]))[0];
          this.contents.fontSize = Number(fontSize) || this.contents.fontSize;
          if (maxFontSize < this.contents.fontSize) {
            maxFontSize = this.contents.fontSize;
          }
        }
      }

      textHeight += maxFontSize + 8;
    }

    this.contents.fontSize = lastFontSize;
    return textHeight;
  };

  //=============================================================================
  // Bitmap
  //  太字対応
  //=============================================================================
  var _Bitmap__makeFontNameText = Bitmap.prototype._makeFontNameText;
  Bitmap.prototype._makeFontNameText = function() {
    return (this.fontBoldFotDtext ? 'bold ' : '') + _Bitmap__makeFontNameText.apply(this, arguments);
  };
})();

repo_name: dazed/translations

license: unknown


code:
// DarkPlasma_ChoiceListCancelSE
// Copyright (c) 2020 DarkPlasma
// This software is released under the MIT license.
// http://opensource.org/licenses/mit-license.php

/**
 * 2020/03/25 1.0.1 マウスクリックやタッチでキャンセル項目を選択した際に決定SEが再生される不具合を修正
 * 2020/03/17 1.0.0 公開
 */

 /*:
 * @plugindesc 選択肢でキャンセル項目を選択したときにキャンセルSEを再生するプラグイン
 * @author DarkPlasma
 * @license MIT
 *
 * @help
 * イベントコマンドの選択肢でキャンセルにあたる項目を選択して決定キーを押した際にも
 * キャンセルSEを再生します。
 */

(function () {
  'use strict';
  const pluginName = document.currentScript.src.replace(/^.*\/(.*).js$/, function() {
      return arguments[1];
  });
  const pluginParameters = PluginManager.parameters(pluginName);

  const _Window_ChoiceList_isOkTriggered = Window_ChoiceList.prototype.isOkTriggered;
  Window_ChoiceList.prototype.isOkTriggered = function() {
    if (this.isCancelEnabled() && this.index() === $gameMessage.choiceCancelType()) {
      return false;
    }
    return _Window_ChoiceList_isOkTriggered.call(this);
  };

  const _Window_ChoiceList_isCancelTriggered = Window_ChoiceList.prototype.isCancelTriggered;
  Window_ChoiceList.prototype.isCancelTriggered = function () {
    if (Input.isTriggered('ok') && this.isCancelEnabled() && this.index() === $gameMessage.choiceCancelType()) {
      return true;
    }
    return _Window_ChoiceList_isCancelTriggered.call(this);
  };

  /**
   * キャンセルに相当する選択肢がタッチされたかどうか
   * @param {boolean} triggered
   * @return {boolean}
   */
  Window_ChoiceList.prototype.isTouchedCancel = function (triggered) {
    if (!triggered || !this.isCancelEnabled() || this.index() !== $gameMessage.choiceCancelType()) {
      return false;
    }
    const hitIndex = this.hitTest(
      this.canvasToLocalX(TouchInput.x),
      this.canvasToLocalY(TouchInput.y)
    );
    return hitIndex >= 0 && hitIndex === this.index();
  };

  const _Window_ChoiceList_onTouch = Window_ChoiceList.prototype.onTouch;
  Window_ChoiceList.prototype.onTouch = function (triggered) {
    if (this.isTouchedCancel(triggered)) {
      this.processCancel();
    } else {
      _Window_ChoiceList_onTouch.call(this, triggered);
    }
  };
})();


code:
// DarkPlasma_SharedSwitchVariable 1.0.1
// Copyright (c) 2021 DarkPlasma
// This software is released under the MIT license.
// http://opensource.org/licenses/mit-license.php

/**
 * 2021/09/21 1.0.1 ニューゲームを開始すると共有セーブデータがリセットされる不具合を修正
 *                  rollup構成へ移行
 * 2021/05/05 1.0.0 公開
 */

/*:ja
 * @plugindesc 全てのセーブデータで共有するスイッチ・変数を指定する
 * @author DarkPlasma
 * @license MIT
 *
 * @target MV
 * @url https://github.com/elleonard/DarkPlasma-MV-Plugins/tree/release
 *
 * @param switchRangeList
 * @desc 共有セーブに保存するスイッチの範囲リストを指定します
 * @text スイッチ範囲リスト
 * @type struct<SwitchRange>[]
 * @default []
 *
 * @param variableRangeList
 * @desc 共有セーブに保存する変数の範囲リストを指定します
 * @text 変数範囲リスト
 * @type struct<VariableRange>[]
 * @default []
 *
 * @param savefileId
 * @desc 共有セーブのIDを指定します。セーブデータの数より必ず大きくしてください
 * @text 共有セーブID
 * @type number
 * @default 20210505
 * @min 21
 *
 * @help
 * version: 1.0.1
 * 全てのセーブデータで共有するスイッチ・変数を指定します。
 * 指定したスイッチ・変数の値は共有セーブデータ(save/shared.rpgsave)に保存します。
 */
/*~struct~SwitchRange:
 * @param from
 * @desc このスイッチ以降、終端で指定したスイッチまでをグローバルセーブに保存します
 * @text 閉区間開始
 * @type switch
 * @default 1
 * @min 1
 *
 * @param to
 * @desc 開始で指定したスイッチからこのスイッチまでをグローバルセーブに保存します
 * @text 閉区間終端
 * @type switch
 * @default 1
 * @min 1
 */
/*~struct~VariableRange:
 * @param from
 * @desc この変数以降、終端で指定した変数までをグローバルセーブに保存します
 * @text 閉区間開始
 * @type variable
 * @default 1
 * @min 1
 *
 * @param to
 * @desc 開始で指定した変数からこの変数までをグローバルセーブに保存します
 * @text 閉区間終端
 * @type variable
 * @default 1
 * @min 1
 */
(() => {
  'use strict';

  const pluginName = document.currentScript.src.replace(/^.*\/(.*).js$/, function () {
    return arguments[1];
  });

  const pluginParameters = PluginManager.parameters(pluginName);

  const settings = {
    switchRangeList: JSON.parse(pluginParameters.switchRangeList || '[]').map((e) => {
      return ((parameter) => {
        const parsed = JSON.parse(parameter);
        return {
          from: Number(parsed.from || 1),
          to: Number(parsed.to || 1),
        };
      })(e || '{}');
    }),
    variableRangeList: JSON.parse(pluginParameters.variableRangeList || '[]').map((e) => {
      return ((parameter) => {
        const parsed = JSON.parse(parameter);
        return {
          from: Number(parsed.from || 1),
          to: Number(parsed.to || 1),
        };
      })(e || '{}');
    }),
    savefileId: Number(pluginParameters.savefileId || 20210505),
  };

  const _StorageManager_localFilePath = StorageManager.localFilePath;
  StorageManager.localFilePath = function (savefileId) {
    if (savefileId === settings.savefileId) {
      return `${this.localFileDirectoryPath()}shared.rpgsave`;
    }
    return _StorageManager_localFilePath.call(this, savefileId);
  };

  const _StorageManager_webStorageKey = StorageManager.webStorageKey;
  StorageManager.webStorageKey = function (savefileId) {
    if (savefileId === settings.savefileId) {
      return 'RPG Shared';
    }
    return _StorageManager_webStorageKey.call(this, savefileId);
  };

  DataManager.makeSharedInfo = function () {
    return {
      switches: this.sharedSaveSwitches(),
      variables: this.sharedSaveVariables(),
    };
  };

  DataManager.saveSharedInfo = function () {
    StorageManager.save(settings.savefileId, JSON.stringify(this.makeSharedInfo()));
  };

  DataManager.loadSharedInfo = function () {
    try {
      const json = StorageManager.load(settings.savefileId);
      return json ? JSON.parse(json) : {};
    } catch (e) {
      console.error(e);
      return {};
    }
  };

  const _DataManager_saveGameWithoutRescue = DataManager.saveGameWithoutRescue;
  DataManager.saveGameWithoutRescue = function (savefileId) {
    const result = _DataManager_saveGameWithoutRescue.call(this, savefileId);
    this.saveSharedInfo();
    return result;
  };

  const _DataManager_extractSaveContents = DataManager.extractSaveContents;
  DataManager.extractSaveContents = function (contents) {
    _DataManager_extractSaveContents.call(this, contents);
    this.extractSharedSaveSwitchesAndVariables();
  };

  /**
   * グローバルセーブに記録したスイッチ・変数を展開する
   */
  DataManager.extractSharedSaveSwitchesAndVariables = function () {
    const sharedInfo = this.loadSharedInfo();
    const sharedSwitches = sharedInfo.switches || [];
    sharedSwitches.forEach((sharedSwitch) => {
      $gameSwitches.setValue(sharedSwitch.id, sharedSwitch.value);
    });
    const sharedVariables = sharedInfo.variables || [];
    sharedVariables.forEach((sharedVariable) => {
      $gameVariables.setValue(sharedVariable.id, sharedVariable.value);
    });
  };

  /**
   * 指定した数値から開始する連番の配列を返す
   * @param {number} length 数値
   * @param {number} start 開始数値
   * @return {number[]}
   */
  const range = (length, start) => [...Array(length).keys()].map((n) => n + start);

  /**
   * 共有セーブに保存すべきスイッチのIDと値の組一覧を返す
   * @return {object[]}
   */
  DataManager.sharedSaveSwitches = function () {
    return settings.switchRangeList
      .filter((switchRange) => switchRange.from <= switchRange.to)
      .map((switchRange) => range(switchRange.to - switchRange.from + 1, switchRange.from))
      .flat()
      .map((switchId) => {
        return {
          id: switchId,
          value: $gameSwitches.value(switchId),
        };
      });
  };

  /**
   * 共有セーブに保存すべき変数のIDと値の組一覧を返す
   * @return {object[]}
   */
  DataManager.sharedSaveVariables = function () {
    return settings.variableRangeList
      .filter((variableRange) => variableRange.from <= variableRange.to)
      .map((variableRange) => range(variableRange.to - variableRange.from + 1, variableRange.from))
      .flat()
      .map((variableId) => {
        return {
          id: variableId,
          value: $gameVariables.value(variableId),
        };
      });
  };

  const _DataManager_setupNewGame = DataManager.setupNewGame;
  DataManager.setupNewGame = function () {
    _DataManager_setupNewGame.call(this);
    this.extractSharedSaveSwitchesAndVariables();
  };

  if (!Array.prototype.flat) {
    Array.prototype.flat = function (depth) {
      var flattend = [];
      (function flat(array, depth) {
        for (let el of array) {
          if (Array.isArray(el) && depth > 0) {
            flat(el, depth - 1);
          } else {
            flattend.push(el);
          }
        }
      })(this, Math.floor(depth) || 1);
      return flattend.filter((el) => el);
    };
  }
})();


code:
/*---------------------------------------------------------------------------*
 * 2018/07/04 kido0617
 * http://kido0617.github.io/
 * 完全に自由にどうぞ。
 * クレジットの表記もいりません。
 * Ver.1.0
 *---------------------------------------------------------------------------*/

/*:
 * @plugindesc デバッグウィンドウにショートカットキーを追加するプラグイン
 * @author kido0617
 * @help
 * 以下を参照
 * http://kido0617.github.io/rpgmaker/2018-07-04-debug-shortcut/
 *
*/

(function(){

  Input.keyMapper[66] = 'B';
  Input.keyMapper[86] = 'V';
  Input.keyMapper[8] = 'BackSpace';
  for(var i = 0; i <= 9; i++){
    Input.keyMapper[48 + i] = String(i);
  }
  Scene_Debug.prototype.update = function() {
    Scene_Base.prototype.update.call(this);
    if(Input.isTriggered('B')){
      this.shortCutType = 'B';
      this.strNum = "";
      this.jump();
    }else if(Input.isTriggered('V')){
      this.shortCutType = 'V';
      this.strNum = "";
      this.jump();
    }else if(Input.isTriggered('BackSpace')){
      if(this.strNum && this.strNum.length > 0) this.strNum = this.strNum.substr(0, this.strNum.length - 1);
      this.jump();
    }
    for(var i = 0; i <= 9; i++){
      if(Input.isTriggered(String(i))){
        if(this.strNum == "" && i == 0) return;  "いきなり0は無し"
        this.strNum += String(i);
        this.jump();
      }
    }
  };

  Scene_Debug.prototype.jump = function(){
    if(!this.shortCutType) return;
    var rangeIndex = this.shortCutType == 'B' ? 0 : this._rangeWindow._maxSwitches;
    if(this.strNum != ''){
      var num = parseInt(this.strNum);
      if((this.shortCutType =='B' && num > $dataSystem.switches.length) ||
       (this.shortCutType =='V' && num > $dataSystem.variables.length)){
         SoundManager.playBuzzer();
         //最大超えたら最大値にしておく
         num = this.shortCutType == 'B' ?  $dataSystem.switches.length - 1 : $dataSystem.variables.length - 1;
      }
      rangeIndex += Math.floor((num - 1) / 10);
      this._rangeWindow.select(rangeIndex);
      this._rangeWindow.deactivate();
      this._editWindow.activate();
      this._editWindow.select((num -1) % 10);
    }else{
      this._rangeWindow.select(rangeIndex);
      this._rangeWindow.activate();
      this._editWindow.deactivate();
    }
    this.refreshHelpWindow();
  }

  var refreshHelpWindow = Scene_Debug.prototype.refreshHelpWindow;
  Scene_Debug.prototype.refreshHelpWindow = function() {
    refreshHelpWindow.call(this);
    var str = this.shortCutType + this.strNum;
    this._debugHelpWindow.drawTextEx(str, 450, this._debugHelpWindow.lineHeight() * 4);
  };
})();