code:
//=============================================================================
// DTextPicture.js
// ----------------------------------------------------------------------------
// (C)2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 2.6.1 2022/06/26 2.6.0で不透明度を指定せず実行するとエラーになる問題を修正
// 2.6.0 2022/06/26 背景ウィンドウの透明度を指定できる機能を追加
// 2.5.0 2022/05/26 動的文字列ピクチャの設定を解除するコマンドを追加
// 2.4.0 2021/10/29 行の高さをコマンドから指定できる機能を追加
//                  直前に生成したピクチャの横幅、高さを変数に格納する機能
// 2.3.0 2021/06/05 フォントロードプラグインと組み合わせて動的文字列ピクチャに好きなフォントを指定できる機能を追加
// 2.2.3 2021/05/04 一部の制御文字を使っていると揃えを中央もしくは右揃えにしたときに正しく表示されない問題を修正
//                  フォントサイズを小さくして複数行表示したときに1行目の高さが正しく計算されない問題を修正
//                  競合対策のためのリファクタリング
// 2.2.2 2021/03/27 文字列を太字にする機能とイタリック体にする機能が正常に動作していなかった問題を修正
// 2.2.1 2021/02/08 色調変更したピクチャを消去し、同一の番号で動的文字列ピクチャを作成したとき文字列ピクチャが表示されない場合がある問題を修正
// 2.2.0 2021/01/22 複数行の動的文字列を中央揃え、右揃えにできる機能を追加
// 2.1.0 2021/01/10 動的文字列のフォントサイズを指定できる機能を追加
// 2.0.4 2021/01/06 制御文字\v[n,m]でもリアルタイム描画されるよう修正
// 2.0.3 2020/09/01 制御文字\oc[c], \ow[n]の移植が漏れていた問題を修正
// 2.0.2 2020/08/26 ベースプラグインの説明を追加
// 2.0.1 2020/08/26 描画文字列に数値のみを指定するとエラーになる問題を修正
// 2.0.0 2020/08/15 MZ対応用に全面リファクタリング
// 1.0.0 2015/11/06 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 動的文字列ピクチャ生成プラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/DTextPicture.js
 * @author トリアコンタン
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 *
 * @param frameWindowSkin
 * @text フレームウィンドウスキン
 * @desc フレームウィンドウのスキンファイル名です。ウィンドウビルダーを使っている場合は、指定する必要があります。
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param frameWindowPadding
 * @text フレームウィンドウ余白
 * @desc フレームウィンドウの余白です。
 * @default 18
 * @type number
 *
 * @param padCharacter
 * @text 埋め文字
 * @desc 数値描画時、指定桁数に満たないときに埋められる文字です。半角で1文字だけ指定してください。
 * @default 0
 *
 * @param prefixText
 * @text 接頭辞文字列
 * @desc すべての文字列ピクチャの前に挿入されるテキストです。主にデフォルトの制御文字などを指定します。
 * @default
 *
 * @param widthVariable
 * @text 横幅格納変数
 * @desc 直前に描画した動的文字列の横幅(ピクセル数)を格納する変数です。
 * @default 0
 * @type variable
 *
 * @param heightVariable
 * @text 高さ格納変数
 * @desc 直前に描画した動的文字列の高さ(ピクセル数)を格納する変数です。
 * @default 0
 * @type variable
 *
 * @command dText
 * @text 文字列ピクチャ準備
 * @desc 文字列ピクチャで表示する文字列を準備します。
 *
 * @arg text
 * @text 表示文字列
 * @desc 文字列ピクチャとして表示するテキストです。
 * @default
 * @type multiline_string
 *
 * @arg fontSize
 * @text フォントサイズ
 * @desc 動的文字列の初期フォントサイズです。0を指定するとシステムで設定したデフォルトサイズになります。
 * @default 0
 * @type number
 *
 * @command dTextSetting
 * @text 文字列ピクチャ設定
 * @desc 文字列ピクチャの表示方法に関する設定です。変更した設定は描画後も保持されます。未設定の項目は現状維持されます。
 *
 * @arg backGroundColor
 * @text 背景色
 * @desc 文字列ピクチャの背景色です。
 * @default
 *
 * @arg gradationLeft
 * @text 左方向グラデーション
 * @desc 文字列ピクチャの背景の左方向グラデーションのピクセル数です。
 * @type number
 * @default
 *
 * @arg gradationRight
 * @text 右方向グラデーション
 * @desc 文字列ピクチャの背景の右方向グラデーションのピクセル数です。
 * @type number
 * @default
 *
 * @arg realTime
 * @text リアルタイム描画
 * @desc 制御文字\v[n]を使っている場合、変数の内容が変化したらピクチャを再描画します。
 * @type boolean
 * @default
 *
 * @arg window
 * @text ウィンドウ
 * @desc 文字列ピクチャの背景にウィンドウを表示します。
 * @type boolean
 * @default
 *
 * @arg windowOpacity
 * @text ウィンドウ不透明度
 * @desc 文字列ピクチャ背景のウィンドウの不透明度です。
 * @type number
 * @default
 *
 * @arg align
 * @text 揃え
 * @desc 複数行の動的文字列を指定したときの揃えです。
 * @default
 * @type select
 * @option 左揃え
 * @value left
 * @option 中央揃え
 * @value center
 * @option 右揃え
 * @value right
 *
 * @arg fontFace
 * @text フォント
 * @desc 文字列ピクチャのフォントです。フォントロードプラグインで読み込んだフォントの名称を指定します。
 * @default
 *
 * @arg lineHeight
 * @text 行の高さ
 * @desc 文字列ピクチャの1行分の高さです。
 * @default 0
 *
 * @command dTextSettingClear
 * @text 文字列ピクチャ設定解除
 * @desc 文字列ピクチャの表示方法に関する設定を全て解除し初期化します。
 *
 * @command windowCursor
 * @text ウィンドウカーソル設定
 * @desc 表示中の文字列ピクチャの背景ウィンドウにカーソルを表示します。
 *
 * @arg pictureId
 * @text ピクチャ番号
 * @desc 対象のピクチャ番号です。すでに表示中のピクチャである必要があります。
 * @type number
 * @default 1
 *
 * @arg x
 * @text X座標
 * @desc カーソルのX座標です。
 * @type number
 * @default 0
 *
 * @arg y
 * @text Y座標
 * @desc カーソルのY座標です。
 * @type number
 * @default 0
 *
 * @arg width
 * @text 横幅
 * @desc カーソルの横幅です。
 * @type number
 * @default 100
 *
 * @arg height
 * @text 横幅
 * @desc カーソルの横幅です。
 * @type number
 * @default 100
 *
 * @arg activateSwitch
 * @text 有効スイッチ
 * @desc 指定した場合、スイッチがONのときのみアクティブになります。指定なしの場合常にアクティブになります。
 * @type switch
 * @default 0
 *
 * @help 指定した文字列でピクチャを動的に生成するコマンドを提供します。
 * 文字列には各種制御文字（\v[n]等）も使用可能で、制御文字で表示した変数の値が
 * 変更されたときにリアルタイムでピクチャの内容を更新できます。
 *
 * 以下の手順で表示します。
 *  1 : プラグインコマンド[文字列ピクチャ準備]で描画内容を準備
 *  2 : イベントコマンド「ピクチャの表示」で「画像」を未選択に指定。
 * ※ 1の時点ではピクチャは表示されないので必ずセットで呼び出してください。
 *
 * 専用制御文字
 * \V[n,m](m桁分のパラメータで指定した文字で埋めた変数の値)
 * \item[n]   n 番のアイテム情報（アイコン＋名称）
 * \weapon[n] n 番の武器情報（アイコン＋名称）
 * \armor[n]  n 番の防具情報（アイコン＋名称）
 * \skill[n]  n 番のスキル情報（アイコン＋名称）
 * \state[n]  n 番のステート情報（アイコン＋名称）
 * \oc[c] アウトラインカラーを「c」に設定(※1)
 * \ow[n] アウトライン幅を「n」に設定(例:\ow[5])
 * \f[b] フォントの太字化
 * \f[i] フォントのイタリック化
 * \f[n] フォントの太字とイタリックを通常に戻す
 *
 * ※1 アウトラインカラーの指定方法
 * \oc[red]  色名で指定
 * \oc[rgb(0,255,0)] カラーコードで指定
 * \oc[2] 文字色番号\c[n]と同様のもので指定
 *
 * 動的文字列ピクチャのフォントを変えたい場合は、
 * 別途フォントロードプラグインを使って読み込んでください。
 * https://github.com/triacontane/RPGMakerMV/blob/mz_master/FontLoad.js
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function () {
  "use strict";
  const script = document.currentScript;
  const param = PluginManagerEx.createParameter(script);

  PluginManager.registerCommand(
    PluginManagerEx.findPluginName(script),
    "dText",
    function (args) {
      $gameScreen.setDTextPicture(
        args.text,
        PluginManagerEx.convertVariables(args.fontSize)
      );
    }
  );

  PluginManagerEx.registerCommand(script, "dTextSetting", function (args) {
    $gameScreen.setDtextSetting(args);
  });

  PluginManagerEx.registerCommand(script, "dTextSettingClear", function (args) {
    $gameScreen.clearDtextSetting();
  });

  PluginManagerEx.registerCommand(script, "windowCursor", function (args) {
    $gameScreen.setDTextWindowCursor(args.pictureId, args, args.activateSwitch);
  });

  //=============================================================================
  // Game_Screen
  //  動的ピクチャ用のプロパティを追加定義します。
  //=============================================================================
  Game_Screen.prototype.setDtextSetting = function (setting) {
    if (setting.backGroundColor !== "") {
      this.dTextBackColor = setting.backGroundColor;
    }
    if (setting.gradationLeft !== "") {
      this.dTextGradationLeft = setting.gradationLeft;
    }
    if (setting.gradationRight !== "") {
      this.dTextGradationRight = setting.gradationRight;
    }
    if (setting.realTime !== "") {
      this.dTextRealTime = setting.realTime;
    }
    if (setting.window !== "") {
      this.dWindowFrame = setting.window;
    }
    if (setting.align !== "") {
      this.dTextAlign = setting.align;
    }
    if (setting.fontFace !== "") {
      this.dTextFontFace = setting.fontFace;
    }
    if (setting.lineHeight > 0) {
      this.dTextLineHeight = setting.lineHeight;
    }
    if (setting.windowOpacity !== "") {
      this.dTextWindowOpacity = setting.windowOpacity;
    }
  };

  Game_Screen.prototype.clearDtextSetting = function () {
    this.dTextBackColor = null;
    this.dTextGradationLeft = null;
    this.dTextGradationRight = null;
    this.dTextRealTime = null;
    this.dWindowFrame = null;
    this.dTextAlign = null;
    this.dTextFontFace = null;
    this.dTextLineHeight = null;
    this.dTextWindowOpacity = null;
  };

  Game_Screen.prototype.clearDTextPicture = function () {
    this.dTextValue = null;
  };

  Game_Screen.prototype.setDTextPicture = function (value, size) {
    if (typeof TranslationManager !== "undefined") {
      TranslationManager.translateIfNeed(value, function (translatedText) {
        value = translatedText;
      });
    }
    if (size > 0) {
      value = `\\fs[${size}]${value}`;
    }
    this.dTextValue = value;
    this.dTextSize = size;
  };

  Game_Screen.prototype.setDTextWindowCursor = function (
    pictureId,
    rect,
    switchId
  ) {
    const picture = this.picture(pictureId);
    if (picture) {
      picture.setWindowCursor(rect, switchId);
    }
  };

  Game_Screen.prototype.getDTextPictureInfo = function () {
    const prefix = param.prefixText || "";
    return {
      value: prefix + this.dTextValue,
      size: this.dTextSize,
      color: this.dTextBackColor,
      realTime: this.dTextRealTime,
      windowFrame: this.dWindowFrame,
      gradationLeft: this.dTextGradationLeft,
      gradationRight: this.dTextGradationRight,
      align: this.dTextAlign,
      font: this.dTextFontFace,
      lineHeight: this.dTextLineHeight,
      windowOpacity: this.dTextWindowOpacity,
    };
  };

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

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

  const _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();
      this.updateDText();
      $gameScreen.clearDTextPicture();
    } else {
      this.dTextInfo = null;
      this._dTextValue = null;
    }
    _Game_Picture_show.apply(this, arguments);
  };

  const _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.updateDText();
    }
  };

  Game_Picture.prototype.updateDText = function () {
    const text = PluginManagerEx.convertEscapeCharacters(this.dTextInfo.value);
    if (text !== this._dTextValue) {
      this._name = Date.now().toString();
    }
    this._dTextValue = text;
  };

  Game_Picture.prototype.getDText = function () {
    return this._dTextValue;
  };

  Game_Picture.prototype.setWindowCursor = function (rect, switchId) {
    this._windowCursor = rect;
    this._windowCursorActive = switchId;
  };

  Game_Picture.prototype.getWindowCursor = function () {
    return this._windowCursor;
  };

  Game_Picture.prototype.getWindowCursorActive = function () {
    const switchId = this._windowCursorActive;
    return !switchId || $gameSwitches.value(switchId);
  };

  //=============================================================================
  // Window_Base
  //  文字列変換処理に追加制御文字を設定します。
  //=============================================================================
  const _PluginManagerEx_convertEscapeCharactersEx =
    PluginManagerEx.convertEscapeCharactersEx;
  PluginManagerEx.convertEscapeCharactersEx = function (text, data = null) {
    text = _PluginManagerEx_convertEscapeCharactersEx.call(this, text, data);
    text = text.replace(
      /\x1bV\[(\d+),\s*(\d+)]/gi,
      function () {
        return this.getVariablePadCharacter(
          $gameVariables.value(parseInt(arguments[1], 10)),
          arguments[2]
        );
      }.bind(this)
    );
    text = text.replace(
      /\x1bITEM\[(\d+)]/gi,
      function () {
        const item = $dataItems[parseInt(arguments[1])];
        return this.getItemInfoText(item);
      }.bind(this)
    );
    text = text.replace(
      /\x1bWEAPON\[(\d+)]/gi,
      function () {
        const item = $dataWeapons[parseInt(arguments[1])];
        return this.getItemInfoText(item);
      }.bind(this)
    );
    text = text.replace(
      /\x1bARMOR\[(\d+)]/gi,
      function () {
        const item = $dataArmors[parseInt(arguments[1])];
        return this.getItemInfoText(item);
      }.bind(this)
    );
    text = text.replace(
      /\x1bSKILL\[(\d+)]/gi,
      function () {
        const item = $dataSkills[parseInt(arguments[1])];
        return this.getItemInfoText(item);
      }.bind(this)
    );
    text = text.replace(
      /\x1bSTATE\[(\d+)]/gi,
      function () {
        const item = $dataStates[parseInt(arguments[1])];
        return this.getItemInfoText(item);
      }.bind(this)
    );
    return text;
  };

  PluginManagerEx.getItemInfoText = function (item) {
    return item ? `\x1bi[${item.iconIndex}]${item.name}` : "";
  };

  PluginManagerEx.getVariablePadCharacter = function (value, digit) {
    let numText = String(Math.abs(value));
    const pad = String(param.padCharacter) || "0";
    while (numText.length < digit) {
      numText = pad + numText;
    }
    return (value < 0 ? "-" : "") + numText;
  };

  //=============================================================================
  // Sprite_Picture
  //  画像の動的生成を追加定義します。
  //=============================================================================
  const _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 () {
    const padding = param.frameWindowPadding;
    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;
    this._frameWindow.opacity = this.opacity;
    if (this.dTextInfo && this.dTextInfo.windowOpacity >= 0) {
      this._frameWindow.backOpacity = this.dTextInfo.windowOpacity;
    }
    if (!this.visible || !this.dTextInfo) {
      this.removeFrameWindow();
      return;
    }
    if (!this._addFrameWindow) {
      this.addFrameWindow();
    }
    if (Graphics.frameCount % 2 === 0) {
      this.adjustScaleFrameWindow();
    }
    this.updateFrameWindowCursor();
  };

  Sprite_Picture.prototype.updateFrameWindowCursor = function () {
    const picture = this.picture();
    if (!picture) {
      return;
    }
    const rect = picture.getWindowCursor();
    if (rect) {
      const width = rect.width || this._frameWindow.contentsWidth();
      const height = rect.width || this._frameWindow.contentsHeight();
      this._frameWindow.setCursorRect(0, 0, width, height);
      this._frameWindow.active = picture.getWindowCursorActive();
    } else {
      this._frameWindow.setCursorRect(0, 0, 0, 0);
    }
  };

  Sprite_Picture.prototype.adjustScaleFrameWindow = function () {
    const padding = param.frameWindowPadding;
    const newFrameWidth = Math.floor(this.width * this.scale.x + padding * 2);
    const 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 () {
    const parent = this.parent;
    if (parent) {
      const index = parent.getChildIndex(this);
      parent.addChildAt(this._frameWindow, index);
      this._addFrameWindow = true;
    }
  };

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

  Sprite_Picture.prototype.makeFrameWindow = function (width, height) {
    const padding = param.frameWindowPadding;
    const rect = new Rectangle(0, 0, width + padding * 2, height + padding * 2);
    this._frameWindow = new Window_Base(rect);
    if (param.frameWindowSkin) {
      this._frameWindow.windowskin = ImageManager.loadSystem(
        param.frameWindowSkin
      );
    }
  };

  const _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 () {
    const tempWindow = new Window_Dummy();
    this.bitmap = tempWindow.createTextContents(
      this.picture().getDText(),
      this.dTextInfo
    );
    if (param.widthVariable) {
      $gameVariables.setValue(param.widthVariable, this.bitmap.width);
    }
    if (param.heightVariable) {
      $gameVariables.setValue(param.heightVariable, this.bitmap.height);
    }
    if (this.dTextInfo.color) {
      this.makeDynamicBitmapBack();
    }
    this.setColorTone([0, 0, 0, 0]);
    tempWindow.drawTextContents();
    if (this._frameWindow) {
      this.removeFrameWindow();
    }
    if (this.dTextInfo.windowFrame) {
      const scaleX = this.picture().scaleX() / 100;
      const scaleY = this.picture().scaleY() / 100;
      this.makeFrameWindow(
        this.bitmap.width * scaleX,
        this.bitmap.height * scaleY
      );
    }
  };

  Sprite_Picture.prototype.makeDynamicBitmapBack = function () {
    this.bitmap.fillAll(this.dTextInfo.color);
    const h = this.bitmap.height;
    const w = this.bitmap.width;
    const gradationLeft = this.dTextInfo.gradationLeft;
    if (gradationLeft > 0) {
      this.bitmap.clearRect(0, 0, gradationLeft, h);
      this.bitmap.gradientFillRect(
        0,
        0,
        gradationLeft,
        h,
        "rgba(0, 0, 0, 0)",
        this.dTextInfo.color,
        false
      );
    }
    const gradationRight = this.dTextInfo.gradationRight;
    if (gradationRight > 0) {
      this.bitmap.clearRect(w - gradationRight, 0, gradationRight, h);
      this.bitmap.gradientFillRect(
        w - gradationRight,
        0,
        gradationRight,
        h,
        this.dTextInfo.color,
        "rgba(0, 0, 0, 0)",
        false
      );
    }
  };

  /**
   * Window_Dummy
   * 動的文字列ピクチャ描画用のダミーウィンドウ
   */
  class Window_Dummy extends Window_Base {
    constructor() {
      super(new Rectangle());
    }

    createTextContents(text, dTextInfo) {
      this._size = dTextInfo.size;
      this._face = dTextInfo.font;
      this._lineHeight = dTextInfo.lineHeight;
      this._text = text;
      const rect = this.textSizeEx(text);
      this.textPictureWidth = rect.width;
      this.textPictureAlign = dTextInfo.align;
      this.contents = new Bitmap(rect.width, rect.height);
      return this.contents;
    }

    drawTextContents() {
      this.drawTextEx(this._text, 0, 0);
      this.contents = null;
      this.destroy();
    }

    calcTextHeight(textState) {
      return this._lineHeight || super.calcTextHeight(textState);
    }

    processAllText(textState) {
      if (textState.drawing) {
        this.setStartXForAlign(textState);
      }
      super.processAllText(textState);
    }

    processNewLine(textState) {
      super.processNewLine(textState);
      if (textState.drawing) {
        this.setStartXForAlign(textState);
      }
    }

    setStartXForAlign(textState) {
      const lines = textState.text.slice(textState.index).split("\n");
      textState.widthList = lines.map((line) => this.textSizeEx(line).width);
      textState.x = this.findStartXForAlign(textState);
    }

    resetFontSettings() {
      super.resetFontSettings();
      if (this._size) {
        this.contents.fontSize = this._size;
      }
      if (this._face) {
        this.contents.fontFace = this._face;
      }
    }

    processEscapeCharacter(code, textState) {
      super.processEscapeCharacter(code, textState);
      switch (code) {
        case "OC":
          const colorCode = this.obtainEscapeParamString(textState);
          const colorIndex = Number(colorCode);
          this.changeOutlineColor(
            !isNaN(colorIndex) ? ColorManager.textColor(colorIndex) : colorCode
          );
          break;
        case "OW":
          this.contents.outlineWidth = this.obtainEscapeParam(textState);
          break;
        case "F":
          this.changeFontStyle(this.obtainEscapeParamString(textState));
          break;
      }
    }

    changeFontStyle(value) {
      switch (value.toUpperCase()) {
        case "B":
          this.contents.fontBold = true;
          break;
        case "I":
          this.contents.fontItalic = true;
          break;
        default:
          this.contents.fontItalic = false;
          this.contents.fontBold = false;
      }
    }

    obtainEscapeParamString(textState) {
      const 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 "";
      }
    }

    findStartXForAlign(textState) {
      const dx = this.textPictureWidth - textState.widthList.shift();
      if (this.textPictureAlign === "center") {
        return Math.floor(dx / 2);
      } else if (this.textPictureAlign === "right") {
        return dx;
      } else {
        return 0;
      }
    }
  }
})();


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

/**
 * 2021/07/05 1.0.2 MZ 1.3.2に対応
 * 2021/06/22 1.0.1 サブフォルダからの読み込みに対応
 * 2021/05/29 1.0.0 公開
 */

/*:ja
 * @plugindesc 全てのセーブデータで共有するスイッチ・変数を指定する
 * @author DarkPlasma
 * @license MIT
 *
 * @target MZ
 * @url https://github.com/elleonard/DarkPlasma-MZ-Plugins/tree/release
 *
 * @param switchRangeList
 * @desc 共有セーブに保存するスイッチの範囲リストを指定します。
 * @text スイッチ範囲リスト
 * @type struct<SwitchRange>[]
 * @default []
 *
 * @param variableRangeList
 * @desc 共有セーブに保存する変数の範囲リストを指定します。
 * @text 変数範囲リスト
 * @type struct<VariableRange>[]
 * @default []
 *
 * @command saveSharedInfo
 * @text 共有セーブに保存する
 * @desc 共有セーブデータにスイッチ・変数を保存します。
 *
 * @help
 * version: 1.0.2
 * 全てのセーブデータで共有するスイッチ・変数を指定します。
 * 指定したスイッチ・変数の値は共有セーブデータ(save/shared.rmmzsave)に保存します。
 *
 * プラグインコマンドで共有セーブデータを更新できます。
 */
/*~struct~SwitchRange:
 * @param from
 * @desc このスイッチ以降、終端で指定したスイッチまでを共有セーブに保存します。
 * @text 閉区間開始
 * @type switch
 * @default 1
 *
 * @param to
 * @desc 開始で指定したスイッチからこのスイッチまでを共有セーブに保存します。
 * @text 閉区間終端
 * @type switch
 * @default 1
 */
/*~struct~VariableRange:
 * @param from
 * @desc この変数以降、終端で指定した変数までを共有セーブに保存します。
 * @text 閉区間開始
 * @type variable
 * @default 1
 *
 * @param to
 * @desc 開始で指定した変数からこの変数までを共有セーブに保存します。
 * @text 閉区間終端
 * @type variable
 * @default 1
 */
(() => {
  "use strict";

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

  const pluginParametersOf = (pluginName) =>
    PluginManager.parameters(pluginName);

  const pluginParameters = pluginParametersOf(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 || "{}");
    }),
  };

  PluginManager.registerCommand(pluginName, "saveSharedInfo", function () {
    DataManager.saveSharedInfo();
  });

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

  const _DataManager_isMapLoaded = DataManager.isMapLoaded;
  DataManager.isMapLoaded = function () {
    /**
     * 共有データロード完了後にマップ処理を行う
     */
    return _DataManager_isMapLoaded.call(this) && this.isSharedInfoLoaded();
  };

  DataManager.isSharedInfoLoaded = function () {
    return this._isSharedInfoLoaded;
  };

  DataManager.loadSharedInfo = function () {
    this._isSharedInfoLoaded = false;
    StorageManager.loadObject("shared")
      .then((sharedInfo) => {
        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);
        });
        this._isSharedInfoLoaded = true;
        return 0;
      })
      .catch(() => {
        /**
         * セーブデータが存在しなかった場合にもロード完了扱いにする
         */
        this._isSharedInfoLoaded = true;
      });
  };

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

  const _DataManager_saveGame = DataManager.saveGame;
  DataManager.saveGame = function (savefileId) {
    this.saveSharedInfo();
    return _DataManager_saveGame.call(this, savefileId);
  };

  DataManager.saveSharedInfo = function () {
    StorageManager.saveObject("shared", this.makeSharedInfo());
  };

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

  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),
        };
      });
  };

  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),
        };
      });
  };

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

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// DirectivityShake.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.2.0 2022/01/08 ランダムシェイクするコマンドを追加
// 1.1.1 2021/07/10 SINカーブで始点が0でなくなる問題を修正
// 1.1.0 2021/01/10 MZで動作するよう修正
// 1.0.0 2016/11/03 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:ja
 * @plugindesc 指向性シェイクプラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/DirectivityShake.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author トリアコンタン
 *
 * @command SHAKE_SETTING
 * @text シェイク指向設定
 * @desc 「画面のシェイク」コマンドに方向やSINカーブを設定します。
 *
 * @arg rotation
 * @text 角度
 * @desc 指定した角度でシェイクします。(0-360)
 * @default 0
 * @type number
 * @min 0
 * @max 360
 *
 * @arg sinWave
 * @text SINカーブ
 * @desc 有効にすると振動がSINカーブを描くようになります。
 * @default false
 * @type boolean
 *
 * @command RANDOM_SHAKE_SETTING
 * @text ランダムシェイク設定
 * @desc 「画面のシェイク」コマンドの角度をランダムにします。
 *
 * @arg sinWave
 * @text SINカーブ
 * @desc 有効にすると振動がSINカーブを描くようになります。
 * @default false
 * @type boolean
 *
 * @arg interval
 * @text 更新間隔
 * @desc シェイク中に角度が更新される間隔です。0を指定すると更新されなくなります。
 * @default 1
 * @type number
 *
 * @help イベントコマンド「画面のシェイク」に指向性を持たせることができます。
 * 角度を指定して縦や斜めに振動させることが可能です。
 *
 * また振動方法を通常の方法以外にsinカーブに設定できます。独特の抑揚がつきます。
 *
 * 「画面のシェイク」を行う直前に、プラグインコマンドを実行してください。
 * シェイクが終了すると設定は自動でリセットされます。
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(() => {
  "use strict";
  const script = document.currentScript;

  PluginManagerEx.registerCommand(script, "SHAKE_SETTING", (args) => {
    $gameScreen.setShakeRotation(args.rotation, args.sinWave);
  });

  PluginManagerEx.registerCommand(script, "RANDOM_SHAKE_SETTING", (args) => {
    $gameScreen.setShakeRandom(args.interval, args.sinWave);
  });

  //=============================================================================
  // Game_Screen
  //  シェイクの方向を保持します。
  //=============================================================================
  Game_Screen.prototype.getShakeRotation = function () {
    return this._shakeRotation;
  };

  Game_Screen.prototype.setShakeRotation = function (value, sin) {
    this._shakeRotation = (value * Math.PI) / 180;
    this._shakeSinWave = sin;
    this._shakeRandomInterval = 0;
  };

  Game_Screen.prototype.setShakeRandom = function (interval, sin) {
    this._shakeRotation = (Math.randomInt(360) * Math.PI) / 180;
    this._shakeSinWave = sin;
    this._shakeRandomInterval = interval;
  };

  const _Game_Screen_clearShake = Game_Screen.prototype.clearShake;
  Game_Screen.prototype.clearShake = function () {
    _Game_Screen_clearShake.apply(this, arguments);
    this.clearDirectivityShake();
  };

  Game_Screen.prototype.clearDirectivityShake = function () {
    this._shakeRotation = 0;
    this._shakeSinWave = false;
  };

  const _Game_Screen_updateShake = Game_Screen.prototype.updateShake;
  Game_Screen.prototype.updateShake = function () {
    const wasShake = this.isNeedShakeUpdate();
    if (
      this._shakeRandomInterval > 0 &&
      Graphics.frameCount % this._shakeRandomInterval === 0
    ) {
      this._shakeRotation = (Math.randomInt(360) * Math.PI) / 180;
    }
    if (this._shakeSinWave && wasShake) {
      this.updateSinShake();
    } else {
      _Game_Screen_updateShake.apply(this, arguments);
    }
    if (wasShake && !this.isNeedShakeUpdate()) {
      this.clearDirectivityShake();
    }
  };

  const _Game_Screen_startShake = Game_Screen.prototype.startShake;
  Game_Screen.prototype.startShake = function (power, speed, duration) {
    _Game_Screen_startShake.apply(this, arguments);
    this._shakeDurationTarget = duration;
  };

  Game_Screen.prototype.updateSinShake = function () {
    const pos = this._shakeDurationTarget - this._shakeDuration;
    this._shake =
      Math.sin((3 * pos * this._shakeSpeed * Math.PI) / 180) *
      this._shakePower *
      3;
    this._shakeDuration--;
    if (this._shakeDuration === 0) {
      this._lastShake = this._shake;
    }
    if (this._lastShake * this._shake < 0) {
      this._shake = 0;
      this._lastShake = 0;
    }
  };

  Game_Screen.prototype.isNeedShakeUpdate = function () {
    return this._shakeDuration > 0 || this._shake !== 0;
  };

  //=============================================================================
  // Spriteset_Base
  //  シェイクの方向を反映します。
  //=============================================================================
  const _Spriteset_Base_updatePosition =
    Spriteset_Base.prototype.updatePosition;
  Spriteset_Base.prototype.updatePosition = function () {
    _Spriteset_Base_updatePosition.apply(this, arguments);
    const shakeRotation = $gameScreen.getShakeRotation();
    if (shakeRotation) {
      const shakeDistance = Math.round($gameScreen.shake());
      this.x -= shakeDistance;
      this.x += Math.cos(shakeRotation) * shakeDistance;
      this.y += Math.sin(shakeRotation) * shakeDistance;
    }
  };
})();


code:
/*:
@target MZ
@plugindesc Equipment scene expansion v1.4.2
@author unagi ootoro
@url https://raw.githubusercontent.com/unagiootoro/RPGMZ/master/EquipScene_Extension.js

@help
It is a plug-in that expands the equipment scene.
By installing this plug-in, you will be able to change the layout of the equipment screen and expand the equipment slot.

【Layout change】
By setting LayoutMode, you can change the layout so that equipment slots and equipment items are displayed at the same time.
If LayoutMode is set to 1, the status screen remains the same and equipment items are displayed in one line.
If LayoutMode is set to 2, the status screen will be reduced and equipment items will be displayed in 2 lines.

【Equipment slot expansion】
This function assigns an equipment type to each equipment slot.
By using this function, you will be able to equip multiple ornaments and multiple weapons of different systems.

■ Equipment slot settings
Set the equipment slot by setting the plug-in parameter "Default Equip Slots".

■ Setting equipment slots for individual characters
In the memo field of either actor / occupation / state
<EquipSlots: Equipment Slots>
By writing, you can set individual equipment slots for each character.
Set the equipment slot in the same format as the plug-in parameter "Default Equip Slots".
(Setting Example)
<EquipSlots: [1, 2, 3, 4, 5]>

■ Multiple types of weapons
You can set multiple weapon types with the plug-in parameter "Weapon Types".
This allows you to separate weapons by lineage, just as armor separates into body, head, and shield.
(Example of setting the plug-in parameter "Weapon Types")
[1, 2]

Next, give the weapon a weapon type.
In the memo field of the weapon
<WeaponType: Weapon Type ID>
It is described in the format. If you do not specify this setting, the weapon type ID will be 1.
(Weapon type ID setting example)
<WeaponType: 2>

■ Prohibit the equipment of the same type of weapon / armor
This function is used when you want to prevent dual wield characters from equipping multiple two-handed swords.
In the plugin parameter "NotMultiEquipWeapon" or "NotMultiEquipArmor"
If you list the weapon / armor type ID that prohibits multiple equipment,
Weapons / armor with the corresponding type ID cannot be equipped more than once.

Also, by making the following settings, you will be able to set equipment coexistence prohibition for each weapon / armor.
In the memo field of the weapon
<NotMultiEquipWeaponIds: [Weapon ID1, Weapon ID2, ...]>
Or in the memo field of the armor
<NotMultiEquipArmorIds: [Armor ID1, Armor ID2, ...]>
You can set the equipment coexistence prohibition by describing.

For example, when setting the coexistence prohibition of weapon ID1 and weapon ID2,
In the memo field of weapon ID1
<NotMultiEquipWeaponIds: [2]>
In the memo field of weapon ID2
<NotMultiEquipWeaponIds: [1]>
It is described as. Be careful not to set only one of the equipment coexistence prohibition settings.

■ Set only one weapon / armor that can be equipped
In the memo field of the weapon or armor
<UniqueEquip>
By writing, you can set only one weapon / armor that can be equipped.

■ Change of initial equipment
If you change the equipment slot from the default one, the contents of the initial equipment will not be reflected.
In that case, change the equipment by performing "Forced change" with the plug-in command "Change equipment slot".

【License】
This plugin is available under the terms of the MIT license.

@param LayoutMode
@type number
@default 2
@desc 0: Default 1: Show equipment slots and equipment items at the same time 2: Show equipment items in 2 lines

@param ActorFaceHeight
@type number
@default 43
Specifies the height of the actor's face graphic when @desc LayoutMode = 2.

@param DefaultEquipSlots
@type string
@default ["1","2","3","4","5"]
@desc This is the default equipment slot. Specify the equipment type ID in slot order.

@param WeaponTypes
@type string
@default ["1"]
@desc Specifies a list of weapon equipment type IDs.

@param DualWieldSlot
@type number
@default 1
@desc Specifies the index of the slot to be rewritten in the case of dual wield. (Example) Specify 1 to rewrite the second slot

@param WeaponTypeWhenDualWield
@type number
@default 1
@desc Specifies the equipment type ID to be rewritten during dual wield.

@param NotMultiEquipWeapon
@type number[]
@default []
@desc Specifies the weapon type ID that prohibits multiple equipment.

@param NotMultiEquipArmor
@type number[]
@default []
@desc Specifies the armor type ID that prohibits multiple equipment.

@param RemoveEquipText
@type string
@default remove
@desc Specifies the wording to be displayed in the empty frame when removing the weapon.

@param RemoveEquipIconIndex
@type number
@default 0
@desc Specifies the icon to display in the empty frame when removing the weapon.

@param DisableCommandWindow
@type boolean
@default false
When @desc true is set, the window that displays the strongest equipment etc. is hidden.

@command ChangeEquipSlot
@text Equipment slot change
@desc
Changes the equipment slot of the specified actor.

@arg ActorId
@text Actor ID
@type actor
@default 1
@desc
Specify the actor whose equipment slot is to be changed.

@arg SlotIndex
@text slot index
@type number
@default 0
@desc
Specifies the index of the equipment slot to change. (Sequential number from 0)

@arg WeaponId
@text Weapon ID
@type weapon
@default 0
@desc
Specify the weapon ID to change. If you want to change the armor, specify 0.

@arg ArmorId
@text Armor ID
@type armor
@default 0
@desc
Specify the armor ID to change. If you want to change the weapon, specify 0.

@arg ForceChange
@text forced change
@type boolean
@default false
@desc
If set to true, the equipment will be forcibly changed.
*/

/*:ja
@target MZ
@plugindesc 装備シーン拡張 v1.4.2
@author うなぎおおとろ
@url https://raw.githubusercontent.com/unagiootoro/RPGMZ/master/EquipScene_Extension.js

@help
装備シーンを拡張するプラグインです。
このプラグインを導入することで、装備画面のレイアウト変更と装備スロットの拡張ができるようになります。

【レイアウト変更】
LayoutModeを設定することで、装備スロットと装備アイテムを同時表示するようにレイアウトを変更します。
LayoutModeに1を設定した場合は、ステータス画面はそのままで、装備アイテムは1行で表示します。
LayoutModeに2を設定した場合は、ステータス画面を縮小し、装備アイテムを2行で表示します。

【装備スロット拡張】
装備スロットごとに装備タイプを割り当てる機能です。
この機能を使用することで、装飾品を複数装備したり、系統の異なる武器を複数装備したりすることができるようになります。

■装備スロットの設定
プラグインパラメータ「DefaultEquipSlots」を設定することで、装備スロットを設定します。

■キャラ個別の装備スロットの設定
アクター/職業/ステートのいずれかのメモ欄に
<EquipSlots: 装備スロット>
と記載することで、キャラごとに個別の装備スロットを設定することができます。
装備スロットにはプラグインパラメータ「DefaultEquipSlots」と同じ形式で設定します。
(設定例)
<EquipSlots: [1, 2, 3, 4, 5]>

■複数系統の武器
プラグインパラメータ「WeaponTypes」で武器系統を複数設定することができます。
これによって、防具が身体、頭、盾と分かれているのと同じように武器も系統ごとに分けることができるようになります。
(プラグインパラメータ「WeaponTypes」の設定例)
[1, 2]

次に武器に武器タイプを持たせます。
武器のメモ欄に
<WeaponType: 武器タイプID>
という形式で記載します。この設定を記載しなかった場合、武器タイプIDは1になります。
(武器タイプIDの設定例)
<WeaponType: 2>

■同じタイプの武器/防具の装備を禁止する
この機能は、二刀流のキャラは両手剣を複数装備できないようにしたい場合などに使用します。
プラグインパラメータ「NotMultiEquipWeapon」または「NotMultiEquipArmor」に
複数装備を禁止する武器/防具タイプIDを記載すると、
該当するタイプIDを持つ武器/防具は複数装備ができなくなります。

また次の設定を行うことで、武器/防具単位で装備共存禁止の設定を行うことができるようになります。
武器のメモ欄に
<NotMultiEquipWeaponIds: [武器ID1, 武器ID2, ...]>
または防具のメモ欄に
<NotMultiEquipArmorIds: [防具ID1, 防具ID2, ...]>
と記載することで装備共存禁止の設定ができるようになります。

例えば、武器ID1と武器ID2の共存禁止設定を行う場合、
武器ID1のメモ欄に
<NotMultiEquipWeaponIds: [2]>
武器ID2のメモ欄に
<NotMultiEquipWeaponIds: [1]>
と記載します。装備共存禁止の設定が片方だけにならないように注意してください。

■一つだけ装備可能な武器/防具を設定する
武器または防具のメモ欄に
<UniqueEquip>
と記載することで、一つだけ装備可能な武器/防具を設定することができます。

■初期装備の変更
装備スロットをデフォルトのものから変更した場合、初期装備の内容が反映されなくなります。
その場合、プラグインコマンド「装備スロット変更」で「強制変更」を行うことで装備を変更してください。

【ライセンス】
このプラグインは、MITライセンスの条件の下で利用可能です。

@param LayoutMode
@type number
@default 2
@desc 0: デフォルト  1: 装備スロットと装備アイテムを同時表示  2: 装備アイテムを2行で表示

@param ActorFaceHeight
@type number
@default 43
@desc LayoutMode = 2のときのアクターの顔グラフィックの高さを指定します。

@param DefaultEquipSlots
@type number[]
@default ["1","2","3","4","5"]
@desc デフォルトの装備スロットです。スロット順に装備タイプIDを指定します。

@param WeaponTypes
@type number[]
@default ["1"]
@desc 武器の装備タイプIDの一覧を指定します。

@param DualWieldSlot
@type number
@default 1
@desc 二刀流の場合に書き換えるスロットのインデックスを指定します。(例)2番目のスロットを書き換える場合は1を指定

@param WeaponTypeWhenDualWield
@type number
@default 1
@desc 二刀流時に書き換える装備タイプIDを指定します。

@param NotMultiEquipWeapon
@type number[]
@default []
@desc 複数装備を禁止する武器タイプIDを指定します。

@param NotMultiEquipArmor
@type number[]
@default []
@desc 複数装備を禁止する防具タイプIDを指定します。

@param RemoveEquipText
@type string
@default 外す
@desc 武器を外すときの空枠に表示する文言を指定します。

@param RemoveEquipIconIndex
@type number
@default 0
@desc 武器を外すときの空枠に表示するアイコンを指定します。

@param DisableCommandWindow
@type boolean
@default false
@desc trueを設定すると最強装備等を表示するウィンドウを非表示にします。

@command ChangeEquipSlot
@text 装備スロット変更
@desc
指定したアクターの装備スロットを変更します。

@arg ActorId
@text アクターID
@type actor
@default 1
@desc
装備スロットを変更するアクターを指定します。

@arg SlotIndex
@text スロットインデックス
@type number
@default 0
@desc
変更する装備スロットのインデックスを指定します。(0からの連番)

@arg WeaponId
@text 武器ID
@type weapon
@default 0
@desc
変更する武器IDを指定します。防具を変更する場合、0を指定してください。

@arg ArmorId
@text 防具ID
@type armor
@default 0
@desc
変更する防具IDを指定します。武器を変更する場合、0を指定してください。

@arg ForceChange
@text 強制変更
@type boolean
@default false
@desc
trueを設定すると強制的に装備を変更します。
*/

const EquipScenePluginName =
  document.currentScript.src.match(/^.*\/(.+)\.js$/)[1];

(() => {
  "use strict";

  class PluginParamsParser {
    static parse(params, typeData, predictEnable = true) {
      return new PluginParamsParser(predictEnable).parse(params, typeData);
    }

    constructor(predictEnable = true) {
      this._predictEnable = predictEnable;
    }

    parse(params, typeData, loopCount = 0) {
      if (++loopCount > 255) throw new Error("endless loop error");
      const result = {};
      for (const name in typeData) {
        result[name] = this.convertParam(
          params[name],
          typeData[name],
          loopCount
        );
      }
      if (!this._predictEnable) return result;
      if (typeof params === "object" && !(params instanceof Array)) {
        for (const name in params) {
          if (result[name]) continue;
          const param = params[name];
          const type = this.predict(param);
          result[name] = this.convertParam(param, type, loopCount);
        }
      }
      return result;
    }

    convertParam(param, type, loopCount) {
      if (typeof type === "string") {
        return this.cast(param, type);
      } else if (typeof type === "object" && type instanceof Array) {
        const aryParam = JSON.parse(param);
        if (typeof type[0] === "string") {
          return aryParam.map((strParam) => this.cast(strParam, type[0]));
        } else {
          return aryParam.map(
            (strParam) => this.parse(JSON.parse(strParam), type[0]),
            loopCount
          );
        }
      } else if (typeof type === "object") {
        return this.parse(JSON.parse(param), type, loopCount);
      } else {
        throw new Error(`${type} is not string or object`);
      }
    }

    cast(param, type) {
      switch (type) {
        case "any":
          if (!this._predictEnable) throw new Error("Predict mode is disable");
          return this.cast(param, this.predict(param));
        case "string":
          return param;
        case "number":
          if (param.match(/\d+\.\d+/)) return parseFloat(param);
          return parseInt(param);
        case "boolean":
          return param === "true";
        default:
          throw new Error(`Unknow type: ${type}`);
      }
    }

    predict(param) {
      if (param.match(/^\d+$/) || param.match(/^\d+\.\d+$/)) {
        return "number";
      } else if (param === "true" || param === "false") {
        return "boolean";
      } else {
        return "string";
      }
    }
  }

  const typeData = {
    DefaultEquipSlots: ["any"],
    WeaponTypes: ["any"],
    NotMultiEquipWeapon: ["any"],
    NotMultiEquipArmor: ["any"],
  };
  const PP = PluginParamsParser.parse(
    PluginManager.parameters(EquipScenePluginName),
    typeData
  );

  const LayoutMode = PP.LayoutMode;
  const ActorFaceHeight = PP.ActorFaceHeight;
  const DualWieldSlot = PP.DualWieldSlot;
  const DefaultEquipSlots = PP.DefaultEquipSlots;
  const WeaponTypes = PP.WeaponTypes;
  const WeaponTypeWhenDualWield = PP.WeaponTypeWhenDualWield;
  const NotMultiEquipWeapon = PP.NotMultiEquipWeapon;
  const NotMultiEquipArmor = PP.NotMultiEquipArmor;
  const RemoveEquipText = PP.RemoveEquipText;
  const RemoveEquipIconIndex = PP.RemoveEquipIconIndex;
  const DisableCommandWindow = PP.DisableCommandWindow;

  // Register plugin commands.
  PluginManager.registerCommand(
    EquipScenePluginName,
    "ChangeEquipSlot",
    function (args) {
      const params = PluginParamsParser.parse(args, {});
      const actorId = params.ActorId;
      const slotIndex = params.SlotIndex;
      const weaponId = params.WeaponId;
      const armorId = params.ArmorId;
      const forceChange = params.ForceChange;
      const actor = $gameActors.actor(actorId);
      let item = null;
      if (weaponId > 0) {
        item = $dataWeapons[weaponId];
      } else if (armorId > 0) {
        item = $dataArmors[armorId];
      }
      if (!item) return;
      if (forceChange) {
        actor.forceChangeEquip(slotIndex, item);
      } else {
        actor.changeEquip(slotIndex, item);
      }
    }
  );

  // Change equip layout.
  Scene_Equip.prototype.createCommandWindow = function () {
    const rect = this.commandWindowRect();
    this._commandWindow = new Window_EquipCommand(rect);
    this._commandWindow.setHelpWindow(this._helpWindow);
    this._commandWindow.setHandler("equip", this.commandEquip.bind(this));
    this._commandWindow.setHandler("optimize", this.commandOptimize.bind(this));
    this._commandWindow.setHandler("clear", this.commandClear.bind(this));
    this._commandWindow.setHandler("cancel", this.popScene.bind(this));
    this._commandWindow.setHandler("pagedown", this.nextActor.bind(this));
    this._commandWindow.setHandler("pageup", this.previousActor.bind(this));
    this.addWindow(this._commandWindow);
  };

  const _Scene_Equip_createSlotWindow = Scene_Equip.prototype.createSlotWindow;
  Scene_Equip.prototype.createSlotWindow = function () {
    _Scene_Equip_createSlotWindow.call(this);
    this._slotWindow.setHandler("pagedown", this.nextActor.bind(this));
    this._slotWindow.setHandler("pageup", this.previousActor.bind(this));
    if (DisableCommandWindow) {
      this._slotWindow.setHandler("cancel", this.popScene.bind(this));
    }
  };

  const _Scene_Equip_start = Scene_Equip.prototype.start;
  Scene_Equip.prototype.start = function () {
    _Scene_Equip_start.call(this);
    if (LayoutMode >= 1) this._itemWindow.show();
    if (DisableCommandWindow) {
      this._slotWindow.select(0);
      this._slotWindow.activate();
    } else {
      this._commandWindow.activate();
    }
  };

  const _Scene_Equip_update = Scene_Equip.prototype.update;
  Scene_Equip.prototype.update = function () {
    _Scene_Equip_update.call(this);
    if (this._slotWindow.active || this._itemWindow.active) {
      this._itemWindow.setDrawState("draw");
    } else {
      this._itemWindow.setDrawState("undraw");
    }
  };

  const _Scene_Equip_createCommandWindow =
    Scene_Equip.prototype.createCommandWindow;
  Scene_Equip.prototype.createCommandWindow = function () {
    if (!DisableCommandWindow) _Scene_Equip_createCommandWindow.call(this);
  };

  const _Scene_Equip_commandWindowRect =
    Scene_Equip.prototype.commandWindowRect;
  Scene_Equip.prototype.commandWindowRect = function () {
    const rect = _Scene_Equip_commandWindowRect.call(this);
    if (DisableCommandWindow) {
      rect.height = 0;
    }
    return rect;
  };

  Scene_Equip.prototype.slotWindowRect = function () {
    const commandWindowRect = this.commandWindowRect();
    const wx = this.statusWidth();
    const wy = commandWindowRect.y + commandWindowRect.height;
    const ww = Graphics.boxWidth - this.statusWidth();
    let wh = this.mainAreaHeight() - commandWindowRect.height;
    if (LayoutMode >= 1) wh = 244;
    return new Rectangle(wx, wy, ww, wh);
  };

  Scene_Equip.prototype.itemWindowRect = function () {
    const slotWindowRect = this.slotWindowRect();
    if (LayoutMode === 1) {
      const wx = slotWindowRect.x;
      const wy = slotWindowRect.y + slotWindowRect.height;
      const ww = slotWindowRect.width;
      const wh = this.mainAreaBottom() - wy;
      return new Rectangle(wx, wy, ww, wh);
    } else if (LayoutMode === 2) {
      const wx = 0;
      const wy = slotWindowRect.y + slotWindowRect.height;
      const ww = Graphics.boxWidth;
      const wh = this.mainAreaBottom() - wy;
      return new Rectangle(wx, wy, ww, wh);
    } else {
      return slotWindowRect;
    }
  };

  Scene_Equip.prototype.statusWindowRect = function () {
    const itemWindowRect = this.itemWindowRect();
    const wx = 0;
    const wy = this.mainAreaTop();
    const ww = this.statusWidth();
    let wh;
    if (LayoutMode === 2) {
      wh = this.mainAreaHeight() - itemWindowRect.height;
    } else {
      wh = this.mainAreaHeight();
    }
    return new Rectangle(wx, wy, ww, wh);
  };

  Scene_Equip.prototype.onSlotOk = function () {
    if (LayoutMode >= 1) {
      this._slotWindow.deactivate();
    } else {
      this._slotWindow.hide();
      this._itemWindow.show();
    }
    this._itemWindow.activate();
    this._itemWindow.select(0);
  };

  Scene_Equip.prototype.onSlotCancel = function () {
    this._slotWindow.deselect();
    this._commandWindow.activate();
  };

  Scene_Equip.prototype.onItemOk = function () {
    SoundManager.playEquip();
    this.executeEquipChange();
    if (LayoutMode >= 1) {
      this._itemWindow.deactivate();
      this._itemWindow.deselect();
      this._slotWindow.activate();
    } else {
      this.hideItemWindow();
    }
    this._slotWindow.refresh();
    this._itemWindow.refresh();
    this._statusWindow.refresh();
  };

  Scene_Equip.prototype.onItemCancel = function () {
    if (LayoutMode >= 1) {
      this._itemWindow.deactivate();
      this._itemWindow.deselect();
      this._slotWindow.activate();
    } else {
      this.hideItemWindow();
    }
  };

  Scene_Equip.prototype.onActorChange = function () {
    Scene_MenuBase.prototype.onActorChange.call(this);
    this.refreshActor();
    if (LayoutMode >= 1) {
      this._itemWindow.deselect();
      this._itemWindow.deactivate();
    } else {
      this.hideItemWindow();
    }
    if (DisableCommandWindow) {
      this._slotWindow.select(0);
      this._slotWindow.activate();
    } else {
      this._slotWindow.deselect();
      this._slotWindow.deactivate();
      this._commandWindow.activate();
    }
  };

  Window_EquipItem.prototype.maxCols = function () {
    if (LayoutMode === 2) return 2;
    return 1;
  };

  Window_EquipStatus.prototype.drawActorName = function (actor, x, y, width) {
    if (LayoutMode <= 1)
      return Window_StatusBase.prototype.drawActorName.call(this, ...arguments);
    width = width || 168;
    this.changeTextColor(ColorManager.hpColor(actor));
    this.drawText(actor.name(), x, y, width, "right");
  };

  Window_EquipStatus.prototype.refresh = function () {
    this.contents.clear();
    if (this._actor) {
      const nameRect = this.itemLineRect(0);
      nameRect.width = this.width - ImageManager.faceWidth - this.padding * 2;
      this.drawActorName(
        this._actor,
        ImageManager.faceWidth,
        0,
        nameRect.width
      );
      let faceHeight = ImageManager.faceHeight;
      if (LayoutMode === 2) faceHeight = ActorFaceHeight;
      let faceY = nameRect.height;
      if (LayoutMode === 2) faceY = nameRect.y;
      this.drawActorFace(
        this._actor,
        nameRect.x,
        faceY,
        ImageManager.faceWidth,
        faceHeight
      );
      this.drawAllParams();
    }
  };

  Window_EquipStatus.prototype.paramY = function (index) {
    if (LayoutMode === 2) {
      return Math.floor(this.lineHeight() * (index + 2));
    } else {
      const faceHeight = ImageManager.faceHeight;
      return faceHeight + Math.floor(this.lineHeight() * (index + 1.5));
    }
  };

  const _Window_EquipItem_initialize = Window_EquipItem.prototype.initialize;
  Window_EquipItem.prototype.initialize = function (rect) {
    _Window_EquipItem_initialize.call(this, rect);
    this._drawState = "undraw";
  };

  // drawState is "undraw" or "draw".
  Window_EquipItem.prototype.setDrawState = function (drawState) {
    if (this._drawState !== drawState) {
      this._drawState = drawState;
      this.refresh();
    }
  };

  Window_EquipItem.prototype.drawItem = function (index) {
    const item = this.itemAt(index);
    if (item) {
      const numberWidth = this.numberWidth();
      const rect = this.itemLineRect(index);
      this.changePaintOpacity(this.isEnabled(item));
      this.drawItemName(item, rect.x, rect.y, rect.width - numberWidth);
      this.drawItemNumber(item, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    } else {
      const numberWidth = this.numberWidth();
      const rect = this.itemLineRect(index);
      const removeEquip = {
        name: RemoveEquipText,
        iconIndex: RemoveEquipIconIndex,
      };
      this.drawItemName(removeEquip, rect.x, rect.y, rect.width - numberWidth);
    }
  };

  const _Window_EquipItem_makeItemList =
    Window_EquipItem.prototype.makeItemList;
  Window_EquipItem.prototype.makeItemList = function () {
    if (this._drawState === "draw") {
      _Window_EquipItem_makeItemList.call(this);
    } else {
      this._data = [];
    }
  };

  // Extend equip slots.
  const _Scene_Boot_start = Scene_Boot.prototype.start;
  Scene_Boot.prototype.start = function () {
    _Scene_Boot_start.call(this);
    DataManager.setupWeaponTypes();
  };

  DataManager.setupWeaponTypes = function () {
    for (let i = 1; i < $dataWeapons.length; i++) {
      const weapon = $dataWeapons[i];
      if (weapon.meta.WeaponType)
        weapon.etypeId = parseInt(weapon.meta.WeaponType);
    }
  };

  Game_Actor.prototype.baseEquipSlots = function () {
    if (this.actor().meta.EquipSlots) {
      return JSON.parse(this.actor().meta.EquipSlots);
    } else if (this.currentClass().meta.EquipSlots) {
      return JSON.parse(this.currentClass().meta.EquipSlots);
    } else if (this.states().some((state) => state.meta.EquipSlots)) {
      const state = this.states().find((state) => state.meta.EquipSlots);
      return JSON.parse(state.meta.EquipSlots);
    } else {
      return DefaultEquipSlots.concat();
    }
  };

  Game_Actor.prototype.equipSlots = function () {
    const slots = this.baseEquipSlots();
    if (slots.length >= 2 && this.isDualWield()) {
      slots[DualWieldSlot] = WeaponTypeWhenDualWield;
    }
    return slots;
  };

  Game_Actor.prototype.canMultiEquipWeaponByWeaponTypeId = function (weapon) {
    if (!NotMultiEquipWeapon.includes(weapon.wtypeId)) return true;
    const equipWeapon = this._equips
      .filter((equip) => DataManager.isWeapon(equip.object()))
      .map((data) => data.object());
    return (
      equipWeapon.filter((weapon) =>
        NotMultiEquipWeapon.includes(weapon.wtypeId)
      ).length === 0
    );
  };

  Game_Actor.prototype.canMultiEquipWeaponByItemId = function (weapon) {
    if (!weapon.meta.NotMultiEquipWeaponIds) return true;
    const notMultiEquipWeaponIds = JSON.parse(
      weapon.meta.NotMultiEquipWeaponIds
    );
    const equipWeapon = this._equips
      .filter((equip) => DataManager.isWeapon(equip.object()))
      .map((data) => data.object());
    return (
      equipWeapon.filter((weapon) => notMultiEquipWeaponIds.includes(weapon.id))
        .length === 0
    );
  };

  Game_Actor.prototype.canMultiEquipArmorByArmorTypeId = function (armor) {
    if (!NotMultiEquipArmor.includes(armor.atypeId)) return true;
    const equipArmor = this._equips
      .filter((equip) => DataManager.isArmor(equip.object()))
      .map((data) => data.object());
    return (
      equipArmor.filter((armor) => NotMultiEquipArmor.includes(armor.atypeId))
        .length === 0
    );
  };

  Game_Actor.prototype.canMultiEquipArmorByItemId = function (armor) {
    if (!armor.meta.NotMultiEquipArmorIds) return true;
    const notMultiEquipArmorIds = JSON.parse(armor.meta.NotMultiEquipArmorIds);
    const equipArmor = this._equips
      .filter((equip) => DataManager.isArmor(equip.object()))
      .map((data) => data.object());
    return (
      equipArmor.filter((armor) => notMultiEquipArmorIds.includes(armor.id))
        .length === 0
    );
  };

  Game_Actor.prototype.canEquipUniqueItem = function (item) {
    if (item.meta.UniqueEquip && this.isEquipped(item)) return false;
    return true;
  };

  Game_Actor.prototype.canMultiEquip = function (item) {
    if (!this.canEquipUniqueItem(item)) return false;
    if (DataManager.isWeapon(item)) {
      return (
        this.canMultiEquipWeaponByWeaponTypeId(item) &&
        this.canMultiEquipWeaponByItemId(item)
      );
    } else {
      return (
        this.canMultiEquipArmorByArmorTypeId(item) &&
        this.canMultiEquipArmorByItemId(item)
      );
    }
  };

  Game_Actor.prototype.bestEquipItem = function (slotId) {
    const etypeId = this.equipSlots()[slotId];
    const items = $gameParty
      .equipItems()
      .filter(
        (item) =>
          item.etypeId === etypeId &&
          this.canEquip(item) &&
          this.canMultiEquip(item)
      );
    let bestItem = null;
    let bestPerformance = -1000;
    for (let i = 0; i < items.length; i++) {
      const performance = this.calcEquipItemPerformance(items[i]);
      if (performance > bestPerformance) {
        bestPerformance = performance;
        bestItem = items[i];
      }
    }
    return bestItem;
  };

  Window_StatusBase.prototype.actorSlotName = function (actor, index) {
    const slots = actor.equipSlots();
    return $dataSystem.equipTypes[slots[index]];
  };

  // Prohibit the equipment of multiple same items.
  const _Window_EquipItem_includes = Window_EquipItem.prototype.includes;
  Window_EquipItem.prototype.includes = function (item) {
    const result = _Window_EquipItem_includes.call(this, item);
    if (!item) return result;
    if (!result) return false;
    return this._actor.canMultiEquip(item);
  };

  // Setting weapon type.
  Game_Actor.prototype.isWeaponType = function (equipType) {
    return WeaponTypes.includes(equipType);
  };

  Game_Actor.prototype.initEquips = function (equips) {
    const slots = this.equipSlots();
    const maxSlots = slots.length;
    this._equips = [];
    for (let i = 0; i < maxSlots; i++) {
      this._equips[i] = new Game_Item();
    }
    for (let j = 0; j < equips.length; j++) {
      if (j < maxSlots) {
        this._equips[j].setEquip(this.isWeaponType(slots[j]), equips[j]);
      }
    }
    this.releaseUnequippableItems(true);
    this.refresh();
  };

  Game_Actor.prototype.changeEquipById = function (etypeId, itemId) {
    const slotId = etypeId - 1;
    if (this.isWeaponType(this.equipSlots()[slotId])) {
      this.changeEquip(slotId, $dataWeapons[itemId]);
    } else {
      this.changeEquip(slotId, $dataArmors[itemId]);
    }
  };
})();


code:
//=============================================================================
// Escape100.js
//=============================================================================
/*:
 * @plugindesc 逃げる成功率を100%にする
 * @author みこと
 *
 * @param escapeSwitche
 * @desc 逃げる成功率を100%にするスイッチの番号
 * @default 10
 *
 * @help 指定のスイッチがONになっている間、戦闘コマンド『逃げる』を必ず成功させます。
 * ただしバトルの処理で『逃走可能』にチェックが入っていない場合は逃げられません。
 *
 * このプラグインには、プラグインコマンドはありません。
 */

(function () {
  var parameters = PluginManager.parameters("Escape100");
  BattleManager.processEscape = function () {
    $gameParty.performEscape();
    SoundManager.playEscape();
    var success = this._preemptive ? true : Math.random() < this._escapeRatio;
    if (success || $gameSwitches.value(parameters["escapeSwitche"])) {
      this.displayEscapeSuccessMessage();
      this._escaped = true;
      this.processAbort();
    } else {
      this.displayEscapeFailureMessage();
      this._escapeRatio += 0.1;
      $gameParty.clearActions();
      this.startTurn();
    }
    return success;
  };
})();


code:
/*=============================================================================
 ExtraGauge.js
----------------------------------------------------------------------------
 (C)2020 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.5.2 2022/12/08 ゲージX座標のパラメータ初期値を変更
 1.5.1 2022/11/20 プリセットをtimeにするとラベルが表示されなくなる件を制約事項としてヘルプに記載
 1.5.0 2022/11/19 ラベル部分にアイコンを表示できる機能を追加
 1.4.0 2022/09/11 満タン時のゲージ色を指定できる機能を追加
 1.3.0 2022/08/23 現在値の描画フォーマットを指定できる機能を追加
 1.2.0 2022/05/06 ゲージの表示優先度をピクチャの下に変更できる機能を追加
 1.1.2 2021/10/20 フォント指定のヘルプが誤っていたのを修正
 1.1.1 2021/09/15 コアスクリプトv1.3.3に伴う修正
 1.1.0 2021/04/10 座標に計算式や変数を指定した場合、表示位置やリアルタイムに変更できる機能を追加
 1.0.3 2020/09/16 ゲージ表示後に一度シーンを切り替えてからマップ移動するとゲージピクチャが消えてしまう問題を修正
 1.0.2 2020/09/12 ヘルプのスクリプトの誤記を修正
 1.0,1 2020/08/30 非表示のときは画像を更新しないよう修正
 1.0.0 2020/08/29 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc 汎用ゲージ追加プラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/ExtraGauge.js
 * @base PluginCommonBase
 * @author トリアコンタン
 *
 * @param GaugeList
 * @text ゲージリスト
 * @desc 各画面に追加するゲージのリストです。
 * @default []
 * @type struct<Gauge>[]
 *
 * @param Priority
 * @text 表示優先度
 * @desc ゲージ画像の表示優先度です。マップ画面および戦闘画面のみ『ピクチャの下』に変更できます。
 * @default 0
 * @type select
 * @option 0:通常
 * @value 0
 * @option 1:ピクチャの下
 * @value 1
 *
 * @help ExtraGauge.js
 *
 * 各画面に追加で任意のゲージを好きなだけ表示できます。
 * 現在値や最大値を変数、スクリプトから指定すれば、あとは値の変動に応じて
 * 自動的にゲージが増減します。
 *
 * ゲージは、マップ画面と戦闘画面ではピクチャの上かつウィンドウの下に、
 * それ以外の画面ではウィンドウの上に表示されます。
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * フォント指定を利用する場合『FontLoad.js』が必要です。
 * 以下のページの『Raw』ボタンを押下した先から入手してください。
 * https://github.com/triacontane/RPGMakerMV/tree/mz_master/FontLoad.js
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~Gauge:
 *
 * @param SceneName
 * @text 対象シーン
 * @desc 追加対象のシーンです。オリジナルのシーンを対象にする場合はシーンクラス名を直接記入します。
 * @type select
 * @default Scene_Title
 * @option タイトル
 * @value Scene_Title
 * @option マップ
 * @value Scene_Map
 * @option ゲームオーバー
 * @value Scene_Gameover
 * @option バトル
 * @value Scene_Battle
 * @option メインメニュー
 * @value Scene_Menu
 * @option アイテム
 * @value Scene_Item
 * @option スキル
 * @value Scene_Skill
 * @option 装備
 * @value Scene_Equip
 * @option ステータス
 * @value Scene_Status
 * @option オプション
 * @value Scene_Options
 * @option セーブ
 * @value Scene_Save
 * @option ロード
 * @value Scene_Load
 * @option ゲーム終了
 * @value Scene_End
 * @option ショップ
 * @value Scene_Shop
 * @option 名前入力
 * @value Scene_Name
 * @option デバッグ
 * @value Scene_Debug
 *
 * @param Id
 * @text 識別子
 * @desc ゲージの識別子です。特に使用されませんが、分かりやすい名称を設定すると管理がしやすくなります。
 * @default gauge01
 *
 * @param SwitchId
 * @text 表示スイッチID
 * @desc 指定したスイッチがONの場合のみ画面に表示されます。0を指定すると常に表示されます。
 * @default 0
 * @type switch
 *
 * @param OpacityVariable
 * @text 不透明度変数ID
 * @desc 不透明度を取得する変数番号です。0を指定すると常に不透明度255で表示されます。
 * @default 0
 * @type variable
 *
 * @param Layout
 * @text レイアウト
 * @desc ゲージの表示座標と幅、高さです。スクリプトを使用する場合、変数witch, heightでUIエリアの幅と高さを取得できます。
 * @type struct<Layout>
 * @default {"x":"width / 2","y":"30","width":"width * 0.8","height":"36","GaugeX":"0","GaugeHeight":"0","Vertical":"false"}
 *
 * @param CurrentMethod
 * @text 現在値取得方法
 * @desc ゲージの現在値を取得する方法です。変数、スクリプトのいずれかを設定します。
 * @default {"VariableId":"1","Script":"","FixedValue":""}
 * @type struct<Method>
 *
 * @param MaxMethod
 * @text 最大値取得方法
 * @desc ゲージの最大値を取得する方法です。変数、スクリプト、固定値のいずれかを設定します。
 * @default {"VariableId":"0","Script":"","FixedValue":"100"}
 * @type struct<Method>
 *
 * @param Detail
 * @text 詳細設定
 * @desc ゲージの配置や色などの細かい設定です。
 * @type struct<Detail>
 * @default
 *
 * @param LowerPicture
 * @text 下ピクチャ
 * @desc ゲージの下に表示されるピクチャです。ゲージの中心と画像の中心が合わせて表示されます。
 * @default
 * @type struct<Picture>
 *
 * @param UpperPicture
 * @text 上ピクチャ
 * @desc ゲージの上に表示されるピクチャです。ゲージの中心と画像の中心が合わせて表示されます。
 * @default
 * @type struct<Picture>
 *
 * @param Battler
 * @text バトラー情報
 * @desc ゲージの主体となるバトラー情報の参照方法を指定します。現在値、最大値をスクリプトで決める場合のみ使用します。
 * @default
 * @type struct<Battler>
 */

/*~struct~Layout:
 *
 * @param x
 * @text X座標
 * @desc X座標です。原点は中央です。数値以外を指定した場合はスクリプトとして評価します。
 * @default width / 2
 *
 * @param y
 * @text Y座標
 * @desc Y座標です。原点は中央です。数値以外を指定した場合はスクリプトとして評価します。
 * @default 30
 *
 * @param realTime
 * @text リアルタイム座標反映
 * @desc ゲージを表示後、X座標、Y座標が変更されたときにゲージの位置を再評価します。
 * @default false
 * @type boolean
 *
 * @param width
 * @text 横幅
 * @desc 横幅です。数値以外を指定した場合はスクリプトとして評価します。
 * @default width * 0.8
 *
 * @param height
 * @text 高さ
 * @desc 高さです。数値以外を指定した場合はスクリプトとして評価します。
 * @default 36
 *
 * @param GaugeX
 * @text ゲージX座標
 * @desc ゲージのX座標です。ラベルが長い文字の場合は変更してください。
 * @default 28
 *
 * @param GaugeHeight
 * @text ゲージ高さ
 * @desc ゲージの高さです。0を指定すると全体の高さに合わせられます。
 * @default 0
 *
 * @param Vertical
 * @text 縦ゲージ
 * @desc 有効にすると縦方向ゲージになります。ラベルなども縦方向になるので注意してください。
 * @default false
 * @type boolean
 */

/*~struct~Picture:
 *
 * @param FileName
 * @text ファイル名
 * @desc ピクチャのファイル名です。
 * @default
 * @type file
 * @dir img/pictures
 *
 * @param OffsetX
 * @text X座標補正値
 * @desc X座標の補正値です。
 * @default 0
 * @type number
 * @min -9999
 *
 * @param OffsetY
 * @text Y座標補正値
 * @desc Y座標の補正値です。
 * @default 0
 * @type number
 * @min -9999
 */

/*~struct~Method:
 *
 * @param VariableId
 * @text 取得変数ID
 * @desc ゲージの値を取得する変数番号です。スクリプトより優先して参照されます。
 * @default 0
 * @type variable
 *
 * @param Script
 * @text 取得スクリプト
 * @desc ゲージの値を取得するスクリプトです。固定値より優先して参照されます。
 * @default
 * @type combo
 * @option battler.hp; // HP
 * @option battler.mhp; // 最大HP
 * @option battler.mp; // MP
 * @option battler.mmp; // 最大MP
 * @option battler.tp; // TP
 * @option battler.maxTp(); // 最大MP
 * @option meta.value; // メモ欄[value]の値
 *
 * @param FixedValue
 * @text 固定値
 * @desc ゲージの値を固定値で設定します。現在値に固定値を指定することは推奨しません。
 * @default
 * @type number
 * @min 1
 */

/*~struct~Detail:
 *
 * @param RisingSmoothness
 * @text 上昇中のなめらかさ
 * @desc 大きい数を指定するとゲージがゆっくりと上昇します。
 * @default 1
 * @type number
 * @min 1
 *
 * @param FallingSmoothness
 * @text 下降中のなめらかさ
 * @desc 大きい数を指定するとゲージがゆっくりと下降します。
 * @default 1
 * @type number
 * @min 1
 *
 * @param GaugeColorPreset
 * @text ゲージ色のプリセット
 * @desc ゲージ色をプリセットから簡易指定します。既存のゲージ仕様を流用する関係上、timeに設定するとラベルが表示されません。
 * @default hp
 * @type select
 * @option
 * @option hp
 * @option mp
 * @option tp
 * @option time
 *
 * @param GaugeColorLeft
 * @text ゲージ色(左)
 * @desc 左側のゲージ色です。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 *
 * @param GaugeColorRight
 * @text ゲージ色(右)
 * @desc 右側のゲージ色です。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 *
 * @param GaugeColorFullLeft
 * @text 満タン時のゲージ色(左)
 * @desc 満タン時の左側のゲージ色です。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 *
 * @param GaugeColorFullRight
 * @text 満タン時のゲージ色(右)
 * @desc 満タン時の右側のゲージ色です。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 *
 * @param BackColor
 * @text ゲージ背景色
 * @desc ゲージ背景色です。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 *
 * @param Label
 * @text ラベル
 * @desc ゲージの左に表示されるラベル文字列です。
 * @default
 *
 * @param IconIndex
 * @text アイコン
 * @desc ラベルと一緒に描画されるアイコンです。ラベルと一緒に表示させると重なって表示されるので注意してください。
 * @default 0
 *
 * @param LabelFont
 * @text ラベルフォント
 * @desc ラベルを表示するときのフォント情報です。未指定の場合はゲージのデフォルト値が使用されます。
 * @default
 * @type struct
 *
 * @param DrawValue
 * @text 現在値を描画する
 * @desc ゲージの右側に現在値を描画します。
 * @default true
 * @type boolean
 *
 * @param ValueFont
 * @text 現在値フォント
 * @desc 現在値を表示するときのフォント情報です。未指定の場合はゲージのデフォルト値が使用されます。
 * @default
 * @type struct
 *
 * @param ValueFormat
 * @text 現在値フォーマット
 * @desc 現在値を表示する際の表示フォーマットです。%1:現在値 %2:最大値に置き換えられます。
 * @default %1/%2
 *
 * @param FlashIfFull
 * @text 満タン時にフラッシュ
 * @desc ゲージの現在値が最大値以上になるとゲージをフラッシュさせます。
 * @default false
 * @type boolean
 */

/*~struct~Font:
 *
 * @param Face
 * @text フォント名
 * @desc フォント名です。別途フォントロードプラグインが必要です。
 * @default
 * @dir fonts
 *
 * @param Size
 * @text フォントサイズ
 * @desc フォントサイズです。
 * @default 0
 * @type number
 *
 * @param Color
 * @text テキストカラー
 * @desc テキストカラーです。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 * @type number
 *
 * @param OutlineColor
 * @text アウトラインカラー
 * @desc アウトラインカラーです。テキストカラー番号かCSS色指定(rgba(0, 0, 0, 0))を指定します。
 * @default 0
 * @type number
 *
 * @param OutlineWidth
 * @text アウトライン横幅
 * @desc アウトラインの横幅です。
 * @default 0
 * @type number
 */

/*~struct~Battler:
 *
 * @param Type
 * @text バトラー種別
 * @desc ゲージの主体となるバトラーの取得方法です。
 * @default
 * @type select
 * @option アクターID
 * @value ActorId
 * @option パーティの並び順
 * @value PartyIndex
 * @option 敵キャラID
 * @value EnemyId
 * @option 敵グループの並び順(戦闘画面で有効)
 * @value TroopIndex
 * @option メニュー画面で選択したアクター(メニュー詳細画面で有効)
 * @value MenuActor
 *
 * @param ActorId
 * @text アクターID
 * @desc 種別選択で『アクターID』を選択したときのアクターIDです。
 * @default 0
 * @type actor
 *
 * @param EnemyId
 * @text 敵キャラID
 * @desc 種別選択で『敵キャラID』を選択したときの敵キャラIDです。
 * @default 0
 * @type enemy
 *
 * @param Index
 * @text 並び順
 * @desc 種別選択で『パーティの並び順』『敵グループの並び順』を選択したときの並び順です。先頭は[0]です。
 * @default 0
 * @type number
 */

(() => {
  "use strict";
  const script = document.currentScript;
  const param = PluginManagerEx.createParameter(script);
  if (!param.GaugeList) {
    param.GaugeList = [];
  }

  const _Scene_Base_create = Scene_Base.prototype.create;
  Scene_Base.prototype.create = function () {
    _Scene_Base_create.apply(this, arguments);
    if (!(this instanceof Scene_Map)) {
      this.createExtraGauges();
    }
  };

  const _Scene_Map_create = Scene_Map.prototype.create;
  Scene_Map.prototype.create = function () {
    _Scene_Map_create.apply(this, arguments);
    this.createExtraGauges();
  };

  Scene_Base.prototype.createExtraGauges = function () {
    this._extraGauges = this.findExtraGaugeList().map((data) => {
      return new Sprite_ExtraGaugeContainer(
        data,
        data.Detail || {},
        data.Layout || {}
      );
    });
  };

  const _Scene_Base_createWindowLayer = Scene_Base.prototype.createWindowLayer;
  Scene_Base.prototype.createWindowLayer = function () {
    if (this instanceof Scene_Message) {
      this.addExtraGauge();
    }
    _Scene_Base_createWindowLayer.apply(this, arguments);
  };

  const _Scene_Base_start = Scene_Base.prototype.start;
  Scene_Base.prototype.start = function () {
    _Scene_Base_start.apply(this, arguments);
    this.addExtraGauge();
  };

  Scene_Base.prototype.addExtraGauge = function () {
    if (this._extraGaugesAdd) {
      return;
    }
    this._extraGauges.forEach((extraGauge) => {
      this.addChildExtraGauge(extraGauge);
    });
    this._extraGaugesAdd = true;
  };

  Scene_Base.prototype.addChildExtraGauge = function (extraGauge) {
    this.addChild(extraGauge);
  };

  if (param.Priority === 1) {
    Scene_Battle.prototype.addChildExtraGauge = function (extraGauge) {
      this._spriteset.addChildExtraGauge(extraGauge);
    };

    Scene_Map.prototype.addChildExtraGauge = function (extraGauge) {
      this._spriteset.addChildExtraGauge(extraGauge);
    };

    Spriteset_Base.prototype.addChildExtraGauge = function (extraGauge) {
      const index = this.getChildIndex(this._pictureContainer);
      this.addChildAt(extraGauge, index);
    };
  }

  Scene_Base.prototype.findExtraGaugeList = function () {
    const currentSceneName = PluginManagerEx.findClassName(this);
    return (param.GaugeList || []).filter(function (data) {
      return data.SceneName === currentSceneName;
    }, this);
  };

  const _Sprite_Gauge_initialize = Sprite_Gauge.prototype.initialize;
  Sprite_Gauge.prototype.initialize = function (data, detail, layout) {
    if (data) {
      this._data = data;
      this._detail = detail;
      this._layout = layout;
    }
    _Sprite_Gauge_initialize.apply(this, arguments);
  };

  /**
   * Sprite_ExtraGaugeContainer
   * 追加ゲージとピクチャを含むコンテナです。
   */
  class Sprite_ExtraGaugeContainer extends Sprite {
    constructor(data, detail, layout) {
      super();
      this._data = data;
      this._detail = detail;
      this._layout = layout;
      this.create();
    }

    create() {
      this._gauge = new Sprite_ExtraGauge(
        this._data,
        this._detail,
        this._layout
      );
      this._lower = this.createPicture(this._data.LowerPicture);
      this.addChild(this._gauge);
      this._upper = this.createPicture(this._data.UpperPicture);
      this.setupPosition();
      this.update();
    }

    setupPosition() {
      this.x = this._gauge.findLayoutValue(this._layout.x);
      this.y = this._gauge.findLayoutValue(this._layout.y);
    }

    update() {
      super.update();
      if (this._layout.realTime) {
        this.setupPosition();
      }
      this.updateVisibly();
      this.updateOpacity();
    }

    updateVisibly() {
      this.visible = this.isVisible();
    }

    updateOpacity() {
      if (this._detail.OpacityVariable) {
        this.opacity = $gameVariables.value(this._detail.OpacityVariable);
      }
    }

    isVisible() {
      return !this._data.SwitchId || $gameSwitches.value(this._data.SwitchId);
    }

    createPicture(pictureData) {
      if (!pictureData || !pictureData.FileName) {
        return null;
      }
      const sprite = new Sprite();
      sprite.anchor.x = 0.5;
      sprite.anchor.y = 0.5;
      sprite.bitmap = ImageManager.loadPicture(pictureData.FileName);
      sprite.x = pictureData.OffsetX || 0;
      sprite.y = pictureData.OffsetY || 0;
      this.addChild(sprite);
      return sprite;
    }
  }

  /**
   * Sprite_ExtraGauge
   * 追加ゲージを扱うクラスです。
   */
  class Sprite_ExtraGauge extends Sprite_Gauge {
    constructor(data, detail, layout) {
      super(data, detail, layout);
      this.setup(this.findBattler(), this._detail.GaugeColorPreset);
      this.setupPosition();
    }

    findBattler() {
      const battlerData = this._data.Battler;
      if (!battlerData) {
        return $gameParty.menuActor();
      }
      const methodName = `findBattler${battlerData.Type}`;
      if (this[methodName]) {
        return this[methodName](battlerData);
      } else {
        return $gameParty.menuActor();
      }
    }

    findBattlerActorId(battlerData) {
      return $gameActors.actor(battlerData.ActorId);
    }

    findBattlerPartyIndex(battlerData) {
      return $gameParty.members()[battlerData.Index];
    }

    findBattlerEnemyId(battlerData) {
      return new Game_Enemy(battlerData.EnemyId, 0, 0);
    }

    findBattlerTroopIndex(battlerData) {
      return $gameTroop.members()[battlerData.Index];
    }

    updateBitmap() {
      const visible = this.parent ? this.parent.visible : false;
      if (visible) {
        if (!this._prevVisible) {
          this._value = this._targetValue;
          this._maxValue = this._targetMaxValue;
        }
        super.updateBitmap();
      }
      this._prevVisible = visible;
    }

    updateFlashing() {
      if (!this._detail.FlashIfFull) {
        return;
      }
      if (this.isFull()) {
        this._flashingCount++;
        if (this._flashingCount % 20 < 10) {
          this.setBlendColor(this.flashingColor1());
        } else {
          this.setBlendColor(this.flashingColor2());
        }
      } else {
        this.setBlendColor([0, 0, 0, 0]);
      }
    }

    flashingColor1() {
      return [255, 255, 255, 96];
    }

    flashingColor2() {
      return [255, 255, 255, 64];
    }

    isFull() {
      return this._value >= this._maxValue;
    }

    setupPosition() {
      this.anchor.x = 0.5;
      this.anchor.y = 0.5;
      if (this._layout.Vertical) {
        this.rotation = (270 * Math.PI) / 180;
      }
    }

    bitmapWidth() {
      return this.findLayoutValue(this._layout.width) || super.bitmapWidth();
    }

    bitmapHeight() {
      return this.findLayoutValue(this._layout.height) || super.bitmapHeight();
    }

    textHeight() {
      return this.bitmapHeight();
    }

    gaugeHeight() {
      return (
        this.findLayoutValue(this._layout.GaugeHeight) || this.bitmapHeight()
      );
    }

    gaugeX() {
      return this.findLayoutValue(this._layout.GaugeX) || 0;
    }

    findLayoutValue(value) {
      if (isNaN(value)) {
        try {
          const width = $dataSystem.advanced.uiAreaWidth;
          const height = $dataSystem.advanced.uiAreaHeight;
          return eval(value);
        } catch (e) {
          console.error(e);
          return 0;
        }
      } else {
        return value;
      }
    }

    currentValue() {
      return this.findValue(this._data.CurrentMethod);
    }

    currentMaxValue() {
      return Math.max(this.findValue(this._data.MaxMethod), 1);
    }

    findValue(method) {
      if (!method) {
        return 0;
      } else if (method.VariableId) {
        return $gameVariables.value(method.VariableId);
      } else if (method.Script) {
        const battler = this._battler;
        const meta = battler.isActor()
          ? battler.actor().meta
          : battler.enemy().meta;
        try {
          return eval(method.Script);
        } catch (e) {
          console.error(e);
          return 0;
        }
      } else {
        return method.FixedValue;
      }
    }

    label() {
      return this._detail.Label || "";
    }

    iconIndex() {
      return this._detail.IconIndex || 0;
    }

    labelColor() {
      return this.findColor(this.findLabelFont().Color, super.labelColor());
    }

    labelOutlineColor() {
      return this.findColor(
        this.findLabelFont().OutlineColor,
        super.labelOutlineColor()
      );
    }

    labelOutlineWidth() {
      return this.findLabelFont().OutlineWidth || super.labelOutlineWidth();
    }

    labelFontFace() {
      return this.findLabelFont().Face || super.labelFontFace();
    }

    labelFontSize() {
      return this.findLabelFont().Size || super.labelFontSize();
    }

    findLabelFont() {
      return this._detail.LabelFont || {};
    }

    valueColor() {
      return this.findColor(this.findValueFont().Color, super.valueColor());
    }

    valueOutlineColor() {
      return this.findColor(
        this.findValueFont().OutlineColor,
        super.valueOutlineColor()
      );
    }

    valueOutlineWidth() {
      return this.findValueFont().OutlineWidth || super.valueOutlineWidth();
    }

    valueFontFace() {
      return this.findValueFont().Face || super.valueFontFace();
    }

    valueFontSize() {
      return this.findValueFont().Size || super.valueFontSize();
    }

    findValueFont() {
      return this._detail.ValueFont || {};
    }

    gaugeBackColor() {
      return this.findColor(this._detail.BackColor, super.gaugeBackColor());
    }

    gaugeColor1() {
      const fullColor = this._detail.GaugeColorFullLeft;
      const color = this._detail.GaugeColorLeft;
      return this.findColor(
        this.isFull() ? fullColor || color : color,
        super.gaugeColor1()
      );
    }

    gaugeColor2() {
      const fullColor = this._detail.GaugeColorFullRight;
      const color = this._detail.GaugeColorRight;
      return this.findColor(
        this.isFull() ? fullColor || color : color,
        super.gaugeColor2()
      );
    }

    isValid() {
      return true;
    }

    smoothness() {
      if (this._value <= this._targetValue) {
        return this._detail.RisingSmoothness || 1;
      } else {
        return this._detail.FallingSmoothness || 1;
      }
    }

    drawValue() {
      if (this._detail.DrawValue) {
        if (this._detail.ValueFormat) {
          this.drawCustomValue();
        } else {
          super.drawValue();
        }
      }
    }

    drawCustomValue() {
      const text = this._detail.ValueFormat.format(
        this.currentValue(),
        this.currentMaxValue()
      );
      const width = this.bitmapWidth() - 2;
      const height = this.textHeight();
      this.setupValueFont();
      this.bitmap.drawText(text, 0, 0, width, height, "right");
    }

    findColor(code, defaultColor = null) {
      if (!code) {
        return defaultColor ? defaultColor : ColorManager.normalColor();
      } else if (isNaN(code)) {
        return code;
      } else {
        return ColorManager.textColor(code);
      }
    }

    drawLabel() {
      super.drawLabel();
      const icon = this.iconIndex();
      if (icon) {
        this.drawIcon(icon);
      }
    }

    drawIcon(iconIndex) {
      const bitmap = ImageManager.loadSystem("IconSet");
      const pw = ImageManager.iconWidth;
      const ph = ImageManager.iconHeight;
      const sx = (iconIndex % 16) * pw;
      const sy = Math.floor(iconIndex / 16) * ph;
      const x = this.labelOutlineWidth() / 2;
      const y = (this.bitmap.height - ph) / 2;
      this.bitmap.blt(bitmap, sx, sy, pw, ph, x, y);
    }
  }
})();


code:
/*=============================================================================
 GameoverImageChange.js
----------------------------------------------------------------------------
 (C)2020 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.1.0 2020/08/21 MEの代わりにBGMを演奏できる機能を追加
                  MEのピッチと位相が正常に設定されない問題を修正
 1.0.1 2020/08/18 英語ヘルプ作成
 1.0.0 2020/08/18 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc GameoverImageChangePlugin
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/GameoverImageChange.js
 * @author triacontane
 *
 * @param gameoverList
 * @text List of images and MEs
 * @desc This is the list that sets the game over image and ME change conditions.
 * @default []
 * @type struct<Record>[]
 *
 * @help GameoverImageChange.js
 *
 * Change the game over image and ME to suit the situation.
 * Set the image, ME, and conditional switch.
 * You can set multiple images, and when multiple conditions are met,
 * the setting above the list takes precedence.
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc ゲームオーバー画像変更プラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/GameoverImageChange.js
 * @author トリアコンタン
 *
 * @param gameoverList
 * @text 画像とMEのリスト
 * @desc ゲームオーバー画像およびMEの変更条件を設定するリストです。
 * @default []
 * @type struct<Record>[]
 *
 * @help GameoverImageChange.js
 *
 * ゲームオーバー時の画像およびMEを状況に応じて変更します。
 * 画像、ME、そして条件となるスイッチを設定してください。
 * 画像は複数設定でき、複数の条件を満たしたときはリストの上の設定が優先されます。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~Record:
 * @param ImageFile
 * @desc This is the game over image that will be displayed when the specified switch is ON.
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param AudioFile
 * @desc This is the file name of the ME file to be played when the switch specified by the condition is ON.
 * @default
 * @require 1
 * @dir audio/me/
 * @type file
 *
 * @param SwitchId
 * @desc The switch is used to display the specified image or ME.
 * @default 1
 * @type switch
 */

/*~struct~Record:ja
 * @param ImageFile
 * @text 画像ファイル
 * @desc 条件で指定したスイッチがONのときに表示されるゲームオーバー画像です。指定しなかった場合はデフォルト画像が表示されます。
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param AudioFile
 * @text MEファイル
 * @desc 条件で指定したスイッチがONのときに演奏されるMEのファイル名です。指定しなかった場合はデフォルトMEが演奏されます。
 * @default
 * @require 1
 * @dir audio/me/
 * @type file
 *
 * @param AudioBgmFile
 * @text BGMファイル
 * @desc MEの代わりにBGMを演奏します。指定するとMEは演奏されなくなります。
 * @default
 * @require 1
 * @dir audio/bgm/
 * @type file
 *
 * @param SwitchId
 * @text スイッチ番号
 * @desc 指定した画像、MEを表示するための条件となるスイッチです。
 * @default 1
 * @type switch
 */

(function () {
  "use strict";

  /**
   * Create plugin parameter. param[paramName] ex. param.commandPrefix
   * @param pluginName plugin name(EncounterSwitchConditions)
   * @returns {Object} Created parameter
   */
  var createPluginParameter = function (pluginName) {
    var paramReplacer = function (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;
      }
    };
    var parameter = JSON.parse(
      JSON.stringify(PluginManager.parameters(pluginName), paramReplacer)
    );
    PluginManager.setParameters(pluginName, parameter);
    return parameter;
  };

  var param = createPluginParameter("GameoverImageChange");
  if (!param.gameoverList) {
    param.gameoverList = [];
  }

  var _Scene_Gameover_playGameoverMusic =
    Scene_Gameover.prototype.playGameoverMusic;
  Scene_Gameover.prototype.playGameoverMusic = function () {
    _Scene_Gameover_playGameoverMusic.apply(this, arguments);
    var data = this.findGameoverData();
    if (data && (data.AudioFile || data.AudioBgmFile)) {
      this.playGameoverCustomMusic(data.AudioFile, data.AudioBgmFile);
    }
  };

  Scene_Gameover.prototype.playGameoverCustomMusic = function (name, bgmName) {
    AudioManager.stopMe();
    var defaultMe = $dataSystem.gameoverMe;
    var audio = {
      name: bgmName || name,
      volume: defaultMe.volume,
      pitch: defaultMe.pitch,
      pan: defaultMe.pan,
    };
    if (bgmName) {
      AudioManager.playBgm(audio);
    } else {
      AudioManager.playMe(audio);
    }
  };

  var _Scene_Gameover_createBackground =
    Scene_Gameover.prototype.createBackground;
  Scene_Gameover.prototype.createBackground = function () {
    _Scene_Gameover_createBackground.apply(this, arguments);
    var data = this.findGameoverData();
    if (data && data.ImageFile) {
      this.changeCustomBackground(data.ImageFile);
    }
  };

  Scene_Gameover.prototype.changeCustomBackground = function (name) {
    this._backSprite.bitmap = ImageManager.loadSystem(name);
  };

  Scene_Gameover.prototype.findGameoverData = function () {
    return param.gameoverList.filter(function (item) {
      return $gameSwitches.value(item.SwitchId);
    })[0];
  };
})();