code:
//=============================================================================
// PictureCallCommon.js
// ----------------------------------------------------------------------------
// (C)2015 Triacontane
// This plugin is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.4.0 2022/10/22 DTextPicture.jsと組み合わせたとき、フレームウィンドウをクリックイベントの範囲に含めるよう変更
// 1.3.1 2022/05/19 ヘルプ微修正
// 1.3.0 2022/04/14 ピクチャクリック時に変数を操作する機能および任意スクリプトを実行する機能を追加
// 1.2.2 2021/11/07 異なるピクチャのトリガーを同一フレームで同時に満たした場合、すべてのタッチ処理が実行されるよう修正
// 1.2.1 2021/10/08 トリガー種別がマウスが重なった場合のとき無効スイッチ中に条件を満たしていると、無効スイッチがOFFになった瞬間にイベントが発生してしまう問題を修正
// 1.2.0 2021/05/20 APNGピクチャプラグインと組み合わせたときにAPNGピクチャをボタン化できるよう修正（ただし透過色は考慮されない）
// 1.1.2 2021/04/08 トリガー「マウスをピクチャ内で移動した場合」がマウスを押していないと反応しない問題を修正
// 1.1.1 2020/12/21 スクリプト$gameScreen.showPictureを使って未キャッシュのピクチャを表示しようとすると画像が表示されなくなる問題を修正
//                  セーブデータロード時にエラーになる問題を修正
// 1.1.0 2020/12/20 イベントごとに無効スイッチを指定できる機能を追加
// 1.0.0 2020/12/17 MZ版として新規作成
// ----------------------------------------------------------------------------
// [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/PictureCallCommon.js
 * @base PluginCommonBase
 * @author トリアコンタン
 *
 * @param PictureIdVariable
 * @text ピクチャ番号の変数
 * @desc 最後にイベントが発生したピクチャ番号を格納する変数IDです。
 * @default 0
 * @type variable
 *
 * @param InvalidSwitchId
 * @text 無効スイッチ
 * @desc 指定した番号のスイッチがONになっている場合、すべてのピクチャイベントが無効になります。
 * @default 0
 * @type switch
 *
 * @param FlickDistance
 * @text フリック有効距離
 * @desc フリック判定が有効になる距離(ピクセル数)です。
 * @default 60
 * @type number
 *
 * @param FlickTimeVariable
 * @text フリック時間の変数
 * @desc フリック判定が有効になるまでに掛かったフレーム数を格納する変数IDです。この値が小さいほど速いフリックです。
 * @default 0
 * @type variable
 *
 * @param FlickDegreeVariable
 * @text フリック角度の変数
 * @desc フリック判定が有効になったときのフリック方向を度数法で格納する変数IDです。
 * @default 0
 * @type variable
 *
 * @command ADD_PICTURE_EVENT
 * @text ピクチャイベント登録
 * @desc ピクチャ操作で発生するイベントを登録します。
 *
 * @arg pictureId
 * @text ピクチャ番号
 * @desc 操作対象のピクチャ番号です。
 * @default 1
 * @type number
 *
 * @arg commonEventId
 * @text コモンイベント番号
 * @desc イベント発生時に呼び出すコモンイベントです。
 * @default 0
 * @type common_event
 *
 * @arg switchId
 * @text スイッチ番号
 * @desc イベント発生時にONになるスイッチです。
 * @default 0
 * @type switch
 *
 * @arg variableId
 * @text 変数番号
 * @desc イベント発生時に値が加減される変数です。
 * @default 0
 * @type variable
 *
 * @arg operationType
 * @parent variableId
 * @text 操作種別
 * @desc イベント発生時に指定した変数の操作種別です。
 * @default 0
 * @type select
 * @option 代入
 * @value 0
 * @option 加算
 * @value 1
 * @option 減算
 * @value 2
 * @option 乗算
 * @value 3
 * @option 除算
 * @value 4
 * @option 剰余
 * @value 5
 *
 * @arg operand
 * @parent variableId
 * @text オペランド
 * @desc イベント発生時に指定した変数の操作値です。
 * @default 0
 * @type number
 * @min -99999999
 *
 * @arg script
 * @text スクリプト
 * @desc イベント発生時に実行されるスクリプトです。
 * @type multiline_string
 *
 * @arg buttonBind
 * @text ボタンバインド
 * @desc イベント発生時に押したことになるボタンです。
 * @default
 * @type combo
 * @option ok
 * @option shift
 * @option control
 * @option escape
 * @option left
 * @option up
 * @option right
 * @option down
 * @option pageup
 * @option pagedown
 *
 * @arg triggerType
 * @text トリガー種別
 * @desc トリガーとなるマウス、タッチ操作の種別です。
 * @default 1
 * @type select
 * @option 1:クリックした場合
 * @value 1
 * @option 2:右クリックした場合
 * @value 2
 * @option 3:長押しした場合
 * @value 3
 * @option 4:マウスをピクチャに重ねた場合
 * @value 4
 * @option 5:マウスをピクチャから放した場合
 * @value 5
 * @option 6:クリックを解放（リリース）した場合
 * @value 6
 * @option 7:クリックした場合（かつ長押しの際の繰り返しを考慮）
 * @value 7
 * @option 8:クリックしている間ずっと
 * @value 8
 * @option 9:ホイールクリックした場合（PCの場合のみ有効）
 * @value 9
 * @option 10:ダブルクリックした場合
 * @value 10
 * @option 11:マウスをピクチャ内で移動した場合
 * @value 11
 * @option 12:マウスを押しつつピクチャ内で移動した場合
 * @value 12
 * @option 13:フリック(マウス押下状態で指定距離以上動かす)した場合
 * @value 13
 *
 * @arg invalidSwitchId
 * @text 無効スイッチ
 * @desc 指定した番号のスイッチがONになっている場合、ピクチャイベントが無効になります。
 * @default 0
 * @type switch
 *
 * @command REMOVE_PICTURE_EVENT
 * @text ピクチャイベント解除
 * @desc 登録したピクチャイベントを解除します。
 *
 * @arg pictureId
 * @text ピクチャ番号
 * @desc 操作対象のピクチャ番号です。
 * @default 1
 * @type number
 *
 * @help PictureCallCommon.js
 *
 * ピクチャに対する様々なマウス操作に反応してコモンイベント実行や
 * スイッチ制御ができます。（これをピクチャイベントと呼びます）
 * 一度登録したピクチャイベントはピクチャを消去しても有効です。
 * 解除は専用のプラグインコマンドから可能です。
 *
 * 各マウス操作について、ピクチャの透明部分には反応しません。
 *
 * ピクチャイベントはマップ画面でも戦闘画面でも
 * 他のイベントや状況の制限を受けずに速やかに並列実行されます。
 * また、ピクチャイベントが発生した瞬間のフレームでは他のクリック処理は
 * 無効となりタッチによるマップ移動やメッセージ送り等は行われません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
  "use strict";
  const script = document.currentScript;
  const param = PluginManagerEx.createParameter(script);

  PluginManagerEx.registerCommand(script, "ADD_PICTURE_EVENT", (args) => {
    $gameScreen.addPictureEvent(args.pictureId, args.triggerType, args);
  });

  PluginManagerEx.registerCommand(script, "REMOVE_PICTURE_EVENT", (args) => {
    $gameScreen.removePictureEvent(args.pictureId);
  });

  //=============================================================================
  // Game_System
  //  ロード時にピクチャ関連メンバを初期化します。
  //=============================================================================
  const _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
  Game_System.prototype.onAfterLoad = function () {
    _Game_System_onAfterLoad.apply(this, arguments);
    $gameScreen.initPictureEventMap();
  };

  //=============================================================================
  // Game_Screen
  //  ピクチャに対応するコモンイベント呼び出し用のID配列を追加定義します。
  //=============================================================================
  const _Game_Screen_initialize = Game_Screen.prototype.initialize;
  Game_Screen.prototype.initialize = function () {
    _Game_Screen_initialize.apply(this, arguments);
    this.initPictureEventMap();
  };

  Game_Screen.prototype.initPictureEventMap = function () {
    if (!this._pictureEventMap) {
      this._pictureEventMap = new Game_PictureEventMap();
    }
  };

  Game_Screen.prototype.addPictureEvent = function (pictureId, trigger, param) {
    const realPictureId = this.realPictureId(pictureId);
    this._pictureEventMap.append(realPictureId, trigger, param);
  };

  Game_Screen.prototype.removePictureEvent = function (
    pictureId,
    trigger = null
  ) {
    const realPictureId = this.realPictureId(pictureId);
    if (trigger === null) {
      this._pictureEventMap.removeById(realPictureId);
    } else {
      this._pictureEventMap.remove(realPictureId, trigger);
    }
  };

  Game_Screen.prototype.findPictureEvent = function (pictureId, trigger) {
    const realPictureId = this.realPictureId(pictureId);
    return this._pictureEventMap.find(realPictureId, trigger);
  };

  Game_Screen.prototype.disConvertPositionX = function (x) {
    const unshiftX = x - this.zoomX() * (1 - this.zoomScale());
    return Math.round(unshiftX / this.zoomScale());
  };

  Game_Screen.prototype.disConvertPositionY = function (y) {
    const unshiftY = y - this.zoomY() * (1 - this.zoomScale());
    return Math.round(unshiftY / this.zoomScale());
  };

  Game_Troop.prototype.setupDynamicCommon =
    Game_Map.prototype.setupDynamicCommon;
  Game_Troop.prototype.setupDynamicInterpreter =
    Game_Map.prototype.setupDynamicInterpreter;

  const _Game_Troop_setup = Game_Troop.prototype.setup;
  Game_Troop.prototype.setup = function (troopId) {
    _Game_Troop_setup.apply(this, arguments);
    if (!this._dynamicEvents) {
      this._dynamicEvents = [];
    }
  };

  Game_Troop.prototype.updateDynamicEvents = function () {
    this._dynamicEvents.forEach((interpreter) => interpreter.update());
  };

  if (!Scene_Battle.prototype.hasOwnProperty("updateDynamicEvents")) {
    const _Scene_Battle_updateBattleProcess =
      Scene_Battle.prototype.updateBattleProcess;
    Scene_Battle.prototype.updateBattleProcess = function () {
      _Scene_Battle_updateBattleProcess.apply(this, arguments);
      this.updateDynamicEvents();
    };

    Scene_Battle.prototype.updateDynamicEvents = function () {
      $gameTroop.updateDynamicEvents();
    };
  }

  /**
   * Game_PictureEventMap
   * ピクチャイベントの登録状態を管理するマップです。
   */
  class Game_PictureEventMap {
    constructor() {
      this._map = {};
    }

    append(pictureId, trigger, option) {
      this._map[this.generateKey(pictureId, trigger)] = option;
    }

    find(pictureId, trigger) {
      return this._map[this.generateKey(pictureId, trigger)];
    }

    remove(pictureId, trigger) {
      delete this._map[this.generateKey(pictureId, trigger)];
    }

    removeById(pictureId) {
      const regExp = new RegExp(`^${pictureId}`);
      Object.keys(this._map).forEach((key) => {
        if (key.match(regExp)) {
          delete this._map[key];
        }
      });
    }

    generateKey(pictureId, trigger) {
      return `${pictureId}:${trigger}`;
    }
  }
  window.Game_PictureEventMap = Game_PictureEventMap;

  //=============================================================================
  // Sprite_Picture
  //  ピクチャのタッチ状態からのコモンイベント呼び出し予約を追加定義します。
  //=============================================================================
  const _Sprite_Picture_initialize = Sprite_Picture.prototype.initialize;
  Sprite_Picture.prototype.initialize = function (pictureId) {
    _Sprite_Picture_initialize.call(this, pictureId);
    this._touch = new PictureTouch(this, pictureId);
  };

  const _Sprite_update = Sprite_Picture.prototype.update;
  Sprite_Picture.prototype.update = function () {
    _Sprite_update.apply(this, arguments);
    if (
      this.picture() &&
      this._touch &&
      !$gameSwitches.value(param.InvalidSwitchId)
    ) {
      this._touch.update();
    }
  };

  const _Spriteset_Base_update = Spriteset_Base.prototype.update;
  Spriteset_Base.prototype.update = function () {
    _Spriteset_Base_update.apply(this, arguments);
    TouchInput.suppressIfNeed();
  };

  /**
   * PictureTouch
   * ピクチャのタッチ状態を管理します。
   */
  class PictureTouch {
    constructor(picture, id) {
      this._picture = picture;
      this._pictureId = id;
      this._handlers = [];
      this._handlers[1] = () => this.isTouchEvent(TouchInput.isTriggered);
      this._handlers[2] = () => this.isTouchEvent(TouchInput.isCancelled);
      this._handlers[3] = () => this.isTouchEvent(TouchInput.isLongPressed);
      this._handlers[4] = () => this._onMouse;
      this._handlers[5] = () => this._outMouse;
      this._handlers[6] = () => this.isTouchEvent(TouchInput.isReleased);
      this._handlers[7] = () => this.isTouchEvent(TouchInput.isRepeated);
      this._handlers[8] = () => this.isTouchEvent(TouchInput.isPressed);
      this._handlers[9] = () => this.isTouchEvent(TouchInput.isWheelTriggered);
      this._handlers[10] = () =>
        this.isTouchEvent(TouchInput.isDoubleTriggered);
      this._handlers[11] = () => this.isTouchEvent(TouchInput.isHovered);
      this._handlers[12] = () => this.isTouchEvent(TouchInput.isMoved);
      this._handlers[13] = () => this._flick;
      this._onMouse = false;
      this._outMouse = false;
      this._wasOnMouse = false;
      this._flick = false;
      this._interpreter = new Game_Interpreter();
    }

    update() {
      this.updateFlick();
      this.updatePictureTouch();
      this.updateMouseMove();
    }

    updatePictureTouch() {
      if (SceneManager.isNextScene(Scene_Battle)) {
        return;
      }
      this._handlers.forEach((handler, trigger) => {
        if (this.isValidTrigger(handler, trigger)) {
          const eventData = $gameScreen.findPictureEvent(
            this._pictureId,
            trigger
          );
          this.fireTouchEvent(eventData, trigger);
        }
      });
    }

    updateMouseMove() {
      if (this.isOnPicturePos()) {
        if (!this._wasOnMouse) {
          this._outMouse = false;
          this._onMouse = true;
          this._wasOnMouse = true;
        }
      } else if (this._wasOnMouse) {
        this._outMouse = true;
        this._wasOnMouse = false;
        this._onMouse = false;
      }
    }

    updateFlick() {
      this._flick = false;
      const data = TouchInput.createFlickData();
      if (!data) {
        return;
      }
      if (
        data.distance >= param.FlickDistance &&
        this.isOnPicturePos(data.start.x, data.start.y)
      ) {
        this._flick = true;
        if (param.FlickTimeVariable) {
          $gameVariables.setValue(param.FlickTimeVariable, data.time);
        }
        if (param.FlickDegreeVariable) {
          $gameVariables.setValue(param.FlickDegreeVariable, data.degree);
        }
      }
    }

    isValidTrigger(handler, trigger) {
      const eventData = $gameScreen.findPictureEvent(this._pictureId, trigger);
      return (
        eventData &&
        !$gameSwitches.value(eventData.invalidSwitchId) &&
        handler &&
        handler.call(this)
      );
    }

    fireTouchEvent(eventData, trigger) {
      TouchInput.requestSuppress();
      if (trigger === 3) {
        TouchInput._pressedTime = -60;
      }
      if (trigger === 4) {
        this._onMouse = false;
      }
      if (trigger === 5) {
        this._outMouse = false;
      }
      this.applyTouchEvent(eventData);
    }

    applyTouchEvent(eventData) {
      if (eventData.switchId) {
        $gameSwitches.setValue(eventData.switchId, true);
      }
      if (eventData.variableId) {
        this._interpreter.operateVariable(
          eventData.variableId,
          eventData.operationType,
          eventData.operand
        );
      }
      if (eventData.script) {
        try {
          eval(eventData.script);
        } catch (e) {
          console.error("Error Script:" + eventData.script);
          PluginManagerEx.throwError(e.message, script);
        }
      }
      if (eventData.buttonBind) {
        Input.bindKeyState(eventData.buttonBind);
      }
      if (eventData.commonEventId) {
        if ($gameParty.inBattle()) {
          $gameTroop.setupDynamicCommon(eventData.commonEventId);
        } else {
          $gameMap.setupDynamicCommon(eventData.commonEventId);
        }
      }
      if (param.PictureIdVariable > 0) {
        $gameVariables.setValue(param.PictureIdVariable, this._pictureId);
      }
    }

    isOnPicturePos(x = TouchInput.x, y = TouchInput.y) {
      const pic = this._picture;
      if (
        !pic.bitmap ||
        !pic.bitmap.isReady() ||
        pic.scale.x === 0 ||
        pic.scale.y === 0
      ) {
        return false;
      }
      if (this.isTouchPosInFrameWindow(x, y)) {
        return true;
      }
      const dx = this.getTouchScreenX(x) - pic.x;
      const dy = this.getTouchScreenY(y) - pic.y;
      const sin = Math.sin(-pic.rotation);
      const cos = Math.cos(-pic.rotation);
      const bx =
        Math.floor(dx * cos + dy * -sin) / pic.scale.x +
        pic.anchor.x * pic.width;
      const by =
        Math.floor(dx * sin + dy * cos) / pic.scale.y +
        pic.anchor.y * pic.height;
      if (pic._apngSprite) {
        return (
          bx >= 0 &&
          by >= 0 &&
          bx <= pic.bitmap.width &&
          by <= pic.bitmap.height
        );
      }
      return pic.bitmap.getAlphaPixel(bx, by) !== 0;
    }

    // for DTextPicture.js
    isTouchPosInFrameWindow(x, y) {
      if (!this._picture._frameWindow) {
        return false;
      }
      const frame = this._picture._frameWindow;
      const sx = this.getTouchScreenX(x);
      const sy = this.getTouchScreenY(y);
      return (
        frame.x <= sx &&
        frame.x + frame.width >= sx &&
        frame.y <= sy &&
        frame.y + frame.height >= sy
      );
    }

    isTouchEvent(triggerFunc) {
      return triggerFunc.call(TouchInput) && this.isOnPicturePos();
    }

    getTouchScreenX(x) {
      return $gameScreen.disConvertPositionX(x);
    }

    getTouchScreenY(y) {
      return $gameScreen.disConvertPositionY(y);
    }
  }

  //=============================================================================
  // Input
  //  ピクチャクリックをキー入力に紐付けます。
  //=============================================================================
  Input._bindKeyStateFrames = new Map();
  Input.bindKeyState = function (name) {
    this._currentState[name] = true;
    this._bindKeyStateFrames.set(name, 5);
  };

  const _Input_update = Input.update;
  Input.update = function () {
    _Input_update.apply(this, arguments);
    this._updateBindKeyState();
  };

  Input._updateBindKeyState = function () {
    this._bindKeyStateFrames.forEach(function (frame, keyName) {
      frame--;
      if (frame === 0 || !this._currentState[keyName]) {
        this._currentState[keyName] = false;
        this._bindKeyStateFrames.delete(keyName);
      } else {
        this._bindKeyStateFrames.set(keyName, frame);
      }
    }, this);
  };

  //=============================================================================
  // TouchInput
  //  ホイールクリック、ダブルクリック等を実装
  //=============================================================================
  const _TouchInput__createNewState = TouchInput._createNewState;
  TouchInput._createNewState = function () {
    const state = _TouchInput__createNewState.apply(this, arguments);
    state.wheelTriggered = false;
    state.doubleTriggered = false;
    return state;
  };

  TouchInput.requestSuppress = function () {
    this._requestSuppress = true;
  };

  TouchInput.suppressIfNeed = function () {
    if (this._requestSuppress) {
      this._currentState = this._createNewState();
      this._requestSuppress = false;
    }
  };

  TouchInput.isWheelTriggered = function () {
    return this._currentState.wheelTriggered;
  };

  TouchInput.isDoubleTriggered = function () {
    return this._currentState.doubleTriggered;
  };

  TouchInput.createFlickData = function () {
    if (!this.isPressed()) {
      return null;
    }
    const data = {};
    const dx = this._x - this._triggerX;
    const dy = this._y - this._triggerY;
    data.distance = Math.round(Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2)));
    data.time = this._pressedTime;
    data.degree = Math.round(((Math.atan2(dy, -dx) + Math.PI) * 180) / Math.PI);
    data.start = new Point(this._triggerX, this._triggerY);
    data.end = new Point(this._x, this._y);
    return data;
  };

  const _TouchInput_onMiddleButtonDown = TouchInput._onMiddleButtonDown;
  TouchInput._onMiddleButtonDown = function (event) {
    _TouchInput_onMiddleButtonDown.apply(this, arguments);
    const x = Graphics.pageToCanvasX(event.pageX);
    const y = Graphics.pageToCanvasY(event.pageY);
    if (Graphics.isInsideCanvas(x, y)) {
      this._newState.wheelTriggered = true;
    }
  };

  const _TouchInput_onTrigger = TouchInput._onTrigger;
  TouchInput._onTrigger = function (x, y) {
    const prevDate = this._date;
    _TouchInput_onTrigger.apply(this, arguments);
    if (this._date - prevDate < 300) {
      this._newState.doubleTriggered = true;
    }
  };
})();


code:
//=============================================================================
// PicturePriorityCustomize.js
// ----------------------------------------------------------------------------
// (C) 2017 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.2.7 2022/02/09 戦闘画面において下層ピクチャの表示位置が実際と比べてズレて表示される問題を修正
// 1.2.6 2021/08/05 上層ピクチャが画面シェイクに連動しない問題を修正
// 1.2.5 2020/11/02 NRP_DynamicMotionMZ.jsと併用したとき戦闘画面のピクチャを敵キャラの下に表示できなくなる競合を修正
// 1.2.4 2020/11/05 戦闘画面で使用するとエラーになる問題を修正
// 1.2.3 2020/09/06 座標の基準をUI幅ではなく画面幅に変更
// 1.2.2 2020/08/29 MZ向けにコード修正
// 1.2.1 2019/05/08 1.2.0の機能がYEP_BattleEngineCore.jsと併用すると無効になる競合を解消
// 1.2.0 2019/05/02 戦闘画面における下層ピクチャの表示優先度を微調整する機能を追加
// 1.1.3 2019/01/20 MenuCommonEvent.jsとの競合によるエラーを解消
// 1.1.2 2018/06/27 1.1.1の対応により発生したYEP_BattleEngineCore.jsとの競合を解消
// 1.1.1 2017/12/24 GALV_LayerGraphics.jsと併用したときに画像がちらつく競合を解消
// 1.1.0 2017/10/01 パラメータの型指定機能に対応
// 1.0.0 2017/03/20 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc PicturePriorityCustomizePlugin
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/PicturePriorityCustomize.js
 * @author triacontane
 *
 * @param UpperPictureId
 * @desc Pictures above the specified number will be displayed above the window.
 * @default 101
 * @type number
 *
 * @param LowerPictureId
 * @desc Pictures below the specified number will be displayed below the character and the butler.
 * @default 0
 * @type number
 *
 * @param LowerPictureZ
 * @desc The Z coordinate of the lower picture. You can adjust the display priority more finely by changing it.
 * @default 1
 * @type select
 * @option Lower Tile
 * @value 0
 * @option Lower Character
 * @value 1
 * @option Same Character
 * @value 3
 * @option Upper Tile
 * @value 4
 * @option Upper Character
 * @value 5
 * @option Shadow
 * @value 6
 * @option Balloon
 * @value 7
 * @option Destination
 * @value 9
 *
 * @param LowerPictureBattleZ
 * @desc Z coordinate of the lower picture of the battle screen.
 * @default 0
 * @type select
 * @option enemy
 * @value 0
 * @option animation
 * @value 1
 *
 * @help You can divide the picture into upper, middle and lower layers.
 * Upper: above the window
 * Mid: default priority
 * Lower: below the character
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc ピクチャの表示優先度調整プラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/PicturePriorityCustomize.js
 * @author トリアコンタン
 *
 * @param 上層ピクチャ番号
 * @desc 指定した番号以上のピクチャはウィンドウより上に表示されるようになります。
 * @default 101
 * @type number
 *
 * @param 下層ピクチャ番号
 * @desc 指定した番号以下のピクチャはキャラクター、バトラーより下に表示されるようになります。
 * @default 0
 * @type number
 *
 * @param 下層ピクチャZ座標
 * @desc 下層ピクチャのZ座標です。変更することでより細かい表示優先度の調整ができます。
 * @default 1
 * @type select
 * @option 下層タイル
 * @value 0
 * @option 通常キャラの下
 * @value 1
 * @option 通常キャラと同じ
 * @value 3
 * @option 上層タイル
 * @value 4
 * @option 通常キャラの上
 * @value 5
 * @option 飛行船の影
 * @value 6
 * @option フキダシ
 * @value 7
 * @option マップタッチの行き先
 * @value 9
 *
 * @param 戦闘下層ピクチャZ座標
 * @desc 戦闘画面の下層ピクチャのZ座標です。変更することでより細かい表示優先度の調整ができます。
 * @default 0
 * @type select
 * @option 敵キャラ
 * @value 0
 * @option アニメーション
 * @value 1
 *
 * @help ピクチャを上層、中層、下層に分けて表示できます。
 * 上層：ウィンドウより上
 * 中層：デフォルトの優先度
 * 下層：キャラクターより下
 *
 * 下層ピクチャに対しては、Z座標を設定することで
 * より細かい表示優先度の調整ができます。
 *
 * ※それぞれのプライオリティの値
 * 0 : 下層タイル
 * 1 : 通常キャラの下
 * 3 : 通常キャラと同じ
 * 4 : 上層タイル
 * 5 : 通常キャラの上
 * 6 : 飛行船の影
 * 7 : フキダシ
 * 8 : アニメーション
 * 9 : マップタッチの行き先（白く光るヤツ）
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
  "use strict";
  const pluginName = "PicturePriorityCustomize";

  //=============================================================================
  // ローカル関数
  //  プラグインパラメータやプラグインコマンドパラメータの整形やチェックをします
  //=============================================================================
  const getParamString = function (paramNames) {
    if (!Array.isArray(paramNames)) paramNames = [paramNames];
    for (let i = 0; i < paramNames.length; i++) {
      const name = PluginManager.parameters(pluginName)[paramNames[i]];
      if (name) return name;
    }
    return "";
  };

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

  //=============================================================================
  // パラメータの取得と整形
  //=============================================================================
  const param = {};
  param.upperPictureId = getParamNumber(["UpperPictureId", "上層ピクチャ番号"]);
  param.lowerPictureId = getParamNumber(["LowerPictureId", "下層ピクチャ番号"]);
  param.lowerPictureZ = getParamNumber(["LowerPictureZ", "下層ピクチャZ座標"]);
  param.lowerPictureBattleZ = getParamNumber(
    ["LowerPictureBattleZ", "戦闘下層ピクチャZ座標"],
    0
  );

  //=============================================================================
  // Scene_Base
  //  ウィンドウの上にピクチャを配置します。
  //=============================================================================
  var _Scene_Base_createWindowLayer = Scene_Base.prototype.createWindowLayer;
  Scene_Base.prototype.createWindowLayer = function () {
    _Scene_Base_createWindowLayer.apply(this, arguments);
    if (this._spriteset) {
      this._spriteset.setUpperPictureContainer(this);
    }
  };

  //=============================================================================
  // Spriteset_Base
  //  ピクチャを三層に分割します。
  //=============================================================================
  var _Spriteset_Base_createPictures = Spriteset_Base.prototype.createPictures;
  Spriteset_Base.prototype.createPictures = function () {
    _Spriteset_Base_createPictures.apply(this, arguments);
    this.removeChild(this._pictureContainer);
    this.createPictureLayer();
  };

  Spriteset_Base.prototype.createPictureLayer = function () {
    var width = Graphics.width;
    var height = Graphics.height;
    var x = 0;
    var y = 0;
    this._pictureContainerLower = new Sprite();
    this._pictureContainerLower.setFrame(x, y, width, height);
    this._pictureContainerMiddle = new Sprite();
    this._pictureContainerMiddle.setFrame(x, y, width, height);
    this._pictureContainerUpper = new Sprite();
    this._pictureContainerUpper.setFrame(x, y, width, height);
    var pictureArray = this._pictureContainer.children.clone();
    pictureArray.forEach(function (picture) {
      var pictureId = picture.getPictureId();
      if (pictureId <= param.lowerPictureId) {
        this._pictureContainerLower.addChild(picture);
      } else if (pictureId >= param.upperPictureId) {
        this._pictureContainerUpper.addChild(picture);
      } else {
        this._pictureContainerMiddle.addChild(picture);
      }
    }, this);
    this._pictureContainer.children = pictureArray;
    this.setLowerPictureContainer();
    this.setMiddlePictureContainer();
  };

  Spriteset_Base.prototype.setUpperPictureContainer = function (parentScene) {
    parentScene.addChild(this._pictureContainerUpper);
  };

  Spriteset_Base.prototype.setMiddlePictureContainer = function () {
    this.addChild(this._pictureContainerMiddle);
  };

  Spriteset_Base.prototype.setLowerPictureContainer = function () {
    this.addChild(this._pictureContainerLower);
  };

  var _Spriteset_Base_updatePosition = Spriteset_Base.prototype.updatePosition;
  Spriteset_Base.prototype.updatePosition = function () {
    _Spriteset_Base_updatePosition.apply(this, arguments);
    this._pictureContainerUpper.x = this.x;
    this._pictureContainerUpper.y = this.y;
  };

  //=============================================================================
  // Spriteset_Map
  //  下層ピクチャの位置を設定します。
  //=============================================================================
  Spriteset_Map.prototype.setLowerPictureContainer = function () {
    this._pictureContainerLower.z = param.lowerPictureZ;
    this._tilemap.addChild(this._pictureContainerLower);
  };

  //=============================================================================
  // Spriteset_Battle
  //  下層ピクチャの位置を設定します。
  //=============================================================================
  Spriteset_Battle.prototype.setLowerPictureContainer = function () {
    this.updateLowerPictureContainerZ();
    // resolve conflict for GALV_LayerGraphics.js
    if (typeof Imported !== "undefined" && Imported.Galv_LayerGraphics) {
      this._pictureContainerLower.z = 2;
    }
    // resolve conflict for NRP_DynamicMotionMZ.js
    if (PluginManagerEx.isExistPlugin("NRP_DynamicMotionMZ")) {
      this._pictureContainerLower.z = param.lowerPictureBattleZ > 0 ? 10 : 0;
    }
    this._pictureContainerLower.y = -this._battleField.y;
    this._pictureContainerLower.x = -this._battleField.x;
  };

  Spriteset_Battle.prototype.updateLowerPictureContainerZ = function () {
    if (param.lowerPictureBattleZ > 0) {
      this._battleField.addChild(this._pictureContainerLower);
    } else {
      this._battleField.addChildAt(this._pictureContainerLower, 0);
    }
  };

  if (typeof Yanfly !== "undefined" && Yanfly.BEC) {
    var _Spriteset_Battle_update = Spriteset_Battle.prototype.update;
    Spriteset_Battle.prototype.update = function () {
      _Spriteset_Battle_update.apply(this, arguments);
      this.updateLowerPictureContainerZ();
    };
  }

  //=============================================================================
  // Sprite_Picture
  //  ピクチャIDを取得可能にします。
  //=============================================================================
  Sprite_Picture.prototype.getPictureId = function () {
    return this._pictureId;
  };
})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// PluginCommandMVInScriptArea.js
//=============================================================================
// Copyright (c) 2020 Thirop
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
//=============================================================================
/*:
 * @target MZ
 * @author Thirop
 * @plugindesc スクリプト欄でMV形式プラグインコマンドを実行
 *
 * @param commands
 * @text コマンド登録
 * @desc 登録したコマンドはcmdを省略して記述できます。
 * @type String[]
 * @default ["skit","スキット"]
 *
 * @help
 * スクリプトコマンドでMV形式のプラグインコマンドが実行できます。
 * たとえば「command1 arg1」というプラグインコマンドを実行するには
 * cmdを頭につけてスクリプトに
 *
 * cmd command1 arg1
 *
 * と記述します。
 * 複数行入力することも可能ですが、ウェイトが無視されたり
 * 意図しない動作となる場合があるのでスクリプトコマンド１つにつき
 * プラグインコマンド１つを実行することを推奨します。
 *
 * また、プラグイン設定にコマンド名を登録することで先頭の「cmd」が
 * 省略できるようになります。
 *
 *
 * 【更新履歴】
 * 1.0.0 2020/8/23  初版
 *
 */
//=============================================================================

(() => {
  "use strict";

  let cmdRegExp;
  function setupPluginParameters() {
    const parameters = PluginManager.parameters(
      "PluginCommandMVInScriptArea".toLowerCase()
    );
    let expStr = "^(?:cmd";
    if (parameters.commands) {
      const commands = JSON.parse(parameters.commands);
      for (let command of commands) {
        expStr += "|" + command;
      }
    }
    expStr += ")";
    cmdRegExp = new RegExp(expStr);
  }

  const _Scene_Boot_start = Scene_Boot.prototype.start;
  Scene_Boot.prototype.start = function () {
    _Scene_Boot_start.call(this);
    setupPluginParameters();
  };

  const Game_Interpreter_command355 = Game_Interpreter.prototype.command355;
  Game_Interpreter.prototype.command355 = function () {
    if (cmdRegExp.test(this.currentCommand().parameters[0])) {
      this.processMVPluginCommandByScript();
      return true;
    } else {
      return Game_Interpreter_command355.call(this);
    }
  };

  Game_Interpreter.prototype.processMVPluginCommandByScript = function () {
    let script = this.currentCommand().parameters[0];
    this._processMvPluginCommandByScript(script);

    while (this.nextEventCode() === 655) {
      this._index++;
      let script = this.currentCommand().parameters[0];
      this._processMvPluginCommandByScript(script);
    }
  };

  Game_Interpreter.prototype._processMvPluginCommandByScript = function (
    script
  ) {
    if (!cmdRegExp.test(script)) {
      return;
    }
    script = script.replace(/^cmd /, "");

    let args = script.split(" ");
    if (args.length > 0) {
      let command = args.shift();
      this.pluginCommand(command, args);
    }
  };

  Game_Interpreter.processKeyValuePluginCommandArguments = function (
    elems,
    defaults,
    map = null,
    keys,
    param
  ) {
    keys = keys || Object.keys(defaults);
    param = param || {};

    const keyLen = keys.length;
    for (let i = 0; i < keyLen; i = (i + 1) | 0) {
      let key = keys[i];
      param[key] = defaults[key];
    }

    const elemLen = elems.length;
    let keyIdx = 0;
    for (let elem of elems) {
      if (map && map[elem]) {
        elem = map[elem];
      }

      let index = elem.indexOf(":");
      if (index <= 0) {
        if (keys.contains(elem)) {
          //flag
          index = elem.length;
          elem += ":true";
        } else {
          param[keys[keyIdx++]] = elem;
          continue;
        }
      }

      let key = elem.substring(0, index);
      if (map && map[key]) {
        key = map[key];
      }
      var order = keys.indexOf(key);
      if (order < 0) {
        param[keys[keyIdx++]] = elem;
        continue;
      }

      let valueStr = elem.substring(index + 1);
      let value;
      switch (typeof defaults[key]) {
        case "boolean":
          if (valueStr === "f" || valueStr === "false" || valueStr === "0") {
            value = false;
          } else {
            value = true;
          }
          break;
        case "number":
          value = Number(valueStr);
          break;
        default:
          value = valueStr;
      }
      param[key] = value;

      if (order === keyIdx) {
        keyIdx += 1;
      }
    }

    return param;
  };
  Game_Interpreter.prototype.processKeyValuePluginCommandArguments =
    Game_Interpreter.processKeyValuePluginCommandArguments;
})();


code:
//=============================================================================
// RPG Maker MZ - Plugin Analysis Common Base
//=============================================================================
// Version
// 1.0.5 2022/02/21 TextScriptBase.jsの\txの制御文字のなかに\s[n]を使ったときに正常に返還されない問題を修正
// 1.0.4 2021/12/19 オブジェクトのクラス名を取得する共通関数が一部のパターン
//                  （functionを使った宣言かつ名称の後ろにスペースがあるケース等）で正常に取得できない問題を修正
// 1.0.3 2021/10/07 文章の表示で「\\」が正しく表示されない問題を修正
// 1.0.2 2021/05/15 プラグインコマンドにもsuffixで型変換しない仕様を適用
// 1.0.1 2021/04/15 プラグイン名称取得で全角文字を考慮
//                  配列の要素のパラメータの制御文字が正常に取得できない問題を修正
// 1.0.0 2020/08/20 初版
//=============================================================================

/*:
 * @target MZ
 * @plugindesc Plugin Analysis Common Base
 * @author triacontane
 *
 * @help PluginCommonBase.js
 *
 * This plugin is a base plugin that is meant to be referenced from other plugins.
 * This plugin allows you to use the following control characters in a variety of situations.
 *
 * Usable Control Characters
 * \v[n]  : nis converted to the value of the nth variable.
 * \s[n]  : nis converted to the value (true, false) of the nth switch.
 * \ss[n] : nis converted to the value (true, false) of the nth self switch.
 * n -> A, B, C, D
 *
 * The situations where control characters can be used are as follows.
 * -Text display
 * -Notes field (*)
 * -Plugin command (*)
 * -Plugin parameter (*)
 * -Explanation fields for skills, etc.
 * *Only for plugins that take PluginCommonBase.js as a base.
 *
 * Below is an explanation for developers.
 *
 * Introducing this plugin as a base allows conversion of parameter types and control characters,
 * when analyzing parameters or fetching plugin commands/note fields, to be automated.
 * Standardizing control character allows conversion processing, and consistent
 * control character conversion specs to be implemented in all subordinate plugins.
 *
 * -Plugin Parameter Type Analysis
 * Automatically analyzes type and converts plugin parameters.
 * Also automatically converts control characters when the parameter is fetched.
 * Calls the following methods to fetch return values.
 *  Always specifies "document.currentScript" in the argument.
 *
 * PluginManagerEx.createParameter(document.currentScript);
 *
 * However, if the end of the parameter name (regardless of case)
 * is one of the following values, the value will be returned as-is without control character or type conversion.
 * text
 * name
 * note
 * desc
 * script
 *
 * -Plugin Command Parameter Type Analysis
 * Automatically analyzes type and converts plugin command parameters.
 * Also automatically converts control characters when the parameter is fetched.
 * Uses the following in place of PluginManager.registerCommand.
 * Always specifies "document.currentScript" in the argument.
 *
 * PluginManagerEx.registerCommand(document.currentScript, "command", args => {
 * });
 *
 * -Notes Field Analysis
 * Retrieves notes field information from specified objects.
 * Automatically converts control characters.
 * Multiple names can be specified.
 *
 * PluginManagerEx.findMetaValue(obj, tagName1, tagName2...);
 *
 * -Dynamic Common Event Execution
 * Executions dynamic common events.
 * Dynamic common events are stacked parallel processed common events.
 * Use to execute as many common events with the same ID in parallel as you want.
 * It can register as many common events as you want and automatically discards those that have been executed.
 *
 * $gameMap.setupDynamicCommon(commonEventId);
 *
 */

/*:ja
 * @target MZ
 * @plugindesc パラメータ解析を提供する共通基盤です
 * @author トリアコンタン
 * @url \dlc\BasicResources\plugins\official
 *
 * @help PluginCommonBase.js
 *
 * 本プラグインは他のプラグインから参照されることを前提としたベースプラグインです。
 * 本プラグインを導入すると様々な場面で以下の制御文字が使えるようになります。
 *
 * 利用可能な制御文字
 * \v[n]  : n番目の変数の値に変換されます。
 * \s[n]  : n番目のスイッチの値(true, false)に変換されます。
 * \ss[n] : セルフスイッチの値(true, false)に変換されます。
 * n -> A, B, C, D
 *
 * 制御文字を利用可能な場面は以下の通りです。
 * ・文章の表示
 * ・メモ欄(※)
 * ・プラグインコマンド(※)
 * ・プラグインパラメータ(※)
 * ・スキルなどの説明欄
 * ※ PluginCommonBase.jsをベースとして取り込んだプラグインのみ
 *
 * 以下は開発者向けの解説です。
 *
 * このプラグインをベースとして取り込むことで、パラメータの解析や
 * プラグインコマンド、メモ欄の取得時にパラメータ型および制御文字の変換を自動化します。
 * 制御文字の変換処理を共通化することで配下の全てのプラグインで一貫した
 * 制御文字の変換仕様を実現します。
 *
 * ・プラグインパラメータの型解析
 * プラグインパラメータを自動で型解析し変換します。
 * また、パラメータ取得時に制御文字の変換を自動で行います。
 * 以下のメソッドを呼んで戻り値を取得します。
 * 引数には必ず「document.currentScript」を指定します。
 *
 * PluginManagerEx.createParameter(document.currentScript);
 *
 * ただし、パラメータ名の末尾が(大文字小文字問わず)以下の値の場合
 * 制御文字や型の変換は行われず、そのままの値を返します。
 * text
 * name
 * note
 * desc
 * script
 *
 * ・プラグインコマンドパラメータの型解析
 * プラグインコマンドパラメータを自動で型解析し変換します。
 * また、パラメータ取得時に制御文字の変換を自動で行います。
 * PluginManager.registerCommandの代わりに以下を使用します。
 * 引数には必ず「document.currentScript」を指定します。
 *
 * PluginManagerEx.registerCommand(document.currentScript, "command", args => {
 * });
 *
 * ・メモ欄の解析
 * 指定したオブジェクトからメモ欄情報を取得します。
 * 制御文字の変換を自動で行います。
 * 名称は複数指定することも可能です。
 *
 * PluginManagerEx.findMetaValue(obj, tagName1, tagName2...);
 *
 * ・動的コモンイベントの実行
 * 動的コモンイベントを実行できます。
 * 動的コモンイベントとは、スタック型の並列処理コモンイベントです。
 * 同一IDのコモンイベントも好きなだけ並列実行できます。
 * 実行が終わったものから自働で破棄されます。
 *
 * $gameMap.setupDynamicCommon(commonEventId);
 */

(() => {
  "use strict";

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

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

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

    _convert(param, paramName) {
      if (this._isStruct(param) || this._isStructArray(param)) {
        return param;
      } else if (Array.isArray(param)) {
        return param.map((paramItem) => this._convert(paramItem, paramName));
      }
      if (
        !PluginManagerEx.findTextParamSuffixList().some((regExp) =>
          paramName.match(regExp)
        )
      ) {
        return PluginManagerEx.convertVariables(param);
      } else {
        return String(param);
      }
    }

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

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

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

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

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

    static convertEscapeCharacters(text, data = null, needEscape = true) {
      if (needEscape) {
        text = text.replace(/\\/g, "\x1b");
        text = text.replace(/\x1b\x1b/g, "\\");
      }
      text = TextConverter.convertEscapeCharactersBase(text, data);
      text = this.convertEscapeCharactersEx(text, data);
      text = TextConverter.convertEscapeCharactersBase(text, data);
      return text;
    }

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

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

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

    static findMetaValue(object, nameList) {
      if (!Array.isArray(nameList)) {
        nameList = [nameList];
      }
      const meta = this.findMetaProperty(object);
      this.generateSelfSwitchKey(object.id);
      for (const name of nameList) {
        if (meta.hasOwnProperty(name)) {
          return this.convertVariables(meta[name], object);
        }
      }
    }

    static findMetaObject(object, nameList) {
      if (!Array.isArray(nameList)) {
        nameList = [nameList];
      }
      const meta = this.findMetaProperty(object);
      this.generateSelfSwitchKey(object.id);
      for (const name of nameList) {
        if (meta.hasOwnProperty(name)) {
          return new PluginParam(meta[name]);
        }
      }
    }

    static findMetaProperty(object) {
      const meta = object.meta;
      if (!meta) {
        throw new Error(`Meta property not found : ${object}`);
      }
      return meta;
    }

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

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

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

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

    static findClassName(object) {
      const define = object.constructor.toString();
      if (define.match(/^class/)) {
        return define.replace(/class\s+(.*?)\s+[\s\S]*/m, "$1");
      }
      return define.replace(/function\s+(.*?)\s*\([\s\S]*/m, "$1");
    }

    static throwError(message, currentScript) {
      const pluginName = this.findPluginName(currentScript);
      throw new Error(`By ${pluginName} : ${message}`);
    }

    static escapeXmlTag(text) {
      text = text.replace(/>?/gi, ">");
      return text.replace(/<?/gi, "<");
    }

    static findTextParamSuffixList() {
      return [/text$/gi, /name$/gi, /desc$/gi, /note$/gi, /script$/gi];
    }
  }
  window.PluginManagerEx = PluginManagerEx;

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

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

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

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

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

  const _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
  Game_System.prototype.onAfterLoad = function () {
    _Game_System_onAfterLoad.apply(this, arguments);
    $gameMap.initDynamicEvents();
  };

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

  Game_Map.prototype.initDynamicEvents = function () {
    if (!this._dynamicEvents) {
      this._dynamicEvents = [];
    }
  };

  Game_Map.prototype.isInterpreterOf = function (interpreter) {
    return this._interpreter === interpreter;
  };

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

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

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

  /**
   * Game_Event
   */
  Game_Event.prototype.findMeta = function (metaNames) {
    return PluginManagerEx.findMetaValue(this.event(), metaNames);
  };

  /**
   * Game_Interpreter
   */
  const _Game_Interpreter_setup = Game_Interpreter.prototype.setup;
  Game_Interpreter.prototype.setup = function (list, eventId) {
    _Game_Interpreter_setup.apply(this, arguments);
    if (eventId) {
      PluginManagerEx.generateSelfSwitchKey(eventId);
    }
  };
})();


code:
/*=============================================================================
 RemoveStateExtend.js
----------------------------------------------------------------------------
 (C)2022 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.1.0 2022/06/08 解除条件にスクリプトを設定、解除確率を補正するタグを追加
 1.0.0 2022/03/23 初版
----------------------------------------------------------------------------
 [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/RemoveStateExtend.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author トリアコンタン
 *
 * @param byDamageList
 * @text ダメージで解除のリスト
 * @desc ダメージを受けたときのステート解除を条件付きにします。データベースの当該項目とは独立して動作します。
 * @default []
 * @type struct<DAMAGE>[]
 *
 * @help RemoveStateExtend.js
 *
 * ステート解除の条件を拡張します。
 * 特定の属性を含む（含まない）攻撃を受けたときや、魔法攻撃を受けたとき
 * HP割合が指定値を下回った場合のみ解除されるステートなどが作成できます。
 * パラメータから条件リストを設定します。
 *
 * ステートを解除するときの確率を補正(加算)するメモ欄です。
 * アクター、職業、武器、防具、敵キャラ、ステートのメモ欄で有効です。
 * ex:ステートID[3]のステート解除確率が20%加算されます。
 * <ステート解除補正3:20>
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~DAMAGE:
 *
 * @param stateId
 * @text ステートID
 * @desc 解除条件を設定するステートIDです。同一ステートを複数定義したときは『いずれか』の条件を満たすと解除されます。
 * @default 1
 * @type state
 *
 * @param elementId
 * @text 属性ID
 * @desc 相手の攻撃が特定の属性を含んでいたときに解除されます。
 * @default 0
 * @type number
 *
 * @param hitType
 * @text 命中タイプ
 * @desc 命中タイプが指定したものと一致するときに解除されます。
 * @default 0
 * @type select
 * @option 指定なし
 * @value 0
 * @option 物理攻撃
 * @value 1
 * @option 魔法攻撃
 * @value 2
 *
 * @param hpRate
 * @text HP割合(%)
 * @desc HPが指定した割合以下の場合に解除されます。
 * @default 0
 * @type number
 * @min 0
 * @max 100
 *
 * @param mpRate
 * @text MP割合(%)
 * @desc MPが指定した割合以下の場合に解除されます。
 * @default 0
 * @type number
 * @min 0
 * @max 100
 *
 * @param tpRate
 * @text TP割合(%)
 * @desc TPが指定した割合以下の場合に解除されます。
 * @default 0
 * @type number
 * @min 0
 * @max 100
 *
 * @param script
 * @text スクリプト
 * @desc 指定した場合、スクリプトの評価結果がtrueを返した場合に解除されます。thisでバトラー、stateでステートが参照できます。
 * @default
 * @type multiline_string
 *
 * @param reverse
 * @text 条件反転
 * @desc 上記の条件を『満たさなかった』場合に解除されるよう変更します。
 * @default false
 * @type boolean
 *
 * @param chanceByDamage
 * @text 解除確率
 * @desc 条件を満たしたときに解除される確率です。100%にすると常に解除されます。
 * @default 100
 * @type number
 * @min 0
 * @max 100
 *
 */

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

  const _Game_Battler_removeStatesByDamage =
    Game_Battler.prototype.removeStatesByDamage;
  Game_Battler.prototype.removeStatesByDamage = function () {
    _Game_Battler_removeStatesByDamage.apply(this, arguments);
    if (!this._acceptItem) {
      return;
    }
    this.states().forEach((state) => {
      param.byDamageList
        .filter((item) => this.isRemoveStateExtend(state, item))
        .forEach((item) => this.removeState(item.stateId));
    });
  };

  Game_Battler.prototype.isRemoveStateExtend = function (state, paramItem) {
    if (state.id !== paramItem.stateId) {
      return false;
    }
    let result = true;
    if (
      paramItem.elementId &&
      this._acceptItem.damage.elementId !== paramItem.elementId
    ) {
      result = false;
    }
    if (paramItem.hitType && this._acceptItem.hitType !== paramItem.hitType) {
      result = false;
    }
    if (paramItem.hpRate && this.hpRate() > paramItem.hpRate / 100) {
      result = false;
    }
    if (paramItem.mpRate && this.mpRate() > paramItem.mpRate / 100) {
      result = false;
    }
    if (paramItem.tpRate && this.tpRate() > paramItem.tpRate / 100) {
      result = false;
    }
    if (paramItem.script && !eval(paramItem.script)) {
      result = false;
    }
    if (paramItem.reverse) {
      result = !result;
    }
    return Math.randomInt(100) < this.findRemoveStateRate(paramItem, state)
      ? result
      : false;
  };

  Game_Battler.prototype.findRemoveStateRate = function (paramItem, state) {
    const tag = `ステート解除補正${state.id}`;
    const rate = this.traitObjects().reduce(
      (prev, obj) => prev + (PluginManagerEx.findMetaValue(obj, tag) || 0),
      0
    );
    return paramItem.chanceByDamage + rate;
  };

  Game_Battler.prototype.setAcceptedItem = function (item) {
    this._acceptItem = item;
  };

  const _Game_Action_executeHpDamage = Game_Action.prototype.executeHpDamage;
  Game_Action.prototype.executeHpDamage = function (target, value) {
    target.setAcceptedItem(this.item());
    _Game_Action_executeHpDamage.apply(this, arguments);
    target.setAcceptedItem(null);
  };
})();


code:
/*:ja
 * @plugindesc アクターコマンド封印プラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/SealActorCommand.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author トリアコンタン
 *
 * @param commandDisable
 * @text コマンド使用禁止
 * @desc 封印したコマンドを非表示ではなく使用禁止にします。
 * @default false
 * @type boolean
 *
 * @param disableSign
 * @text 使用禁止サイン
 * @desc 使用禁止にしたコマンドのうえに被せる文字列です。(コマンド使用禁止が有効な場合のみ機能します)
 * @default c[2]i[1]禁止i[1]
 *
 * @help アクターコマンド「攻撃」「防御」「アイテム」「スキル」を封印できます。
 * 封印されたコマンドはウィンドウから消失します。
 * 特定のコマンドが使用できないアクター、職業、装備品、ステートが作成できます。
 * さらに、スイッチやJavaScript計算式により、細かい条件が指定できます。
 *
 * 特徴を有するデータベースのメモ欄に以下の通り記入してください。
 *
 * <攻撃封印スイッチ:4>   # ID[4]のスイッチがONのとき攻撃を封印
 * <AttackSealSwitch:4>   # 同上
 * <防御封印スイッチ:5>   # ID[5]のスイッチがONのとき防御を封印
 * <GuardSealSwitch:5>    # 同上
 * <道具封印スイッチ:6>   # ID[6]のスイッチがONのときアイテムを封印
 * <ItemSealSwitch:6>     # 同上
 * <スキル封印スイッチ:7> # ID[7]のスイッチがONのときスキルを封印
 * <SkillSealSwitch:7>    # 同上
 * <攻撃封印計算式:f>     # 計算式[f]の結果がtrueのとき攻撃を封印
 * <AttackSealFormula:f>  # 同上
 * <防御封印計算式:f>     # 計算式[f]の結果がtrueのとき防御を封印
 * <GuardSealFormula:f>   # 同上
 * <道具封印計算式:f>     # 計算式[f]の結果がtrueのときアイテムを封印
 * <ItemSealFormula:f>    # 同上
 * <スキル封印計算式:f>   # 計算式[f]の結果がtrueのときスキルを封印
 * <SkillSealFormula:f>   # 同上
 *
 * スイッチを指定しなかった場合、常に封印されます。
 * <攻撃封印スイッチ>
 *
 * 文章、スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → <
 * > → >
 *
 * 例
 * <AttackSealFormula:v[1] >= 5> # 変数[1]が5以下の場合攻撃封印
 * <GuardSealSwitch>                 # 常に防御封印
 *
 * 注意！
 * 全てのコマンドを封印するとゲームが続行不可になります。
 *
 * アイテム使用をスキル化したい場合は、スキルのメモ欄に以下の通り
 * 入力してください。対象スキルを選択後、アイテムウィンドウが開きます。
 * <アイテムスキル> # アイテム使用スキル化
 * <ItemSkill>      # 同上
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */


code:
//=============================================================================
// SealEscapeCommand.js
//=============================================================================

/*:
 * @target MZ
 * @plugindesc Creates a trait to disable the [Escape] command.
 * @author Toru Higuruma
 * @url https://github.com/neofuji/RPGMZ-Plugins
 *
 * @help SealEscapeCommand v1.0 (2020-08-25)
 * Copyright (c) 2020 Toru Higuruma
 * This plugin is provided under the MIT License.
 *
 * It does not provide plugin commands.
 *
 * Actors/Classes/Weapons/Armors/States note:
 *   <seal_escape>  : Seal escape command
 */

/*:ja
 * @target MZ
 * @plugindesc ［逃げる］コマンドが使用できなくなる特徴を作ります。
 * @author Toru Higuruma
 * @url https://github.com/neofuji/RPGMZ-Plugins
 *
 * @help SealEscapeCommand v1.0 (2020-08-25)
 * Copyright (c) 2020 Toru Higuruma
 * このプラグインは MIT License の下で提供されます。
 *
 * プラグインコマンドはありません。
 *
 * アクター／職業／武器／防具／ステートのメモ:
 *   <seal_escape>  : ［逃げる］コマンド封印
 */

(() => {
  const _BattleManager_canEscape = BattleManager.canEscape;
  BattleManager.canEscape = function () {
    return (
      _BattleManager_canEscape.apply(this, arguments) &&
      !$gameParty
        .members()
        .some((actor) =>
          actor.traitObjects().some((obj) => obj.meta.seal_escape === true)
        )
    );
  };
})();


code:
//=============================================================================
// SideEffectSkill.js
// ----------------------------------------------------------------------------
// (C) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.7.2 2022/09/20 ID問わずすべての副作用を無効化できる特徴を追加
// 1.7.1 2022/09/20 1.7.0のメモ欄の仕様を変更
// 1.7.0 2022/09/20 副作用を無効化できる特徴を追加
// 1.6.5 2022/04/02 ステートおよびバフが解除されたとき、解除メッセージが二重に出力される場合がある問題を修正
// 1.6.4 2022/01/13 BattleEffectPopup.jsと併用したとき、使用者に対する効果ポップアップが二重に出力される場合がある問題を修正
// 1.6.3 2021/12/27 1.6.2の修正が一部不十分だった問題を修正
// 1.6.2 2021/11/29 使用者に対する行動結果が出力されない場合がある問題を修正
// 1.6.1 2021/10/20 メニュー画面でスキルを使用するとエラーになる問題を修正
// 1.6.0 2021/10/16 MZで動作するよう全面的に修正
// 1.5.0 2021/06/13 行動が耐性だったのときのみ適用する副作用を指定できる機能を追加
// 1.4.2 2020/05/22 反撃された場合などスキルを使用しなかったケースで「弱点時のみ」などの判定が無条件で有効になってしまう問題を修正
// 1.4.1 2019/07/15 BattleEffectPopup.jsと併用したとき、フロントビューだと戦闘開始時などにInvalidポップが余分に表示される競合を解消
// 1.4.0 2019/02/16 行動が無効(ダメージ0)だった場合のみ副作用を適用できる機能を追加
//                  行動が反射された場合のみ副作用を適用できる機能を追加
// 1.3.0 2018/11/29 行動が会心だった場合のみ副作用を適用できる機能を追加
// 1.2.3 2017/10/10 0ターン目に戦闘行動の強制を実行するとエラーになる問題の修正
// 1.2.2 2017/10/07 ターン終了時の副作用を持つスキルでトドメをさした場合、次の戦闘のターン終了時に副作用が発生する問題を修正
// 1.2.1 2017/06/10 自動戦闘が有効なアクターがいる場合に一部機能が正常に動作しない問題を修正
// 1.2.0 2017/06/01 弱点時のみ副作用が適用できる機能を追加
// 1.1.1 2017/01/24 副作用設定時にターン終了時にダメージのポップアップ等が出なくなる問題を修正
// 1.1.0 2016/12/13 フロントビュー時にエフェクト効果のメッセージが重複して表示される問題を修正
// 1.0.2 2016/10/10 行動パターンが何も設定されていない敵キャラが行動しようとするとエラーになる問題を修正
// 1.0.1 2016/10/10 タイミングが「スキル使用時」「ターン開始時」以外のものについて、対象者にも効果が適用されていた問題を修正
// 1.0.0 2016/09/25 初版
// ----------------------------------------------------------------------------
// [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/SideEffectSkill.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author トリアコンタン
 *
 * @help SideEffectSkill.js
 *
 * スキル使用時に、使用者に対して適用されるスキル効果を設定できます。
 * 副作用が適用されるタイミングは以下の中から選択できます。
 *
 * ・スキル入力時(敵キャラのみ有効)
 * 味方の行動入力前に副作用が適用されます。敵キャラ専用です。
 *
 * ・スキル使用前
 * スキルを使用する直前に副作用が適用されます。スキルを使用する時点では
 * すでに適用済みの状態になっています。
 *
 * ・スキル使用時
 * スキルを使用して、相手に効果が適用されるのと同じタイミングで
 * 副作用が適用されます。
 *
 * ・スキル使用後
 * スキルを使用して、相手に効果が適用された後で、副作用が適用されます。
 * 微妙なタイミングの違い以外は、ほぼ「スキル使用時」と同じです。
 *
 * ・ターン開始時(ターン制戦闘のみ有効)
 * 味方の行動入力が終わってターンが開始された瞬間に
 * 副作用が適用されます。
 *
 * ・ターン終了時(ターン制戦闘のみ有効)
 * 全員の行動が完了してターンが終了した瞬間に
 * 副作用が適用されます。
 *
 * さらにスキルが「成功時のみ」「失敗時のみ」「弱点時のみ」の場合だけ
 * 副作用を適用することもできます。
 *
 * スキルのメモ欄に以下の通り指定してください。
 * 使用効果のうち指定された番号の効果の適用対象がもとの効果範囲の対象者ではなく
 * スキル使用者に変更されます。（対象者には適用されなくなります）
 *
 * <スキル入力時:4,3>  # スキル入力時、効果[4][3]を使用者に適用（敵専用）
 * <OnSkillInput:4,3>  # 同上
 * <スキル使用前:3>    # スキル使用前、効果[3]を使用者に適用
 * <OnSkillBefore:3>   # 同上
 * <スキル使用時:3>    # スキル使用時、効果[3]を使用者に適用
 * <OnSkillUsing:3>    # 同上
 * <スキル使用後:1,5>  # スキル使用後、効果[1][5]を使用者に適用（[,]区切り）
 * <OnSkillAfter:1,5>  # 同上
 * <ターン開始時:2,4>  # ターン開始時、効果[2][4]を使用者に適用
 * <OnTurnStart:2,4>   # 同上
 * <ターン終了時:8>    # ターン終了時、効果[8]を使用者に適用
 * <OnTurnEnd:8>       # 同上
 * <成功時のみ>        # 行動が成功した場合のみ副作用を適用
 * <HitOnly>           # 同上
 * <失敗時のみ>        # 行動が失敗した場合のみ副作用を適用
 * <MissOnly>          # 同上
 * <弱点時のみ>        # 行動が弱点を突いた場合のみ副作用を適用
 * <EffectiveOnly>     # 同上
 * <耐性時のみ>        # 行動が耐性だった場合のみ副作用を適用
 * <ResistOnly>        # 同上
 * <会心時のみ>        # 行動が会心だった場合のみ副作用を適用
 * <CriticalOnly>      # 同上
 * <反射時のみ>        # 行動が魔法反射された場合のみ副作用を適用
 * <ReflectionOnly>    # 同上
 * <無効時のみ>        # 行動のダメージが0だった場合のみ副作用適用
 * <InvalidOnly>       # 同上
 *
 * 複数指定する場合、[,]で区切ってください。効果の番号が[1]が先頭です。
 * また入力時副作用は敵キャラ専用です。
 *
 * 「成功時のみ」「失敗時のみ」といった条件は、以下のタイミングでは
 * スキルを実行前なので使用できません。
 * 　スキル入力時
 * 　スキル使用前
 * 　ターン開始時
 *
 * スキルの副作用を無効化したい場合は、ステートや装備品のメモ欄に
 * 以下の通り記述します。
 *
 * <スキル副作用無効化_3> # ID[3]のスキルの副作用を無効化
 * <SESkillInvalidate_3> # 同上
 * <アイテム副作用無効化_3> # ID[3]のアイテムの副作用を無効化
 * <SEItemInvalidate_3> # 同上
 * <スキル副作用無効化> # すべてのスキル、アイテムの副作用を無効化
 * <SESkillInvalidate> # 同上
 *
 * 効果「コモンイベント」はタイミングが
 * 「ターン開始時」「スキル使用時」「スキル使用後」「ターン終了時」
 * の場合のみ適切なタイミングで実行されます。
 *
 * ・スクリプト（上級者向け）
 * 副作用でコモンイベントを実行した際、以下のスクリプトで
 * 副作用の対象バトラーを取得できます。
 * $gameTemp.getCommonEventSubjectBattler();
 *
 * このプラグインの利用にはベースプラグイン『PluginCommonBase.js』が必要です。
 * 『PluginCommonBase.js』は、RPGツクールMZのインストールフォルダ配下の
 * 以下のフォルダに格納されています。
 * dlc/BasicResources/plugins/official
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

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

  //=============================================================================
  // DataManager
  //  データベースのロード時にスキルとアイテムの使用効果から副作用対象を抜き取ります。
  //  以下のプロパティを新規で追加します。
  //   sideEffectOnInput  : スキル入力時副作用
  //   sideEffectOnBefore : スキル使用前副作用
  //   sideEffectOnAfter  : スキル使用後副作用
  //   sideEffectOnStart  : ターン開始時副作用
  //   sideEffectOnEnd    : ターン終了時副作用
  //=============================================================================
  const _DataManager_loadDatabase = DataManager.loadDatabase;
  DataManager.loadDatabase = function () {
    this._itemEffectsCategorize = false;
    _DataManager_loadDatabase.apply(this, arguments);
  };

  const _DataManager_isDatabaseLoaded = DataManager.isDatabaseLoaded;
  DataManager.isDatabaseLoaded = function () {
    const result = _DataManager_isDatabaseLoaded.apply(this, arguments);
    if (result && !this._itemEffectsCategorize) {
      this._itemEffectsCategorize = true;
      $dataItems.forEach((item) => this.categorizeItemEffects(item));
      $dataSkills.forEach((item) => this.categorizeItemEffects(item));
    }
    return result;
  };

  DataManager.categorizeItemEffects = function (data) {
    if (!data) return;
    const sideEffectOnEnd = [],
      sideEffectOnUsing = [],
      sideEffectOnBefore = [],
      sideEffectOnStart = [],
      sideEffectOnInput = [],
      sideEffectOnAfter = [];
    const numbersOnInput = this.getSideEffectNumbers(data, [
      "OnSkillInput",
      "スキル入力時",
    ]);
    const numbersOnBefore = this.getSideEffectNumbers(data, [
      "OnSkillBefore",
      "スキル使用前",
    ]);
    const numbersOnUsing = this.getSideEffectNumbers(data, [
      "OnSkillUsing",
      "スキル使用時",
    ]);
    const numbersOnAfter = this.getSideEffectNumbers(data, [
      "OnSkillAfter",
      "スキル使用後",
    ]);
    const numbersOnStart = this.getSideEffectNumbers(data, [
      "OnTurnStart",
      "ターン開始時",
    ]);
    const numbersOnEnd = this.getSideEffectNumbers(data, [
      "OnTurnEnd",
      "ターン終了時",
    ]);
    const effects = data.effects;
    for (let i = 0; i < effects.length; i++) {
      const effectIndex = i + 1;
      if (numbersOnInput.contains(effectIndex)) {
        sideEffectOnInput.push(effects[i]);
        effects[i].sideEffect = true;
      }
      if (numbersOnBefore.contains(effectIndex)) {
        sideEffectOnBefore.push(effects[i]);
        effects[i].sideEffect = true;
      }
      if (numbersOnUsing.contains(effectIndex)) {
        sideEffectOnUsing.push(effects[i]);
        effects[i].sideEffect = true;
      }
      if (numbersOnAfter.contains(effectIndex)) {
        sideEffectOnAfter.push(effects[i]);
        effects[i].sideEffect = true;
      }
      if (numbersOnStart.contains(effectIndex)) {
        sideEffectOnStart.push(effects[i]);
        effects[i].sideEffect = true;
      }
      if (numbersOnEnd.contains(effectIndex)) {
        sideEffectOnEnd.push(effects[i]);
        effects[i].sideEffect = true;
      }
    }
    data.effects = effects.filter((effect) => !effect.sideEffect);
    data.sideEffectOnInput = sideEffectOnInput;
    data.sideEffectOnBefore = sideEffectOnBefore;
    data.sideEffectOnUsing = sideEffectOnUsing;
    data.sideEffectOnAfter = sideEffectOnAfter;
    data.sideEffectOnStart = sideEffectOnStart;
    data.sideEffectOnEnd = sideEffectOnEnd;
  };

  DataManager.getSideEffectNumbers = function (data, names) {
    const metaValue = PluginManagerEx.findMetaValue(data, names);
    if (metaValue) {
      if (metaValue === String(metaValue)) {
        return metaValue.split(",").map((item) => parseInt(item));
      } else {
        return [metaValue];
      }
    }
    return [];
  };

  //=============================================================================
  // BattleManager
  //  ターン開始時に開始時副作用を適用します。
  //=============================================================================
  const _BattleManager_startTurn = BattleManager.startTurn;
  BattleManager.startTurn = function () {
    if (BattleManager.isTpb()) {
      _BattleManager_startTurn.apply(this, arguments);
    } else {
      this.makeActionOrders();
      this._sideEffectBattlers = this._actionBattlers.clone();
      _BattleManager_startTurn.apply(this, arguments);
      this.applyItemSideEffectStart();
    }
  };

  const _BattleManager_endTurn = BattleManager.endTurn;
  BattleManager.endTurn = function () {
    _BattleManager_endTurn.apply(this, arguments);
    if (!BattleManager.isTpb()) {
      if (this._sideEffectBattlers) {
        this.applyItemSideEffectEnd();
      }
    }
  };

  const _BattleManager_startAction = BattleManager.startAction;
  BattleManager.startAction = function () {
    _BattleManager_startAction.apply(this, arguments);
    this._action.applyItemSideEffect("sideEffectOnBefore");
  };

  const _BattleManager_endAction = BattleManager.endAction;
  BattleManager.endAction = function () {
    _BattleManager_endAction.apply(this, arguments);
    if (this._action) {
      this._action.applyItemSideEffect("sideEffectOnAfter");
    }
  };

  BattleManager.applyItemSideEffectStart = function () {
    this._sideEffectBattlers.forEach(function (battler) {
      const number = battler.numActions();
      for (let i = 0; i < number; i++) {
        battler.action(i).applyItemSideEffect("sideEffectOnStart");
      }
    }, this);
  };

  BattleManager.applyItemSideEffectEnd = function () {
    this._sideEffectBattlers.forEach(function (battler) {
      const actions = battler.getEndActions();
      actions.forEach(function (action) {
        action.applyItemSideEffect("sideEffectOnEnd");
      }, this);
      battler.resetEndActions();
    }, this);
  };

  BattleManager.displaySideEffectResult = function (subject) {
    this._logWindow.displaySideEffectResult(subject);
    switch (this._phase) {
      case "input":
      case "turn":
        this._logWindow.waitForLong();
    }
  };

  //=============================================================================
  // Game_Battler
  //  終了した行動を別変数に保持します。
  //=============================================================================
  const _Game_Battler_removeCurrentAction =
    Game_Battler.prototype.removeCurrentAction;
  Game_Battler.prototype.removeCurrentAction = function () {
    const action = this.currentAction();
    if (action) {
      this._endActions = this.getEndActions();
      this._endActions.push(action);
    }
    _Game_Battler_removeCurrentAction.apply(this, arguments);
  };

  Game_Battler.prototype.getEndActions = function () {
    return this._endActions || [];
  };

  Game_Battler.prototype.resetEndActions = function () {
    this._endActions = null;
  };

  const _Game_Battler_onBattleEnd = Game_Battler.prototype.onBattleEnd;
  Game_Battler.prototype.onBattleEnd = function () {
    _Game_Battler_onBattleEnd.apply(this, arguments);
    this.resetEndActions();
  };

  //=============================================================================
  // Game_Enemy
  //  行動入力時に副作用を適用します。
  //=============================================================================
  const _Game_Enemy_makeActions = Game_Enemy.prototype.makeActions;
  Game_Enemy.prototype.makeActions = function () {
    _Game_Enemy_makeActions.apply(this, arguments);
    const number = this.numActions();
    for (let i = 0; i < number; i++) {
      this.action(i).applyItemSideEffect("sideEffectOnInput");
    }
    BattleManager.checkBattleEnd();
  };

  //=============================================================================
  // Game_Action
  //  副作用を適用します。
  //=============================================================================
  const _Game_Action_apply = Game_Action.prototype.apply;
  Game_Action.prototype.apply = function (target) {
    if (this._reflectionTarget) {
      this._reflectionForSideEffect = true;
    }
    _Game_Action_apply.apply(this, arguments);
    this.applyItemSideEffect("sideEffectOnUsing", target);
  };

  const _Game_Action_makeDamageValue = Game_Action.prototype.makeDamageValue;
  Game_Action.prototype.makeDamageValue = function (target, critical) {
    this._criticalForSideEffect = critical;
    return _Game_Action_makeDamageValue.apply(this, arguments);
  };

  const _Game_Action_applyItemUserEffect =
    Game_Action.prototype.applyItemUserEffect;
  Game_Action.prototype.applyItemUserEffect = function (target) {
    _Game_Action_applyItemUserEffect.apply(this, arguments);
    this._successForSideEffect = true;
  };

  const _Game_Action_calcElementRate = Game_Action.prototype.calcElementRate;
  Game_Action.prototype.calcElementRate = function (target) {
    const rate = _Game_Action_calcElementRate.apply(this, arguments);
    if (!BattleManager.isInputting()) {
      if (rate >= 1.1) {
        this._effectiveForSideEffect = true;
      }
      if (rate <= 0.9) {
        this._resistForSideEffect = true;
      }
    }
    return rate;
  };

  const _Game_Action_executeDamage = Game_Action.prototype.executeDamage;
  Game_Action.prototype.executeDamage = function (target, value) {
    if (value === 0) {
      this._invalidForSideEffect = true;
    }
    _Game_Action_executeDamage.apply(this, arguments);
  };

  Game_Action.prototype.applyItemSideEffect = function (
    property,
    target = null
  ) {
    if (!this.isValidSideEffect(property)) {
      return;
    }
    if (!this._applySideEffect) {
      this._applySideEffect = {};
    }
    if (this._applySideEffect[property]) {
      return;
    }
    this._applySideEffect[property] = true;
    if (this.subject() === target) {
      return;
    }
    this.item()[property].forEach(function (effect) {
      this.applyItemEffect(this.subject(), effect);
    }, this);
    this.applyItemSideEffectGlobal(property);
    if (this.isNeedDisplaySideEffect(property)) {
      BattleManager.displaySideEffectResult(this.subject());
      this.subject().result().clear();
    }
  };

  Game_Action.prototype.isValidSideEffect = function (property) {
    if (!this.item() || this.item()[property].length === 0) {
      return false;
    } else {
      return (
        this.isValidSideEffectForSuccess() &&
        this.isValidSideEffectForFailure() &&
        this.isValidSideEffectForEffective() &&
        this.isValidSideEffectForResist() &&
        this.isValidSideEffectForCritical() &&
        this.isValidSideEffectForInvalid() &&
        this.isValidSideEffectForReflection() &&
        this.isValidSideEffectForTag()
      );
    }
  };

  Game_Action.prototype.isValidSideEffectForSuccess = function () {
    return (
      this._successForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), ["HitOnly", "成功時のみ"])
    );
  };

  Game_Action.prototype.isValidSideEffectForFailure = function () {
    return (
      !this._successForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), ["MissOnly", "失敗時のみ"])
    );
  };

  Game_Action.prototype.isValidSideEffectForEffective = function () {
    return (
      this._effectiveForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), [
        "EffectiveOnly",
        "弱点時のみ",
      ])
    );
  };

  Game_Action.prototype.isValidSideEffectForResist = function () {
    return (
      this._resistForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), ["ResistOnly", "耐性時のみ"])
    );
  };

  Game_Action.prototype.isValidSideEffectForCritical = function () {
    return (
      this._criticalForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), [
        "CriticalOnly",
        "会心時のみ",
      ])
    );
  };

  Game_Action.prototype.isValidSideEffectForInvalid = function () {
    return (
      this._invalidForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), ["InvalidOnly", "無効時のみ"])
    );
  };

  Game_Action.prototype.isValidSideEffectForReflection = function () {
    return (
      this._reflectionForSideEffect ||
      !PluginManagerEx.findMetaValue(this.item(), [
        "ReflectionOnly",
        "反射時のみ",
      ])
    );
  };

  Game_Action.prototype.isValidSideEffectForTag = function () {
    const id = this.item().id;
    const allInvalidate = this.subject()
      .traitObjects()
      .some((obj) =>
        PluginManagerEx.findMetaValue(obj, [
          `SESkillInvalidate`,
          `スキル副作用無効化`,
        ])
      );
    if (allInvalidate) {
      return false;
    }
    if (DataManager.isSkill(this.item())) {
      return this.subject()
        .traitObjects()
        .every(
          (obj) =>
            !PluginManagerEx.findMetaValue(obj, [
              `SESkillInvalidate_${id}`,
              `スキル副作用無効化_${id}`,
            ])
        );
    } else {
      return this.subject()
        .traitObjects()
        .every((obj) =>
          PluginManagerEx.findMetaValue(obj, [
            `SEItemInvalidate_${id}`,
            `アイテム副作用無効化_${id}`,
          ])
        );
    }
  };

  Game_Action.prototype.applyItemSideEffectGlobal = function (property) {
    this.item()[property].forEach(function (effect) {
      if (effect.code === Game_Action.EFFECT_COMMON_EVENT) {
        $gameTemp.reserveCommonEvent(effect.dataId);
        $gameTemp.setCommonEventSubject(this.subject());
      }
    }, this);
  };

  Game_Action.prototype.isNeedDisplaySideEffect = function (property) {
    if (!$gameParty.inBattle()) {
      return false;
    }
    return !BattleManager.isTpb() || property !== "sideEffectOnInput";
  };

  //=============================================================================
  // Game_Temp
  //  コモンイベントの予約をスタックします。
  //=============================================================================
  const _Game_Temp_initialize = Game_Temp.prototype.initialize;
  Game_Temp.prototype.initialize = function () {
    _Game_Temp_initialize.apply(this, arguments);
    this._commonEventReserveStack = [];
    this._commonEventSubjects = [];
    this._commonEventSubjectBattler = null;
    this.getCommonEventSubjectBattler();
  };

  const _Game_Temp_reserveCommonEvent = Game_Temp.prototype.reserveCommonEvent;
  Game_Temp.prototype.reserveCommonEvent = function (commonEventId) {
    if (this.isCommonEventReserved()) {
      this._commonEventReserveStack.push(commonEventId);
    } else {
      _Game_Temp_reserveCommonEvent.apply(this, arguments);
    }
  };

  Game_Temp.prototype.setCommonEventSubject = function (battler) {
    this._commonEventSubjects.push(battler);
  };

  const _Game_Temp_clearCommonEvent = Game_Temp.prototype.clearCommonEvent;
  Game_Temp.prototype.clearCommonEvent = function () {
    _Game_Temp_clearCommonEvent.apply(this, arguments);
    if (this._commonEventReserveStack.length > 0) {
      this.reserveCommonEvent(this._commonEventReserveStack.shift());
    }
    if (this._commonEventSubjects.length > 0) {
      this._commonEventSubjectBattler = this._commonEventSubjects.shift();
    } else {
      this._commonEventSubjectBattler = null;
    }
  };

  Game_Temp.prototype.getCommonEventSubjectBattler = function () {
    return this._commonEventSubjectBattler;
  };

  //=============================================================================
  // Window_BattleLog
  //  副作用効果を出力します。
  //=============================================================================
  Window_BattleLog.prototype.displaySideEffectResult = function (subject) {
    this.displayChangedStates(subject);
    this.displayChangedBuffs(subject);
    subject.startDamagePopup();
    if (!$gameSystem.isSideView() && subject.result().used) {
      this.displayDamage(subject);
    }
  };

  Window_BattleLog.prototype.waitForLong = function () {
    if (this.countTextStack() > 0) {
      this.push("waitForSideEffectMessage");
      this.push("clear");
    }
  };

  Window_BattleLog.prototype.waitForSideEffectMessage = function () {
    this._waitCount = 30;
  };

  Window_BattleLog.prototype.countTextStack = function () {
    return this._methods.reduce(function (prevValue, method) {
      return prevValue + (method.name === "addText" ? 1 : 0);
    }, 0);
  };
})();


code:
//=============================================================================
// SimpleSingleActorMenu.js
// ----------------------------------------------------------------------------
// Copyright (c) 2017 n2naokun(柊菜緒)
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.2 2017/10/28 競合が発生しにくいように調整・修正履歴の修正
// 1.1.1 2017/10/25 ステータス画面で余計なキーが反応しないように変更
// 1.1.0 2017/10/22 このプラグインの読み込み状況を他のプラグインからわかるように改修
// 1.0.1 2017/10/21 うっかり並び替えボタンが表示されていたのを修正
// 1.0.0 2017/10/21 初版
// ----------------------------------------------------------------------------
// [Twitter]: https://twitter.com/n2naokun/
// [GitHub] : https://github.com/n2naokun/
//=============================================================================

/*:
 * @plugindesc シンプルなメニュー画面を提供するプラグインです。
 * 恐らく簡易的なシングルアクタープラグインとして動作すると思われます。
 * @author n2naokun(柊菜緒)
 *
 * @help プラグインコマンドなどは有りません。
 * メニューのコマンドのみを画面中央に表示します。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

"use strict"; //厳格なエラーチェック

var Imported = Imported || {};
Imported.SimpleSingleActorMenu = true;

(function (_global) {
  Scene_Menu.prototype.create = function () {
    Scene_MenuBase.prototype.create.call(this);
    this.createCommandWindow();
    this._commandWindow.x =
      Graphics.boxWidth / 2 - this._commandWindow.width / 2;
    this._commandWindow.y =
      Graphics.boxHeight / 2 - this._commandWindow.height / 2;
  };

  Window_MenuCommand.prototype.makeCommandList = function () {
    this.addMainCommands();
    this.addOriginalCommands();
    this.addOptionsCommand();
    this.addSaveCommand();
    this.addGameEndCommand();
  };

  Scene_Menu.prototype.createCommandWindow = function () {
    this._commandWindow = new Window_MenuCommand(0, 0);
    this._commandWindow.setHandler("item", this.commandItem.bind(this));
    this._commandWindow.setHandler("skill", this.onPersonalOk.bind(this));
    this._commandWindow.setHandler("equip", this.onPersonalOk.bind(this));
    this._commandWindow.setHandler("status", this.onPersonalOk.bind(this));
    this._commandWindow.setHandler("options", this.commandOptions.bind(this));
    this._commandWindow.setHandler("save", this.commandSave.bind(this));
    this._commandWindow.setHandler("gameEnd", this.commandGameEnd.bind(this));
    this._commandWindow.setHandler("cancel", this.popScene.bind(this));
    this.commandWindowSetHandler(); // ハンドラセット用関数
    this.addWindow(this._commandWindow);
  };

  Scene_Menu.prototype.start = function () {
    Scene_MenuBase.prototype.start.call(this);
  };

  Scene_ItemBase.prototype.determineItem = function () {
    var action = new Game_Action(this.user());
    var item = this.item();
    action.setItemObject(item);
    this.useItem();
    this.activateItemWindow();
  };

  Scene_ItemBase.prototype.itemTargetActors = function () {
    var action = new Game_Action(this.user());
    action.setItemObject(this.item());
    if (!action.isForFriend()) {
      return [];
    } else if (action.isForAll()) {
      return $gameParty.members();
    } else {
      return $gameParty.members();
    }
  };

  Scene_Status.prototype.create = function () {
    Scene_MenuBase.prototype.create.call(this);
    this._statusWindow = new Window_Status();
    this._statusWindow.setHandler("cancel", this.popScene.bind(this));
    this._statusWindow.reserveFaceImages();
    this.addWindow(this._statusWindow);
  };
})(this);

Scene_Menu.prototype.commandWindowSetHandler = function () {
  // ここをオーバーライドして
  // this._commandWindow.setHandler('シンボル', 呼ばれる関数.bind(this));
  // このように処理を追加すると競合なく追加可能
};

Window_MenuCommand.prototype.addOriginalCommands = function () {
  // ここをオーバーライドすることでメニューにコマンドを追加できます。
};


code:
/*=============================================================================
 StateAfterDeath.js
----------------------------------------------------------------------------
 (C)2018 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.3.0 2022/05/10 全回復実行時もステートが解除されない設定を追加
 1.2.1 2021/09/16 戦闘不能後継続ステートをすでに戦闘不能のバトラーに付与したときにも付与できるよう修正
 1.2.0 2021/08/25 対象ステートを範囲指定できるパラメータを追加
 1.1.0 2021/05/28 MZ用にリファクタリング
 1.0.1 2018/08/12 継続ステートが戦闘不能後にターン数で解除されなくなっていた問題を修正
 1.0.0 2018/08/12 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc StateAfterDeathPlugin
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/StateAfterDeath.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author triacontane
 *
 * @param states
 * @desc 戦闘不能後も継続するステートの配列の一覧です。
 * @type state[]
 * @default []
 *
 * @param stateIdStart
 * @text 対象ステート(範囲設定開始)
 * @desc 戦闘不能後も継続するステートを範囲指定したい場合の開始IDです。
 * @type state
 * @default 0
 *
 * @param stateIdEnd
 * @text 対象ステート(範囲設定終了)
 * @desc 戦闘不能後も継続するステートを範囲指定したい場合の終了IDです。
 * @type state
 * @default 0
 *
 * @param considerRecoverAll
 * @text 全回復を考慮
 * @desc 戦闘不能だけでなく全回復をした場合もステートが解除されず、永続的に付与されるようになります。
 * @type boolean
 * @default false
 *
 * @help StateAfterDeath.js
 *
 * 戦闘不能後も解除されず継続するステートを作成できます。
 * パラメータから対象となるステートを指定してください。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 戦闘不能後継続ステートプラグイン
 * @target MZ
 * @url https://github.com/triacontane/RPGMakerMV/tree/mz_master/StateAfterDeath.js
 * @base PluginCommonBase
 * @orderAfter PluginCommonBase
 * @author トリアコンタン
 *
 * @param states
 * @text 対象ステート
 * @desc 戦闘不能後も継続するステートの配列の一覧です。
 * @type state[]
 * @default []
 *
 * @param stateIdStart
 * @text 対象ステート(範囲設定開始)
 * @desc 戦闘不能後も継続するステートを範囲指定したい場合の開始IDです。
 * @type state
 * @default 0
 *
 * @param stateIdEnd
 * @text 対象ステート(範囲設定終了)
 * @desc 戦闘不能後も継続するステートを範囲指定したい場合の終了IDです。
 * @type state
 * @default 0
 *
 * @param considerRecoverAll
 * @text 全回復を考慮
 * @desc 戦闘不能だけでなく全回復をした場合もステートが解除されず、永続的に付与されるようになります。
 * @type boolean
 * @default false
 *
 * @help StateAfterDeath.js
 *
 * 戦闘不能後も解除されず継続するステートを作成できます。
 * パラメータから対象となるステートを指定してください。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

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

  const _Game_BattlerBase_clearStates = Game_BattlerBase.prototype.clearStates;
  Game_BattlerBase.prototype.clearStates = function () {
    if (!this._states) {
      _Game_BattlerBase_clearStates.apply(this, arguments);
      return;
    }
    const deathStates = this.findStateAfterDeath();
    const stillStates = this._states.filter((stateId) =>
      deathStates.includes(stateId)
    );
    const stillStateTurns = {};
    stillStates.forEach(
      (stateId) => (stillStateTurns[stateId] = this._stateTurns[stateId])
    );
    _Game_BattlerBase_clearStates.apply(this, arguments);
    if (!param.considerRecoverAll && this.hp > 0) {
      return;
    }
    this._states = this._states.concat(stillStates);
    this._stateTurns = stillStateTurns;
  };

  Game_BattlerBase.prototype.findStateAfterDeath = function () {
    const deathStates = param.states.clone();
    for (let id = param.stateIdStart; id <= param.stateIdEnd; id++) {
      deathStates.push(id);
    }
    return deathStates;
  };

  const _Game_BattlerBase_isAlive = Game_BattlerBase.prototype.isAlive;
  Game_BattlerBase.prototype.isAlive = function () {
    const result = _Game_BattlerBase_isAlive.apply(this, arguments);
    return this._ignoreDeath ? true : result;
  };

  const _Game_Battler_isStateAddable = Game_Battler.prototype.isStateAddable;
  Game_Battler.prototype.isStateAddable = function (stateId) {
    const deathStates = this.findStateAfterDeath();
    if (deathStates.includes(stateId)) {
      this._ignoreDeath = true;
    }
    const result = _Game_Battler_isStateAddable.apply(this, arguments);
    this._ignoreDeath = false;
    return result;
  };
})();


code:
//=============================================================================
// TMPlugin - パッシヴスキル
// バージョン: 1.1.1
// 最終更新日: 2017/06/17
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @target MZ MV
 * @url https://raw.githubusercontent.com/munokura/tomoaky-MV-plugins/master/TMPassiveSkill.js
 * @plugindesc 使用せずとも常に効果が発動しつづけるスキルを追加します。
 *
 * @author tomoaky (https://twitter.com/tomoaky/)
 *
 * @param passiveCommands
 * @text 戦闘中非表示スキルタイプ
 * @type string
 * @desc パッシヴスキルのスキルタイプ番号を半角数字で設定します。
 * 複数指定する場合は半角スペースで区切ってください。
 * @default
 *
 * @help
 * TMPlugin - パッシヴスキル ver1.1.1
 *
 * 使い方:
 *
 *   このプラグインは、データベースに設定されているスキルと武器を紐付けて
 *   パッシヴスキルを作成します。
 *   スキルのメモ欄に <passive:50> というタグを書き込むと、
 *   このスキルを習得している間、50 番の武器を装備したときと
 *   同じ効果が得られるようになります。
 *
 *   特徴の『スキル追加』ではパッシヴスキルの効果は適用されません。
 *
 *   パッシヴスキルに必要武器が設定されている場合、該当するタイプの武器を
 *   装備している間だけパッシヴスキルの効果が適用されます。
 *   武器タイプ以外にもメモ欄タグを使ってＴＰやステートを効果適用の条件に
 *   指定することができます。
 *
 *   プラグインコマンドはありません。
 *
 *
 * メモ欄タグ（スキル）:
 *
 *   <passive:50>     # 50 番の武器を効果とするパッシヴスキルになる
 *   <passiveTp:75>   # 残りＴＰが 75 以上のときだけパッシヴ効果が適用される
 *   <passiveTp:-25>  # 残りＴＰが 25 未満のときだけパッシヴ効果が適用される
 *   <passiveState:4> # 4 番のステートが有効なときだけパッシヴ効果が適用される
 *   <passiveTurn:2>  # 戦闘中 2 ターン目にのみパッシヴ効果が適用される
 *
 *   パッシヴ効果はスキルだけでなく装備品に設定することもできます。
 *
 *
 * プラグインパラメータ補足:
 *
 *   passiveCommands を設定すると、該当するスキルタイプはバトル中に
 *   表示されなくなります。
 *   パッシヴスキルのスキルタイプ番号を指定すれば、コマンドからパッシヴスキルを
 *   除外することができます。
 *
 *
 * 利用規約:
 *   MITライセンスです。
 *   https://ja.osdn.net/projects/opensource/wiki/licenses%2FMIT_license
 *   作者に無断で改変、再配布が可能で、
 *   利用形態（商用、18禁利用等）についても制限はありません。
 */

var Imported = Imported || {};
Imported.TMPassiveSkill = true;

(function () {
  "use strict";

  var parameters = PluginManager.parameters("TMPassiveSkill");
  var passiveCommands = parameters["passiveCommands"].split("").map(Number);

  //-----------------------------------------------------------------------------
  // Game_Actor
  //

  var _Game_Actor_paramPlus = Game_Actor.prototype.paramPlus;
  Game_Actor.prototype.paramPlus = function (paramId) {
    var passiveWeapons = this.passiveWeapons();
    return passiveWeapons.reduce(function (r, weapon) {
      return r + weapon.params[paramId];
    }, _Game_Actor_paramPlus.call(this, paramId));
  };

  var _Game_Actor_traitObjects = Game_Actor.prototype.traitObjects;
  Game_Actor.prototype.traitObjects = function () {
    var objects = _Game_Actor_traitObjects.call(this);
    var passiveWeapons = this.passiveWeapons();
    for (var i = 0; i < passiveWeapons.length; i++) {
      objects.push(passiveWeapons[i]);
    }
    return objects;
  };

  Game_Actor.prototype.passiveWeapons = function () {
    var result = [];
    var objects = this.equips();
    this._skills.forEach(function (id) {
      objects.push($dataSkills[id]);
    }, this);
    objects.forEach(function (item) {
      if (item && !result.contains(item)) {
        var passiveWeapon = this.passiveWeapon(item);
        if (passiveWeapon) result.push(passiveWeapon);
      }
    }, this);
    return result;
  };

  Game_Actor.prototype.passiveWeapon = function (item) {
    if (
      item.meta.passive &&
      this.isPassiveSkillTpOk(item) &&
      this.isPassiveSkillStateOk(item) &&
      this.isPassiveSkillTurnOk(item) &&
      (!DataManager.isSkill(item) || this.isSkillWtypeOk(item))
    ) {
      return $dataWeapons[+item.meta.passive];
    }
    return null;
  };

  Game_Actor.prototype.isPassiveSkillTpOk = function (item) {
    if (item.meta.passiveTp) {
      var n = +item.meta.passiveTp;
      var tp = this.tp;
      if ((n > 0 && n > tp) || (n < 0 && -n <= tp)) return false;
    }
    return true;
  };

  Game_Actor.prototype.isPassiveSkillStateOk = function (item) {
    if (item.meta.passiveState) {
      return this.isStateAffected(+item.meta.passiveState);
    }
    return true;
  };

  Game_Actor.prototype.isPassiveSkillTurnOk = function (item) {
    if (item.meta.passiveTurn) {
      return (
        $gameParty.inBattle() &&
        $gameTroop.turnCount() === +item.meta.passiveTurn
      );
    }
    return true;
  };

  Game_Actor.prototype.addedSkillTypes = function () {
    var skillTypes = Game_BattlerBase.prototype.addedSkillTypes.call(this);
    if ($gameParty.inBattle()) {
      for (var i = 0; i < skillTypes.length; i++) {
        if (passiveCommands.contains(skillTypes[i])) {
          skillTypes.splice(i--, 1);
        }
      }
    }
    return skillTypes;
  };
})();


code:
//=============================================================================
// TMPlugin - リージョン通行設定
// バージョン: 1.0.0
// 最終更新日: 2018/03/02
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2018 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @target MZ MV
 * @url https://raw.githubusercontent.com/munokura/tomoaky-MV-plugins/master/TMRegionPassable.js
 * @author tomoaky (https://twitter.com/tomoaky/)
 * @plugindesc その場所が通行可能かどうかをリージョンで設定できるようになります。
 *
 * @param passableRegions
 * @text 通行可能リージョン
 * @type string
 * @desc タイルに関係なく通行を可能にするリージョン番号。
 * 半角スペース区切りで複数設定
 * 初期値: 251
 * @default 251
 *
 * @param dontPassRegions
 * @text 通行不可リージョン
 * @type string
 * @desc タイルに関係なく通行を不可にするリージョン番号。
 * 半角スペース区切りで複数設定
 * 初期値: 252 253
 * @default 252 253
 *
 * @param counterRegions
 * @text カウンター属性リージョン
 * @type string
 * @desc カウンター属性をもたせるリージョン番号。
 * 半角スペース区切りで複数設定
 * 初期値: 253
 * @default 253
 *
 * @help
 * TMPlugin - リージョン通行設定 ver1.0.0
 *
 * 使い方:
 *
 *   プラグインパラメータで通行可能リージョンと通行不可リージョンの番号を
 *   それぞれ設定してください。
 *   これらのリージョンが付加された場所ではタイルによる通行判定を実行せず、
 *   リージョンでのみ通行できるかどうかが決まります。
 *
 *   また、リージョン番号を半角スペースで区切って複数設定することで
 *   複数のリージョンに通行設定を適用できます。
 *
 *   プラグインコマンドはありません。
 *
 *
 * 利用規約:
 *   MITライセンスです。
 *   https://ja.osdn.net/projects/opensource/wiki/licenses%2FMIT_license
 *   作者に無断で改変、再配布が可能で、
 *   利用形態（商用、18禁利用等）についても制限はありません。
 */

var Imported = Imported || {};
Imported.TMRegionPassable = true;

(function () {
  "use strict";

  var parameters = PluginManager.parameters("TMRegionPassable");
  var passableRegions = (parameters["passableRegions"] || "251")
    .split(" ")
    .map(Number);
  var dontPassRegions = (parameters["dontPassRegions"] || "252 253")
    .split(" ")
    .map(Number);
  var counterRegions = (parameters["counterRegions"] || "253")
    .split(" ")
    .map(Number);

  //-----------------------------------------------------------------------------
  // Game_Map
  //

  var _Game_Map_checkPassage = Game_Map.prototype.checkPassage;
  Game_Map.prototype.checkPassage = function (x, y, bit) {
    var regionId = this.regionId(x, y);
    if (passableRegions.indexOf(regionId) >= 0) return true;
    if (dontPassRegions.indexOf(regionId) >= 0) return false;
    return _Game_Map_checkPassage.call(this, x, y, bit);
  };

  var _Game_Map_isCounter = Game_Map.prototype.isCounter;
  Game_Map.prototype.isCounter = function (x, y) {
    var regionId = this.regionId(x, y);
    if (counterRegions.indexOf(regionId) >= 0) return true;
    return _Game_Map_isCounter.call(this, x, y);
  };
})();