code:
//=============================================================================
// InputForm.js
// PUBLIC DOMAIN
// ----------------------------------------------------------------------------
// 2017/09/03 iOSで「決定」ボタンを押せないバグを修正＆裏のゲーム画面のクリックを無効に
// 2018/12/06 入力欄の大きさを画面サイズに追従＆iPhoneで画面がズレるバグ修正＆文字サイズ設定＆初期値設定
//=============================================================================

/*:
 * @plugindesc フォーム作って文字入力（修正版）
 * @author １１１, くらむぼん
 *
 *
 * @help InputForm x=350;y=200;v=11;max=5;
 * みたいな感じで。この例だとx350,y200の位置に表示、結果を11番の変数に保存。
 * 最大文字数は5（maxは省略すれば無制限にもできる）
 *
 * 時間切れなどを作りたい時は、if_s=3;を付けると
 * ”スイッチ３がONになった場合”に強制終了できます
 * 並列イベントの中で、スイッチ３をONにするイベントを作りましょう
 * （ハマリポイント１）なおこの際、強制終了した瞬間の
 * テキストが結果の変数にしっかり保存されていることに注意。
 *
 * index.htmlと同じ場所にcssフォルダを作ってそこに111_InputForm.cssを入れること。
 * このファイルをいじって文字の大きさや、ウィンドウのデザイン・幅とかも変えられる
 * いじり方がわからなかったら「css 書き方」などで検索だ！
 *
 * 入力が終わるまで次のイベントコマンドは読み込みません
 * （ハマリポイント２）次のイベントコマンドの読み込みまでは
 * 少し間があるため結果の変数を他の並列処理で上書きしないよう注意。
 *
 *
 * 機能追加：
 * Inputform （中略）btn_x=100;btn_y=100;
 * という書き方で、「決定」ボタンの位置を細かく調整できるようにしました。
 * 値はテキストボックスからの相対位置で、デフォルトはbtn_x=0;btn_y=50;です。
 *
 * （2018/12/06追加）
 * 入力欄や決定ボタンの縮尺が画面の縮尺に合わせて伸び縮みするようになりました。
 *
 * Inputform （中略）font_size=30;
 * で入力欄・決定ボタンの文字の大きさを変更できます。
 * font_sizeを指定しなければfont_size=24になります。
 *
 * Inputform （中略）placeholder=文章;
 * で「文章」の内容を最初から入力欄に表示しておくことができます。
 * デフォルトネームを設定しておく場合などにご利用ください。
 * なお、placeholder=$;と指定すると変数vに入っている内容が表示されます。
 *
 * ライセンス：
 * このプラグインの利用法に制限はありません。お好きなようにどうぞ。
 */
(function () {
  function stopPropagation(event) {
    event.stopPropagation();
  }

  // css追加
  (function () {
    var css = document.createElement("link");
    css.rel = "stylesheet";
    css.type = "text/css";
    css.href = "./css/111_InputForm.css";
    var b_top = document.getElementsByTagName("head")[0];
    b_top.appendChild(css);
  })();
  // キー入力不可にする為に
  Input.form_mode = false;
  var _Input_onKeyDown = Input._onKeyDown;
  Input._onKeyDown = function (event) {
    if (Input.form_mode) return;
    _Input_onKeyDown.call(this, event);
  };
  var _Input_onKeyUp = Input._onKeyUp;
  Input._onKeyUp = function (event) {
    if (Input.form_mode) return;
    _Input_onKeyUp.call(this, event);
  };
  // 入力終わるまで次のイベントコマンド読み込まない
  var _Game_Interpreter_updateWaitMode =
    Game_Interpreter.prototype.updateWaitMode;
  Game_Interpreter.prototype.updateWaitMode = function () {
    if (this._waitMode == "input_form") return true;
    return _Game_Interpreter_updateWaitMode.call(this);
  };

  HTMLElement.prototype.postionAdjust = function (
    screen_postion,
    target_postion,
    unitFontSize
  ) {
    this.style.left =
      screen_postion[0] + target_postion[0] * Graphics._realScale + "px";
    this.style.top =
      screen_postion[1] + target_postion[1] * Graphics._realScale + "px";
    this.style.fontSize = unitFontSize * Graphics._realScale + "px";
    this.style.maxWidth = "calc(100% - " + this.style.left + ")";
    this.style.maxHeight = "calc(100% - " + this.style.top + ")";
  };
  // 引数のx=350;y=200;みたいなのを可能にする
  var argHash = function (text, arg_names) {
    var _args = new Array(arg_names.length);
    var ary = text.split(";");
    ary.forEach(function (str) {
      var s_ary = str.split("=");
      var prop = s_ary[0].toLowerCase();
      var value = s_ary[1];
      _args[arg_names.indexOf(prop)] = value;
    });
    return _args;
  };
  //=============================================================================
  // Game_Interpreter - register plugin commands
  //=============================================================================
  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "InputForm") {
      console.log(args);
      var _ary = argHash(args[0], [
        "x",
        "y",
        "v",
        "max",
        "if_s",
        "btn_x",
        "btn_y",
        "font_size",
        "placeholder",
      ]);
      var target_x = +_ary[0];
      var target_y = +_ary[1];
      var variables_id = +_ary[2];
      var max_count = _ary[3] || null;
      var if_switch_id = 50;
      var button_x = +_ary[5] || 0;
      var button_y = _ary[6] === "" || isNaN(_ary[6]) ? 50 : +_ary[6];
      var unitFontSize = _ary[7] === "" || isNaN(_ary[7]) ? 24 : +_ary[7];
      var placeholder = _ary[8].replace(/__/g, " ");

      var interpreter = this;
      var gui = {
        input: null,
        submit: null,
        is_pc: true,
        init: function () {
          this.is_pc = Utils.isNwjs();
          this.create();
          this.input.focus();
          this.screenAdjust();
        },
        create: function () {
          // 入力フォーム
          this.input = document.createElement("input");
          this.input.setAttribute("id", "_111_input");
          if (max_count) this.input.setAttribute("maxlength", max_count);

          if (placeholder === "$") {
            placeholder = $gameVariables.value(variables_id);
          }
          this.input.setAttribute("value", placeholder || "");
          document.body.appendChild(this.input);
          // 送信ボタン
          this.submit = document.createElement("input");
          this.submit.setAttribute("type", "submit");
          this.submit.setAttribute("id", "_111_submit");
          let label1 = "決定";
          let label2 = "キャンセル";
          switch ($gameVariables.value(1999)) {
            case 1:
            case 2:
              label1 = "OK";
              label2 = "CANCEL";
              break;
          }
          this.submit.setAttribute("value", label1);
          document.body.appendChild(this.submit);

          // Cancel Button (キャンセルボタン)
          this._cancel = document.createElement("input");
          this._cancel.setAttribute("type", "submit");
          this._cancel.setAttribute("id", "_111_submit");
          this._cancel.setAttribute("value", label2);
          document.body.appendChild(this._cancel);
        },
        success: function () {
          $gameVariables.setValue(variables_id, this.input.value);
          this.end();
        },
        cancel: function () {
          $gameVariables.setValue(variables_id, placeholder);
          this.end();
        },
        start: function () {
          interpreter.setWaitMode("input_form");
          Input.clear();
          Input.form_mode = true;
          // SceneManager._scene.stop();
        },
        end: function () {
          this.input.remove(); // document.body.removeChild(this.input);
          this.submit.remove();
          this._cancel.remove();
          window.removeEventListener("resize", resizeEvent, false);
          interpreter.setWaitMode("");
          Input.form_mode = false;
          clearInterval(_event);
          // SceneManager._scene.start();
        },
        screenAdjust: function () {
          // canvasの左上を基準にした位置に合わせる
          var screen_x, screen_y;
          var _canvas = document.querySelector("#UpperCanvas");
          var rect = _canvas.getBoundingClientRect();
          screen_x = rect.left;
          screen_y = rect.top;
          this.input.postionAdjust(
            [screen_x, screen_y],
            [target_x, target_y],
            unitFontSize
          );
          this.submit.postionAdjust(
            [screen_x, screen_y],
            [target_x + button_x, target_y + button_y],
            unitFontSize
          );
          this._cancel.postionAdjust(
            [screen_x, screen_y],
            [target_x + button_x + 100, target_y + button_y],
            unitFontSize
          );
        },
      };
      //
      console.log(gui);
      gui.init();
      // 送信するイベントgui.input.onkeydown = function(e){
      gui.input.addEventListener("keydown", function (e) {
        if (e.keyCode === 13) {
          // 決定キーで送信
          Input.clear();
          gui.success();
          // 親へのイベント伝播を止める（documentのkeydownが反応しないように）
          e.stopPropagation();
        }
        if (e.keyCode === 27) {
          Input.clear();
          gui.cancel();
          // 親へのイベント伝播を止める（documentのkeydownが反応しないように）
          e.stopPropagation();
        }
      });
      gui.input.addEventListener("mousedown", stopPropagation); // 裏のゲーム画面のクリック暴発を防ぐ
      gui.input.addEventListener("touchstart", stopPropagation); // iOSでclickイベント取れない対策
      gui.submit.addEventListener("mousedown", stopPropagation); // 裏のゲーム画面のクリック暴発を防ぐ
      gui.submit.addEventListener("touchstart", stopPropagation); // iOSでclickイベント取れない対策
      gui.submit.addEventListener("click", function () {
        // 送信ボタンクリック
        gui.success();
        return false;
      });
      gui._cancel.addEventListener("mousedown", stopPropagation); // 裏のゲーム画面のクリック暴発を防ぐ
      gui._cancel.addEventListener("touchstart", stopPropagation); // iOSでclickイベント取れない対策
      gui._cancel.addEventListener("click", function () {
        // 送信ボタンクリック
        gui.cancel();
        return false;
      });
      // キャンセルするイベント
      if (if_switch_id) {
        var _event = setInterval(function () {
          if ($gameSwitches.value(if_switch_id)) {
            // clearInterval(_event);
            gui.cancel();
          }
        }, 1);
      }

      // webではウィンドー大きさ変わる度に%求め直すイベントもいる
      //if(! gui.is_pc){
      var resizeEvent = gui.screenAdjust.bind(gui);
      window.addEventListener("resize", resizeEvent, false);
      //}
      //
      gui.start();
    }
  };
})();


code:
//=============================================================================
// ItemBook.js
//=============================================================================

/*:
 * @plugindesc Displays detailed statuses of items.
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc The index name for an unknown item.
 * @default ??????
 *
 * @param Price Text
 * @desc The text for "Price".
 * @default Price
 *
 * @param Equip Text
 * @desc The text for "Equip".
 * @default Equip
 *
 * @param Type Text
 * @desc The text for "Type".
 * @default Type
 *
 * @help
 *
 * Plugin Command:
 *   ItemBook open            # Open the item book screen
 *   ItemBook add weapon 3    # Add weapon #3 to the item book
 *   ItemBook add armor 4     # Add armor #4 to the item book
 *   ItemBook remove armor 5  # Remove armor #5 from the item book
 *   ItemBook remove item 6   # Remove item #6 from the item book
 *   ItemBook complete        # Complete the item book
 *   ItemBook clear           # Clear the item book
 *
 * Item (Weapon, Armor) Note:
 *   <book:no>                # This item does not appear in the item book
 */

/*:ja
 * @plugindesc アイテム図鑑です。アイテムの詳細なステータスを表示します。
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc 未確認のアイテムの索引名です。
 * @default ？？？？？？
 *
 * @param Price Text
 * @desc 「価格」の文字列です。
 * @default 価格
 *
 * @param Equip Text
 * @desc 「装備」の文字列です。
 * @default 装備
 *
 * @param Type Text
 * @desc 「タイプ」の文字列です。
 * @default タイプ
 *
 * @help
 *
 * プラグインコマンド:
 *   ItemBook open            # 図鑑画面を開く
 *   ItemBook add weapon 3    # 武器３番を図鑑に追加
 *   ItemBook add armor 4     # 防具４番を図鑑に追加
 *   ItemBook remove armor 5  # 防具５番を図鑑から削除
 *   ItemBook remove item 6   # アイテム６番を図鑑から削除
 *   ItemBook complete        # 図鑑を完成させる
 *   ItemBook clear           # 図鑑をクリアする
 *
 * アイテム（武器、防具）のメモ:
 *   <book:no>                # 図鑑に載せない場合
 */

(function () {
  var parameters = PluginManager.parameters("ItemBook");
  var unknownData = String(parameters["Unknown Data"] || "??????");
  var priceText = String(parameters["Price Text"] || "Price");
  var equipText = String(parameters["Equip Text"] || "Equip");
  var typeText = String(parameters["Type Text"] || "Type");

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "ItemBook") {
      switch (args[0]) {
        case "open":
          SceneManager.push(Scene_ItemBook);
          break;
        case "add":
          $gameSystem.addToItemBook(args[1], Number(args[2]));
          break;
        case "remove":
          $gameSystem.removeFromItemBook(args[1], Number(args[2]));
          break;
        case "complete":
          $gameSystem.completeItemBook();
          break;
        case "clear":
          $gameSystem.clearItemBook();
          break;
      }
    }
  };

  Game_System.prototype.addToItemBook = function (type, dataId) {
    if (!this._ItemBookFlags) {
      this.clearItemBook();
    }
    var typeIndex = this.itemBookTypeToIndex(type);
    if (typeIndex >= 0) {
      this._ItemBookFlags[typeIndex][dataId] = true;
    }
  };

  Game_System.prototype.removeFromItemBook = function (type, dataId) {
    if (this._ItemBookFlags) {
      var typeIndex = this.itemBookTypeToIndex(type);
      if (typeIndex >= 0) {
        this._ItemBookFlags[typeIndex][dataId] = false;
      }
    }
  };

  Game_System.prototype.itemBookTypeToIndex = function (type) {
    switch (type) {
      case "item":
        return 0;
      case "weapon":
        return 1;
      case "armor":
        return 2;
      default:
        return -1;
    }
  };

  Game_System.prototype.completeItemBook = function () {
    var i;
    this.clearItemBook();
    for (i = 1; i < $dataItems.length; i++) {
      this._ItemBookFlags[0][i] = true;
    }
    for (i = 1; i < $dataWeapons.length; i++) {
      this._ItemBookFlags[1][i] = true;
    }
    for (i = 1; i < $dataArmors.length; i++) {
      this._ItemBookFlags[2][i] = true;
    }
  };

  Game_System.prototype.clearItemBook = function () {
    this._ItemBookFlags = [[], [], []];
  };

  Game_System.prototype.isInItemBook = function (item) {
    if (this._ItemBookFlags && item) {
      var typeIndex = -1;
      if (DataManager.isItem(item)) {
        typeIndex = 0;
      } else if (DataManager.isWeapon(item)) {
        typeIndex = 1;
      } else if (DataManager.isArmor(item)) {
        typeIndex = 2;
      }
      if (typeIndex >= 0) {
        return !!this._ItemBookFlags[typeIndex][item.id];
      } else {
        return false;
      }
    } else {
      return false;
    }
  };

  var _Game_Party_gainItem = Game_Party.prototype.gainItem;
  Game_Party.prototype.gainItem = function (item, amount, includeEquip) {
    _Game_Party_gainItem.call(this, item, amount, includeEquip);
    if (item && amount > 0) {
      var type;
      if (DataManager.isItem(item)) {
        type = "item";
      } else if (DataManager.isWeapon(item)) {
        type = "weapon";
      } else if (DataManager.isArmor(item)) {
        type = "armor";
      }
      $gameSystem.addToItemBook(type, item.id);
    }
  };

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

  Scene_ItemBook.prototype = Object.create(Scene_MenuBase.prototype);
  Scene_ItemBook.prototype.constructor = Scene_ItemBook;

  Scene_ItemBook.prototype.initialize = function () {
    Scene_MenuBase.prototype.initialize.call(this);
  };

  Scene_ItemBook.prototype.create = function () {
    Scene_MenuBase.prototype.create.call(this);
    this._indexWindow = new Window_ItemBookIndex(0, 0);
    this._indexWindow.setHandler("cancel", this.popScene.bind(this));
    var wy = this._indexWindow.height;
    var ww = Graphics.boxWidth;
    var wh = Graphics.boxHeight - wy;
    this._statusWindow = new Window_ItemBookStatus(0, wy, ww, wh);
    this.addWindow(this._indexWindow);
    this.addWindow(this._statusWindow);
    this._indexWindow.setStatusWindow(this._statusWindow);
  };

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

  Window_ItemBookIndex.prototype = Object.create(Window_Selectable.prototype);
  Window_ItemBookIndex.prototype.constructor = Window_ItemBookIndex;

  Window_ItemBookIndex.lastTopRow = 0;
  Window_ItemBookIndex.lastIndex = 0;

  Window_ItemBookIndex.prototype.initialize = function (x, y) {
    var width = Graphics.boxWidth;
    var height = this.fittingHeight(6);
    Window_Selectable.prototype.initialize.call(this, x, y, width, height);
    this.refresh();
    this.setTopRow(Window_ItemBookIndex.lastTopRow);
    this.select(Window_ItemBookIndex.lastIndex);
    this.activate();
  };

  Window_ItemBookIndex.prototype.maxCols = function () {
    return 3;
  };

  Window_ItemBookIndex.prototype.maxItems = function () {
    return this._list ? this._list.length : 0;
  };

  Window_ItemBookIndex.prototype.setStatusWindow = function (statusWindow) {
    this._statusWindow = statusWindow;
    this.updateStatus();
  };

  Window_ItemBookIndex.prototype.update = function () {
    Window_Selectable.prototype.update.call(this);
    this.updateStatus();
  };

  Window_ItemBookIndex.prototype.updateStatus = function () {
    if (this._statusWindow) {
      var item = this._list[this.index()];
      this._statusWindow.setItem(item);
    }
  };

  Window_ItemBookIndex.prototype.refresh = function () {
    var i, item;
    this._list = [];
    for (i = 1; i < $dataItems.length; i++) {
      item = $dataItems[i];
      if (item.name && item.itypeId === 1 && item.meta.book !== "no") {
        this._list.push(item);
      }
    }
    for (i = 1; i < $dataWeapons.length; i++) {
      item = $dataWeapons[i];
      if (item.name && item.meta.book !== "no") {
        this._list.push(item);
      }
    }
    for (i = 1; i < $dataArmors.length; i++) {
      item = $dataArmors[i];
      if (item.name && item.meta.book !== "no") {
        this._list.push(item);
      }
    }
    this.createContents();
    this.drawAllItems();
  };

  Window_ItemBookIndex.prototype.drawItem = function (index) {
    var item = this._list[index];
    var rect = this.itemRect(index);
    var width = rect.width - this.textPadding();
    if ($gameSystem.isInItemBook(item)) {
      this.drawItemName(item, rect.x, rect.y, width);
    } else {
      var iw = Window_Base._iconWidth + 4;
      this.drawText(unknownData, rect.x + iw, rect.y, width - iw);
    }
  };

  Window_ItemBookIndex.prototype.processCancel = function () {
    Window_Selectable.prototype.processCancel.call(this);
    Window_ItemBookIndex.lastTopRow = this.topRow();
    Window_ItemBookIndex.lastIndex = this.index();
  };

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

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

  Window_ItemBookStatus.prototype.initialize = function (x, y, width, height) {
    Window_Base.prototype.initialize.call(this, x, y, width, height);
  };

  Window_ItemBookStatus.prototype.setItem = function (item) {
    if (this._item !== item) {
      this._item = item;
      this.refresh();
    }
  };

  Window_ItemBookStatus.prototype.refresh = function () {
    var item = this._item;
    var x = 0;
    var y = 0;
    var lineHeight = this.lineHeight();

    this.contents.clear();

    if (!item || !$gameSystem.isInItemBook(item)) {
      return;
    }

    this.drawItemName(item, x, y);

    x = this.textPadding();
    y = lineHeight + this.textPadding();

    var price = item.price > 0 ? item.price : "-";
    this.changeTextColor(this.systemColor());
    this.drawText(priceText, x, y, 120);
    this.resetTextColor();
    this.drawText(price, x + 120, y, 120, "right");
    y += lineHeight;

    if (DataManager.isWeapon(item) || DataManager.isArmor(item)) {
      var etype = $dataSystem.equipTypes[item.etypeId];
      this.changeTextColor(this.systemColor());
      this.drawText(equipText, x, y, 120);
      this.resetTextColor();
      this.drawText(etype, x + 120, y, 120, "right");
      y += lineHeight;

      var type;
      if (DataManager.isWeapon(item)) {
        type = $dataSystem.weaponTypes[item.wtypeId];
      } else {
        type = $dataSystem.armorTypes[item.atypeId];
      }
      this.changeTextColor(this.systemColor());
      this.drawText(typeText, x, y, 120);
      this.resetTextColor();
      this.drawText(type, x + 120, y, 120, "right");

      x = this.textPadding() + 300;
      y = lineHeight + this.textPadding();
      for (var i = 2; i < 8; i++) {
        this.changeTextColor(this.systemColor());
        this.drawText(TextManager.param(i), x, y, 160);
        this.resetTextColor();
        this.drawText(item.params[i], x + 160, y, 60, "right");
        y += lineHeight;
      }
    }

    x = 0;
    y = this.textPadding() * 2 + lineHeight * 7;
    this.drawTextEx(item.description, x, y);
  };
})();

repo_name: Idkwtcm/violated

license: unknown


code:
//===================================================================
//ItemTrigger.js
//アイテム使用でイベント実行プラグイン
//===================================================================
//Copyright (c) 2017 蔦森くいな
//Released under the MIT license.
//http://opensource.org/licenses/mit-license.php
//-------------------------------------------------------------------
//blog   : http://paradre.com/
//Twitter: https://twitter.com/Kuina_T
//===================================================================
//＜更新情報＞
//　ver1.0.0 2017/06/30 初版
//===================================================================

/*:
 * @plugindesc メニュー画面からアイテムを使用して目の前のイベントを実行できます。
 * @author 蔦森くいな
 *
 * @help プラグイン管理画面からパラメータ「ItemId_Variable」に変数番号を設定すると、
 * メニュー画面からアイテムを使用した時、指定した番号の変数に
 * 使用アイテムのIDを代入してから目の前のイベントを実行します。
 *
 * アイテム使用をトリガーに設定したいイベントの実行内容には、
 * プラグインで指定した変数を使った「条件分岐」を設定しておいて下さい。
 * 特定のアイテムを使った時だけ特定の処理を実行するイベントが作成できます。
 *
 * 例）指定した変数の値が「3」の時のみ実行する条件分岐を設定したイベントは、
 * 　　ID「3」のアイテムを目の前で使った時のみ条件分岐の内容を実行します。
 *
 * なお、１つのページのイベント内容の中に複数の条件分岐を設定する事で
 * 「アイテム１を使った時」「アイテム２を使った時」「話しかけられた時」など
 * それぞれの開始トリガーごとに実行内容を分ける事ができます。
 *
 * また、データベースのアイテム使用効果にコモンイベントを設定している場合、
 * アイテム使用対象となるイベントが存在しなければそのコモンイベントを実行し
 * 使用対象となるイベントが存在すればコモンイベントをキャンセルします。
 * これにより、対象イベントが存在しない状況でアイテムを使用した時に
 * 「アイテムを使用したが何も起こらなかった」的な表現が実現できます。
 *
 *
 * ※このプラグインは対象イベントのプライオリティと
 * 　タイルセットのカウンター設定に対応しています。
 * 　通常の「決定ボタン」トリガーと同様の感覚でアイテム使用トリガーが発動します。
 *
 * ※このプラグインで指定した変数はイベント終了時に自動的に値がリセットされます。
 * 　使用アイテムの判定以外の用途に利用する事は推奨されません。
 *
 * @param ItemId_Variable
 * @desc 使用されたアイテムIDを受け取る変数の番号
 * @default 0
 *
 * 利用規約：
 * このプラグインは商用・非商用を問わず無料でご利用いただけます。
 * どのようなゲームに使っても、どのように加工していただいても構いません。
 * MIT Licenseにつき著作権表示とライセンスURLは残しておいて下さい。
 */

(function () {
  "use strict";
  var pd_IT_useVariableId = Number(
    PluginManager.parameters("ItemTrigger")["ItemId_Variable"]
  );
  var pd_IT_Scene_ItemBase_checkCommonEvent =
    Scene_ItemBase.prototype.checkCommonEvent;
  Scene_ItemBase.prototype.checkCommonEvent = function () {
    if (pd_IT_useVariableId != 0) {
      if (
        !this.pd_IT_checkUseItemEvent($gamePlayer._x, $gamePlayer._y, false)
      ) {
        var x = $gameMap.roundXWithDirection(
          $gamePlayer._x,
          $gamePlayer._direction
        );
        var y = $gameMap.roundYWithDirection(
          $gamePlayer._y,
          $gamePlayer._direction
        );
        if (
          !this.pd_IT_checkUseItemEvent(x, y, true) &&
          $gameMap.isCounter(x, y)
        ) {
          var x2 = $gameMap.roundXWithDirection(x, $gamePlayer._direction);
          var y2 = $gameMap.roundYWithDirection(y, $gamePlayer._direction);
          this.pd_IT_checkUseItemEvent(x2, y2, true);
        }
      }
    }
    pd_IT_Scene_ItemBase_checkCommonEvent.call(this);
  };

  Scene_ItemBase.prototype.pd_IT_checkUseItemEvent = function (x, y, normal) {
    if (pd_IT_useVariableId != 0) {
      var useItemId = this._itemWindow.item().id;
      var frontEvents = $gameMap.eventsXy(x, y);

      if (frontEvents.length >= 1) {
        frontEvents.forEach(function (event) {
          if (event.isNormalPriority() === normal && !event._erased) {
            var eventList =
              $dataMap.events[event._eventId].pages[event._pageIndex].list;
            for (var i = 0; i < eventList.length; i++) {
              if (
                eventList[i].code === 111 &&
                eventList[i].parameters[0] === 1
              ) {
                if (eventList[i].parameters[1] === pd_IT_useVariableId) {
                  var variableValue;
                  if (eventList[i].parameters[2] === 0) {
                    variableValue = eventList[i].parameters[3];
                  } else {
                    variableValue = $gameVariables.value(
                      eventList[i].parameters[3]
                    );
                  }
                  if (variableValue === useItemId) {
                    if ($gameTemp.isCommonEventReserved()) {
                      $gameTemp.clearCommonEvent();
                    }
                    $gameVariables.setValue(pd_IT_useVariableId, useItemId);
                    event.start();
                    SceneManager.goto(Scene_Map);
                    return true;
                  }
                }
              }
            }
          }
        });
      }
    }
    return false;
  };

  var pd_IT_Game_Map_isEventRunning = Game_Map.prototype.isEventRunning;
  Game_Map.prototype.isEventRunning = function () {
    if (pd_IT_Game_Map_isEventRunning.call(this)) {
      return true;
    } else {
      if (
        pd_IT_useVariableId != 0 &&
        $gameVariables.value(pd_IT_useVariableId) != 0
      ) {
        $gameVariables.setValue(pd_IT_useVariableId, 0);
      }
      return false;
    }
  };
})();


code:
//=============================================================================
// KMS_AreaEvent.js
//   Last update: 2019/01/01
//=============================================================================

/*:
 * @plugindesc
 * [v0.1.0] Expand the trigger area for events on map.
 *
 * @author Kameo (Kamesoft)
 *
 * @help
 * ## Set trigger area
 *
 *  Add <AreaEvent:WxH> to the comment command which placed top
 *  of the event page, the trigger area is expanded to WxH tiles.
 *  Example: <AreaEvent:3x2>
 *
 */

/*:ja
 * @plugindesc
 * [v0.1.0] マップイベントが起動する範囲を拡張する機能を追加します。
 *
 * @author かめお (Kamesoft)
 *
 * @help
 * ## イベント起動範囲の設定
 *
 * イベントページ先頭に置いた「注釈」に <AreaEvent:WxH> と記述すると、
 * イベント位置を左上として横幅 W、縦幅 H のタイルでイベントが起動する
 * ようになります。
 *  例: <AreaEvent:3x2>
 *
 */

var KMS = KMS || {};

(function () {
  "use strict";

  // 定数
  var Const = {
    debug: false, // デバッグモード
    pluginCode: "AreaEvent", // プラグインコード
  };

  var PluginName = "KMS_" + Const.pluginCode;

  KMS.imported = KMS.imported || {};
  KMS.imported[Const.pluginCode] = true;

  var AreaEvent = {};

  // 正規表現
  AreaEvent.regex = {
    area: /<(?:エリアイベント|AreaEvent)\s*[:\s]\s*(\d+)\s*x\s*(\d+)>/i,
  };

  // エリア定義の原点
  AreaEvent.origin = {
    topLeft: 7,
    topCenter: 8,
    topRight: 9,
    middleLeft: 4,
    middleCenter: 5,
    middleRight: 6,
    bottomLeft: 1,
    bottomCenter: 2,
    bottomRight: 3,
  };

  // デバッグログ
  var debuglog;
  if (Const.debug) {
    debuglog = function () {
      console.log(arguments);
    };
  } else {
    debuglog = function () {};
  }

  // Integer の半分
  function halfInt(value) {
    return Math.floor(value / 2);
  }

  // 位置をエリアイベントの設定に合わせて補正
  function convertPositionForAreaEvent(x, y, area) {
    var width = area.width - 1;
    var height = area.height - 1;

    switch (area.origin) {
      case AreaEvent.origin.topLeft:
        return { x: x, y: y };
      case AreaEvent.origin.topCenter:
        return { x: x - halfInt(width), y: y };
      case AreaEvent.origin.topRight:
        return { x: x - width, y: y };
      case AreaEvent.origin.middleLeft:
        return { x: x, y: y - halfInt(height) };
      case AreaEvent.origin.middleCenter:
        return { x: x - halfInt(width), y: y - halfInt(height) };
      case AreaEvent.origin.middleRight:
        return { x: x - width, y: y - halfInt(height) };
      case AreaEvent.origin.bottomLeft:
        return { x: x, y: y - height };
      case AreaEvent.origin.bottomCenter:
        return { x: x - halfInt(width), y: y - height };
      case AreaEvent.origin.bottomRight:
        return { x: x - width, y: y - height };
      default:
        console.assert("Invalid area origin");
    }
  }

  //-----------------------------------------------------------------------------
  // Game_Event

  var _Game_Event_setupPage = Game_Event.prototype.setupPage;
  Game_Event.prototype.setupPage = function () {
    _Game_Event_setupPage.call(this);

    this.setupAreaEventAttribute();
  };

  /**
   * エリアイベント用属性の設定
   */
  Game_Event.prototype.setupAreaEventAttribute = function () {
    // 初期値はサイズ 1x1
    this._areaEventAttribute = {
      width: 1,
      height: 1,
      origin: AreaEvent.origin.topLeft,
    };

    var isComment = function (command) {
      return command && (command.code === 108 || command.code === 408);
    };

    // 注釈以外に達するまで解析
    var page = this.page();
    if (!page) {
      return;
    }

    var commands = page.list;
    var index = 0;
    var command = commands[index++];
    while (isComment(command)) {
      var comment = command.parameters[0];
      var match = AreaEvent.regex.area.exec(comment);
      if (match) {
        this._areaEventAttribute.width = Math.max(Number(match[1]), 1);
        this._areaEventAttribute.height = Math.max(Number(match[2]), 1);
        debuglog(this._areaEventAttribute);
        break;
      }

      command = commands[index++];
    }
  };

  /**
   * イベントのトリガー位置とサイズを取得 (他プラグイン用)
   *
   * @return {object} イベントのトリガー位置とサイズを格納したオブジェクト
   */
  Game_Event.prototype.getEventTriggerArea = function () {
    var area = this._areaEventAttribute;
    var pos = convertPositionForAreaEvent(this._x, this._y, area);
    return {
      x: pos.x,
      y: pos.y,
      width: area.width,
      height: area.height,
      origin: area.origin,
    };
  };

  Game_Event.prototype.pos = function (x, y) {
    var area = this._areaEventAttribute;
    var pos = convertPositionForAreaEvent(x, y, area);

    return (
      pos.x >= this._x &&
      pos.x < this._x + area.width &&
      pos.y >= this._y &&
      pos.y < this._y + area.height
    );
  };
})();


code:
//=============================================================================
// KMS_MapActiveMessage.js
//   Last update: 2019/08/31
//=============================================================================

/*:
 * @plugindesc
 * [v0.2.0] Show messages automatically for events on map.
 *
 * @author Kameo (Kamesoft)
 *
 * @param Balloon offset Y
 * @default 20
 * @desc Vertical position offset for balloons by pixel.
 *
 * @param Balloon margin
 * @default -8
 * @desc Adjust frame size of balloons by pixel.
 *
 * @param Default range
 * @default 4
 * @desc Default distance for displaying message by tile unit.
 *
 * @param Display duration
 * @default 300
 * @desc Display frame count.
 *
 * @param Max message count
 * @default 10
 * @desc Max number of active messages.
 *
 * @param Message skin
 * @default ActiveMessageSkin
 * @require 1
 * @dir img/system/
 * @type file
 * @desc Message skin for active message. Load from img/system.
 *
 *
 * @help
 *
 * ## Plugin command
 *
 * MapActiveMessage enable      # Enable active message
 * MapActiveMessage disable     # Display active message
 * MapActiveMessage show 10     # Show message of the event whose ID is 10
 * MapActiveMessage show        # Show messages of all events
 *
 */

/*:ja
 * @plugindesc
 * [v0.2.0] プレイヤーが近付いたときに、自動的にメッセージを表示するイベントを作成します。
 *
 * @author かめお (Kamesoft)
 *
 * @param Balloon offset Y
 * @default 20
 * @desc 吹き出しの縦方向の位置をピクセル単位で調整します。
 *
 * @param Balloon margin
 * @default -8
 * @desc 吹き出しの枠サイズをピクセル単位で調整します。
 *
 * @param Default range
 * @default 4
 * @desc メッセージを表示する距離をタイル単位で指定します。
 *
 * @param Display duration
 * @default 300
 * @desc メッセージ表示時間をフレーム単位で指定します。
 *
 * @param Max message count
 * @default 10
 * @desc 表示できるメッセージの最大数です。
 *
 * @param Message skin
 * @default ActiveMessageSkin
 * @require 1
 * @dir img/system/
 * @type file
 * @desc メッセージの表示に使用するスキン画像です。 img/system から読み込みます。
 *
 *
 * @help
 *
 * ■ プラグインコマンド
 *
 * MapActiveMessage enable      # アクティブメッセージを有効にします。
 * MapActiveMessage disable     # アクティブメッセージを無効にします。
 * MapActiveMessage show 10     # イベント ID:10 のメッセージを表示します。
 * MapActiveMessage show        # 全イベントのメッセージを表示します。
 *
 */

var KMS = KMS || {};

(function () {
  "use strict";

  // 定数
  var Const = {
    debug: false, // デバッグモード
    pluginCode: "MapActiveMessage", // プラグインコード
    regex: {
      activeMessage:
        /<(?:アクティブメッセージ|ActiveMessage)\s*[:\s]\s*([^>]+)>/i,
      displayRange:
        /<(?:アクティブメッセージ距離|ActiveMessageRange)\s*[:\s]\s*(\d+)>/i,
      displayDuration:
        /<(?:アクティブメッセージ表示時間|ActiveMessageDuration)\s*[:\s]\s*(\d+)>/i,
      beginMessage: /<(?:アクティブメッセージ開始|BeginActiveMessage)>/i, // * 未使用
      endMessage: /<(?:アクティブメッセージ終了|EndActiveMessage)>/i, // * 未使用
    },

    balloonFrameInfo: { margin: 4, size: 24, lineLength: 48, srcSize: 96 },
    balloonVertexSize: { width: 24, height: 48 },

    // 吹き出しの表示位置
    balloonPosition: { below: 0, above: 1 },
  };

  var PluginName = "KMS_" + Const.pluginCode;

  KMS.imported = KMS.imported || {};
  KMS.imported[Const.pluginCode] = true;

  function isNullOrUndefined(value) {
    return value === null || value === undefined;
  }

  // デフォルト値つきで文字列から int を解析
  function parseIntWithDefault(param, defaultValue) {
    var value = parseInt(param);
    return isNaN(value) ? defaultValue : value;
  }

  var pluginParams = PluginManager.parameters(PluginName);
  var Params = {};
  Params.messageSkin = pluginParams["Message skin"] || "ActiveMessageSkin";
  Params.messageCountMax = Math.max(
    parseIntWithDefault(pluginParams["Max message count"], 8),
    1
  );
  Params.balloonOffsetY = parseIntWithDefault(
    pluginParams["Balloon offset Y"],
    20
  );
  Params.balloonMargin = parseIntWithDefault(
    pluginParams["Balloon margin"],
    -8
  );
  Params.defaultRange = Math.max(
    parseIntWithDefault(pluginParams["Default range"], 4),
    1
  );
  Params.displayDuration = Math.max(
    parseIntWithDefault(pluginParams["Display duration"], 300),
    1
  );
  Params.fadeFrameCount = Math.max(
    parseIntWithDefault(pluginParams["Fade frame count"], 8),
    1
  );
  Params.fontSize = Math.max(
    parseIntWithDefault(pluginParams["Font size"], 18),
    1
  );

  // デバッグログ
  var debuglog;
  if (Const.debug) {
    debuglog = function () {
      console.log(arguments);
    };
  } else {
    debuglog = function () {};
  }

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

    if (command !== Const.pluginCode) {
      return;
    }

    switch (args[0]) {
      case "enable": // 有効化
        $gameSystem.setMapActiveMessageEnabled(true);
        break;

      case "disable": // 無効化
        $gameSystem.setMapActiveMessageEnabled(false);
        break;

      case "show": // 強制表示 (eventId)
        // eventId 省略時 (undefined) は全イベントが対象
        $gameMap.forceDisplayActiveMessage(parseInt(args[1]));
        break;

      default:
        // 不明なコマンド
        console.error("[%s %s] Unknown command.", Const.pluginCode, args[0]);
        break;
    }
  };

  // タイリング描画
  function tileBlt(dstImage, srcImage, sx, sy, sw, sh, dx, dy, dw, dh) {
    for (var offY = 0; offY < dh; offY += sh) {
      for (var offX = 0; offX < dw; offX += sw) {
        var tempSh = Math.min(sh, dh - offY);
        var tempSw = Math.min(sw, dw - offX);
        dstImage.blt(
          srcImage,
          sx,
          sy,
          tempSw,
          tempSh,
          dx + offX,
          dy + offY,
          tempSw,
          tempSh
        );
      }
    }
  }

  //-----------------------------------------------------------------------------
  // Game_Temp

  var _Game_Temp_initialize = Game_Temp.prototype.initialize;
  Game_Temp.prototype.initialize = function () {
    _Game_Temp_initialize.call(this);

    this.clearMapActiveMessage();
  };

  /**
   * アクティブメッセージの登録
   */
  Game_Temp.prototype.pushMapActiveMessage = function (
    text,
    targetEvent,
    isForced
  ) {
    var message = { text: text, event: targetEvent, isForced: !!isForced };
    this._mapActiveMessages.push(message);
  };

  /**
   * アクティブメッセージのクリア
   */
  Game_Temp.prototype.clearMapActiveMessage = function () {
    this._mapActiveMessages = [];
  };

  /**
   * 次のアクティブメッセージを取得
   */
  Game_Temp.prototype.popNextMapActiveMessage = function () {
    return this._mapActiveMessages.shift();
  };

  /**
   * アクティブメッセージが登録されているか
   */
  Game_Temp.prototype.isMapActiveMessageReady = function () {
    return this._mapActiveMessages.length > 0;
  };

  //-----------------------------------------------------------------------------
  // Game_System

  /**
   * アクティブメッセージの有効状態を取得
   */
  Game_System.prototype.isMapActiveMessageEnabled = function () {
    return !isNullOrUndefined(this._mapActiveMessageEnabled)
      ? this._mapActiveMessageEnabled
      : true;
  };

  /**
   * アクティブメッセージの有効状態を設定
   */
  Game_System.prototype.setMapActiveMessageEnabled = function (enabled) {
    this._mapActiveMessageEnabled = !!enabled;
  };

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

  var _Game_Map_setup = Game_Map.prototype.setup;
  Game_Map.prototype.setup = function (mapId) {
    _Game_Map_setup.call(this, mapId);

    this.initializeActiveMessage();
  };

  /**
   * アクティブメッセージの初期化
   */
  Game_Map.prototype.initializeActiveMessage = function () {
    // 最初は全イベントの表示済みフラグを解除
    this.clearActiveMessageShownFlags();
  };

  /**
   * アクティブメッセージの表示済みフラグを解除
   */
  Game_Map.prototype.clearActiveMessageShownFlags = function () {
    this.events().forEach(function (event) {
      event.setMapActiveMessageShown(false);
    });

    this.requestUpdateActiveMessage();
  };

  /**
   * アクティブメッセージの更新要求
   */
  Game_Map.prototype.requestUpdateActiveMessage = function () {
    this._needsUpdateActiveMessage = true;
  };

  var _Game_Map_update = Game_Map.prototype.update;
  Game_Map.prototype.update = function (sceneActive) {
    _Game_Map_update.call(this, sceneActive);

    this.updateDisplayActiveMessage();
  };

  /**
   * アクティブメッセージの表示判定
   */
  Game_Map.prototype.updateDisplayActiveMessage = function () {
    if (!this._needsUpdateActiveMessage) {
      return;
    }

    this._needsUpdateActiveMessage = false;

    // アクティブメッセージの登録
    var events = $gamePlayer.findAvailableMapActiveMessageEvents();
    events.forEach(function (event) {
      $gameTemp.pushMapActiveMessage(event.getMapActiveMessage(), event);
    });
  };

  /**
   * アクティブメッセージの強制表示
   */
  Game_Map.prototype.forceDisplayActiveMessage = function (eventId) {
    var invoker = function (event) {
      $gameTemp.pushMapActiveMessage(event.getMapActiveMessage(), event, true);
    };

    if (isNullOrUndefined(eventId) || isNaN(eventId)) {
      // 全表示
      this.events().forEach(invoker);
    } else {
      // イベント ID 指定
      this.events()
        .filter(function (event) {
          return event.eventId() === eventId;
        })
        .forEach(invoker);
    }
  };

  var _Game_Map_refresh = Game_Map.prototype.refresh;
  Game_Map.prototype.refresh = function () {
    _Game_Map_refresh.call(this);

    this.requestUpdateActiveMessage();
  };

  //-----------------------------------------------------------------------------
  // Game_CharacterBase

  var _Game_CharacterBase = Game_CharacterBase.prototype.setDirection;
  Game_CharacterBase.prototype.setDirection = function (d) {
    _Game_CharacterBase.call(this, d);

    // 移動時には方向指定があるはずなので、ここでメッセージの更新要求を出す
    if (!isNullOrUndefined($gameMap)) {
      $gameMap.requestUpdateActiveMessage();
    }
  };

  //-----------------------------------------------------------------------------
  // Game_Player

  /**
   * アクティブメッセージを表示可能なイベントを探す
   */
  Game_Player.prototype.findAvailableMapActiveMessageEvents = function () {
    if (!this.canMove()) {
      return [];
    }

    // 指定距離内でメッセージ未表示のイベントを列挙
    var candidateEvents = $gameMap.events().filter(function (event) {
      return (
        event.hasMapActiveMessage() &&
        !event.isMapActiveMessageShown() &&
        this.calcDistanceForMapActiveMessage(event) <=
          event.getMapActiveMessageRange()
      );
    }, this);

    // 表示済みフラグの解除判定
    $gameMap.events().forEach(function (event) {
      var distance = this.calcDistanceForMapActiveMessage(event);
      if (event.isMapActiveMessageShown()) {
        // メッセージ表示距離から出ていれば表示済みフラグ解除
        if (distance > event.getMapActiveMessageRange()) {
          event.setMapActiveMessageShown(false);
        }
      }
    }, this);

    return candidateEvents;
  };

  Game_Player.prototype.calcDistanceForMapActiveMessage = function (event) {
    var diffX = this.x - event.x;
    var diffY = this.y - event.y;

    return Math.sqrt(diffX * diffX + diffY * diffY);
  };

  //-----------------------------------------------------------------------------
  // Game_Event

  var _Game_Event_setupPage = Game_Event.prototype.setupPage;
  Game_Event.prototype.setupPage = function () {
    _Game_Event_setupPage.call(this);

    this.setupMapActiveMessage();
  };

  /**
   * 現在のページ番号を取得
   */
  Game_Event.prototype.pageIndex = function () {
    return this._pageIndex;
  };

  /**
   * アクティブメッセージを構築
   */
  Game_Event.prototype.setupMapActiveMessage = function () {
    this._mapActiveMessage = null;
    this._mapActiveMessageRange = Params.defaultRange;
    this._mapActiveMessageDuration = Params.displayDuration;
    this._isMapActiveMessageShown = false;

    // 注釈以外に達するまで解析
    var page = this.page();
    if (isNullOrUndefined(page)) {
      return;
    }

    var isComment = function (command) {
      return command && (command.code === 108 || command.code === 408);
    };

    // 複数行対応のために注釈を結合
    var index = 0;
    var command = page.list[index];
    var comment = "";
    while (isComment(command)) {
      if (comment.length > 0) {
        comment += "\n";
      }
      comment += command.parameters[0];
      command = page.list[++index];
    }

    // メッセージ定義を解析
    var messageMatch = Const.regex.activeMessage.exec(comment);
    if (!isNullOrUndefined(messageMatch)) {
      this._mapActiveMessage = messageMatch[1];
    }

    // メッセージ距離を解析
    var rangeMatch = Const.regex.displayRange.exec(comment);
    if (!isNullOrUndefined(rangeMatch)) {
      this._mapActiveMessageRange = Math.max(
        parseIntWithDefault(rangeMatch[1], Params.defaultRange),
        1
      );
    }

    // メッセージ表示時間を解析
    var durationMatch = Const.regex.displayDuration.exec(comment);
    if (!isNullOrUndefined(durationMatch)) {
      this._mapActiveMessageDuration = parseIntWithDefault(
        durationMatch[1],
        Params.displayDuration
      );
    }
  };

  /**
   * アクティブメッセージを取得
   *
   * @return {String} メッセージ
   */
  Game_Event.prototype.getMapActiveMessage = function () {
    return this._mapActiveMessage.replace(/_/g, ' ');
  };

  /**
   * アクティブメッセージが存在するか
   *
   * @return {Boolean} true if exists
   */
  Game_Event.prototype.hasMapActiveMessage = function () {
    return !isNullOrUndefined(this._mapActiveMessage);
  };

  /**
   * アクティブメッセージを表示可能な範囲
   *
   * @return {Number} タイル単位の表示範囲半径
   */
  Game_Event.prototype.getMapActiveMessageRange = function () {
    return this._mapActiveMessageRange;
  };

  /**
   * アクティブメッセージを表示するフレーム数
   *
   * @return {Number} 自動消去するまでのフレーム数
   */
  Game_Event.prototype.getMapActiveMessageDuration = function () {
    return this._mapActiveMessageDuration;
  };

  /**
   * アクティブメッセージを表示済みか
   *
   * @return {Boolean} true if shown
   */
  Game_Event.prototype.isMapActiveMessageShown = function () {
    return this._isMapActiveMessageShown;
  };

  /**
   * アクティブメッセージ表示済みかどうかを設定
   *
   * @param {Boolean} shown 設定する値
   */
  Game_Event.prototype.setMapActiveMessageShown = function (shown) {
    this._isMapActiveMessageShown = !!shown;
  };

  //-----------------------------------------------------------------------------
  // Sprite_MapActiveMessageBalloon
  //
  // アクティブメッセージの吹き出し用スプライト

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

  Sprite_MapActiveMessageBalloon.prototype = Object.create(
    Sprite_Base.prototype
  );
  Sprite_MapActiveMessageBalloon.prototype.constructor =
    Sprite_MapActiveMessageBalloon;

  Sprite_MapActiveMessageBalloon.prototype.initialize = function () {
    Sprite_Base.prototype.initialize.call(this);

    this.anchor.y = 0.5;
    this.initMembers();
  };

  Sprite_MapActiveMessageBalloon.prototype.initMembers = function () {
    this._owner = null;
  };

  /**
   * オーナーウィンドウの設定
   */
  Sprite_MapActiveMessageBalloon.prototype.setOwner = function (owner) {
    this._owner = owner;
  };

  /**
   * 位置をオーナーウィンドウに合わせる
   */
  Sprite_MapActiveMessageBalloon.prototype.followOwner = function () {
    this.y = this._owner.height / 2;
  };

  /**
   * サイズをオーナーウィンドウに合わせる
   */
  Sprite_MapActiveMessageBalloon.prototype.fitToOwner = function () {
    if (isNullOrUndefined(this._owner)) {
      return;
    }

    var frameSize = Const.balloonFrameInfo.size;
    var vertexHeight = Const.balloonVertexSize.height;
    var heightOffset = (vertexHeight - frameSize) * 2;

    // Bitmap のサイズ調整
    var bitmapWidth = this._owner.width;
    var bitmapHeight = this._owner.height + heightOffset;
    if (
      isNullOrUndefined(this.bitmap) ||
      this.width != bitmapWidth ||
      this.height != bitmapHeight
    ) {
      this.bitmap = new Bitmap(bitmapWidth, bitmapHeight);
    } else {
      this.bitmap.clear();
    }

    if (Const.debug) {
      this.bitmap.fillRect(
        0,
        0,
        bitmapWidth,
        bitmapHeight,
        "rgba(160, 255, 160, 0.5)"
      );
    }
  };

  /**
   * 吹き出しの再描画
   */
  Sprite_MapActiveMessageBalloon.prototype.refresh = function () {
    if (isNullOrUndefined(this._owner)) {
      return;
    }

    // サイズの調整
    this.fitToOwner();

    // 吹き出しの描画
    var frameSize = Const.balloonFrameInfo.size;
    var vertexHeight = Const.balloonVertexSize.height;
    var offsetX = -Params.balloonMargin;
    var offsetY = vertexHeight - frameSize - Params.balloonMargin;
    this.drawBalloon(
      offsetX,
      offsetY,
      this.width - offsetX * 2,
      this.height - offsetY * 2
    );
  };

  /**
   * 吹き出しを描画
   */
  Sprite_MapActiveMessageBalloon.prototype.drawBalloon = function (
    x,
    y,
    width,
    height
  ) {
    if (isNullOrUndefined(this._owner)) {
      return;
    }

    this.drawBalloonBackground(x, y, width, height);
    this.drawBalloonFrame(x, y, width, height);
  };

  /**
   * 吹き出しの背景を描画
   */
  Sprite_MapActiveMessageBalloon.prototype.drawBalloonBackground = function (
    x,
    y,
    width,
    height
  ) {
    var srcImage = this._owner.getWindowSkin();
    var frame = Const.balloonFrameInfo;

    var prevOpacity = this.bitmap.paintOpacity;
    this.bitmap.paintOpacity = this._owner.backOpacity;

    // 背景下層
    this.bitmap.blt(
      srcImage,
      0,
      0,
      frame.srcSize,
      frame.srcSize,
      x + frame.margin,
      y + frame.margin,
      width - frame.margin * 2,
      height - frame.margin * 2
    );

    // 背景上層
    tileBlt(
      this.bitmap,
      srcImage,
      0,
      frame.srcSize,
      frame.srcSize,
      frame.srcSize,
      x + frame.margin,
      y + frame.margin,
      width - frame.margin * 2,
      height - frame.margin * 2
    );

    this.bitmap.paintOpacity = prevOpacity;
  };

  /**
   * 吹き出しの枠を描画
   */
  Sprite_MapActiveMessageBalloon.prototype.drawBalloonFrame = function (
    x,
    y,
    width,
    height
  ) {
    var srcImage = this._owner.getWindowSkin();
    var vertexOffset = this._owner.getBalloonVertexX();
    var balloonPos = this._owner.getBalloonPosition();

    var frame = Const.balloonFrameInfo;
    var vertexSize = Const.balloonVertexSize;

    // 吹き出しの頂点は枠内に収める
    vertexOffset = Math.min(
      Math.max(vertexOffset, 0),
      width - (frame.size * 2 + vertexSize.width)
    );

    // 縦枠 + コーナーを描画
    function drawFrameV(sx, dx, dy) {
      this.bitmap.blt(
        srcImage,
        sx,
        0,
        frame.size,
        frame.size,
        dx,
        dy,
        frame.size,
        frame.size
      );
      this.bitmap.blt(
        srcImage,
        sx,
        frame.size,
        frame.size,
        frame.lineLength,
        dx,
        dy + frame.size,
        frame.size,
        height - frame.size * 2
      );
      this.bitmap.blt(
        srcImage,
        sx,
        frame.size + frame.lineLength,
        frame.size,
        frame.size,
        dx,
        dy + height - frame.size,
        frame.size,
        frame.size
      );
    }

    // 横枠と頂点を描画
    function drawFrameH(sy, dx, dy, showVertex) {
      var baseSx = frame.srcSize + frame.size;
      var frameWidth = width - frame.size * 2;
      var leftWidth = showVertex ? vertexOffset : frameWidth;

      // 枠線の左側 (頂点がない場合は全体)
      this.bitmap.blt(
        srcImage,
        baseSx,
        sy,
        frame.lineLength,
        frame.size,
        dx,
        dy,
        leftWidth,
        frame.size
      );

      if (!showVertex) {
        // 頂点を描画しない
        return;
      }

      // sy > 0 なら下枠、sy === 0 なら上枠のはず
      var newDx = dx + leftWidth;
      var newDy = dy + (sy > 0 ? 0 : -(vertexSize.height - frame.size));

      // 頂点
      var vertexSx = frame.srcSize + (sy > 0 ? 0 : vertexSize.width);
      this.bitmap.blt(
        srcImage,
        vertexSx,
        frame.srcSize,
        vertexSize.width,
        vertexSize.height,
        newDx,
        newDy,
        vertexSize.width,
        vertexSize.height
      );

      if (Const.debug) {
        this.bitmap.fillRect(
          newDx,
          newDy,
          vertexSize.width,
          vertexSize.height,
          "rgba(255, 160, 160, 0.5)"
        );
      }

      // 枠線の右側
      var rightWidth = frameWidth - (leftWidth + vertexSize.width);
      if (rightWidth > 0) {
        newDx += vertexSize.width;
        this.bitmap.blt(
          srcImage,
          baseSx,
          sy,
          frame.lineLength,
          frame.size,
          newDx,
          dy,
          rightWidth,
          frame.size
        );
      }
    }

    // 左枠
    drawFrameV.call(this, frame.srcSize, x, y);

    // 右枠
    drawFrameV.call(
      this,
      frame.srcSize + frame.size + frame.lineLength,
      x + width - frame.size,
      y
    );

    // 上枠 + 頂点
    drawFrameH.call(
      this,
      0,
      x + frame.size,
      y,
      balloonPos === Const.balloonPosition.below
    );

    // 下枠 + 頂点
    drawFrameH.call(
      this,
      frame.size + frame.lineLength,
      x + frame.size,
      y + height - frame.size,
      balloonPos === Const.balloonPosition.above
    );
  };

  //-----------------------------------------------------------------------------
  // Sprite_Character

  /**
   * 同一のイベントか判定
   */
  Sprite_Character.prototype.isSameEvent = function (event) {
    if (
      isNullOrUndefined(this._character) ||
      isNullOrUndefined(event) ||
      !(this._character instanceof Game_Event)
    ) {
      return false;
    }

    return this._character.eventId() === event.eventId();
  };

  //-----------------------------------------------------------------------------
  // Spriteset_Map

  /**
   * 指定されたイベントに対応するキャラクタースプライトを取得
   */
  Spriteset_Map.prototype.findCharacterSpriteByEvent = function (event) {
    var sameSprites = this._characterSprites.filter(function (sprite) {
      return sprite.isSameEvent(event);
    });

    if (sameSprites.length > 0) {
      return sameSprites[0];
    } else {
      return null;
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MapActiveMessage
  //
  // マップ上でアクティブメッセージを表示するウィンドウ
  // (スプライトでも良いが、メッセージ周りはウィンドウの方が扱いやすい)

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

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

  // メッセージの一時描画バッファ
  Window_MapActiveMessage.tempMessageBuffer = null;

  /**
   * アクティブメッセージ用スキンの事前読み込み
   */
  Window_MapActiveMessage.preloadWindowskin = function () {
    ImageManager.loadSystem(Params.messageSkin);
  };

  Window_MapActiveMessage.prototype.initialize = function () {
    // コンテンツサイズは内容に応じて可変なので、ウィンドウサイズは仮
    Window_Base.prototype.initialize.call(this, 0, 0, 64, 64);

    if (isNullOrUndefined(Window_MapActiveMessage.tempMessageBuffer)) {
      Window_MapActiveMessage.tempMessageBuffer = new Bitmap(
        Graphics.boxWidth,
        Graphics.boxHeight / 2
      );
    }

    this._balloonSprite = null;

    this.opacity = 0;
    this.contentsOpacity = 0;
    this.initMembers();
  };

  Window_MapActiveMessage.prototype.standardFontSize = function () {
    return Params.fontSize;
  };

  Window_MapActiveMessage.prototype.loadWindowskin = function () {
    // デフォルトのスキンの代わりに、アクティブメッセージ用のスキンを読み込む
    this._windowskin = ImageManager.loadSystem(Params.messageSkin);
  };

  /**
   * ウィンドウスキンを取得
   */
  Window_MapActiveMessage.prototype.getWindowSkin = function () {
    return this._windowskin;
  };

  Window_MapActiveMessage.prototype.initMembers = function () {
    this._textState = null;
    this._event = null;
    this._characterSprite = null;
    this._targetPageIndex = 0;
    this._duration = 0;
    this._isForceDisplay = false;
    this._balloonPosition = Const.balloonPosition.above;
  };

  Window_MapActiveMessage.prototype.show = function () {
    Window_Base.prototype.show.call(this);

    if (!isNullOrUndefined(this._balloonSprite)) {
      this._balloonSprite.show();
    }
  };

  Window_MapActiveMessage.prototype.hide = function () {
    this._duration = 0;

    Window_Base.prototype.hide.call(this);

    if (!isNullOrUndefined(this._balloonSprite)) {
      this._balloonSprite.hide();
    }
  };

  /**
   * フェードアウト
   */
  Window_MapActiveMessage.prototype.fadeOut = function () {
    if (this.isFadingOut()) {
      return;
    }

    if (this.isFadingIn()) {
      // フェードイン中は同じ不透明度からフェードアウトする
      this._duration = this._initialDisplayDuration - this._duration;
    } else {
      this._duration = Params.fadeFrameCount;
    }
  };

  Window_MapActiveMessage.prototype.numVisibleRows = function () {
    return 4;
  };

  /**
   * 吹き出しスプライトの設定
   */
  Window_MapActiveMessage.prototype.setBalloonSprite = function (sprite) {
    sprite.setOwner(this);
    this._balloonSprite = sprite;

    // ウィンドウの裏に表示
    this.addChildAt(sprite, 0);
  };

  /**
   * イベントに対する吹き出しの表示位置を取得
   */
  Window_MapActiveMessage.prototype.getBalloonPosition = function () {
    return this._balloonPosition;
  };

  /**
   * メッセージ表示中か
   */
  Window_MapActiveMessage.prototype.isDisplaying = function () {
    return this._duration > 0;
  };

  /**
   * 強制表示されたか
   */
  Window_MapActiveMessage.prototype.isForced = function () {
    return this._isForceDisplay;
  };

  /**
   * フェードイン中か
   */
  Window_MapActiveMessage.prototype.isFadingIn = function () {
    return (
      this._duration >= this._initialDisplayDuration - Params.fadeFrameCount
    );
  };

  /**
   * フェードアウト中か
   */
  Window_MapActiveMessage.prototype.isFadingOut = function () {
    return this._duration < Params.fadeFrameCount;
  };

  /**
   * 表示中のイベントと同一イベントか
   */
  Window_MapActiveMessage.prototype.isSameEvent = function (event) {
    if (isNullOrUndefined(this._event)) {
      return false;
    }

    // ページ番号まで同じ場合に同一と見なす
    if (
      this._event.eventId() === event.eventId() &&
      this._targetPageIndex === event.pageIndex()
    ) {
      return true;
    }

    return false;
  };

  /**
   * イベントが画面内にあるか判定
   */
  Window_MapActiveMessage.prototype.isEventInScreen = function () {
    if (isNullOrUndefined(this._event)) {
      return false;
    }

    var x = this._event.screenX();
    var y = this._event.screenY();
    return (
      x >= 0 && y >= 0 && x <= Graphics.boxWidth && y <= Graphics.boxHeight
    );
  };

  /**
   * メッセージの表示開始
   *
   * @param {String}              text        '\n' 区切りのメッセージ
   * @param {Game_Event}          event       表示対象のイベント
   * @param {Sprite_Character}    sprite      表示対象のキャラクタースプライト
   * @param {boolean}             isForce     表示時間満了まで強制表示
   */
  Window_MapActiveMessage.prototype.display = function (
    text,
    event,
    sprite,
    isForce
  ) {
    // 表示のキャンセル
    function rollback() {
      this.initMembers();
      this.hide();
    }

    if (isNullOrUndefined(text) || isNullOrUndefined(event)) {
      rollback.call(this);
      return;
    }

    this._event = event;
    this._characterSprite = sprite;
    if (!this.isEventInScreen()) {
      rollback.call(this);
      return;
    }

    // 表示パラメータの設定
    this._textState = {
      index: 0,
      text: this.convertEscapeCharacters(text),
    };
    this._allTextWidth = 0;
    this._targetPageIndex = event.pageIndex();
    this._initialDisplayDuration = event.getMapActiveMessageDuration();
    this._duration = this._initialDisplayDuration;
    this._isForceDisplay = !!isForce;

    this.newPage(this._textState);
    this.updatePosition();
    this.updateOpacity();
    this.refreshBalloon();

    this.show();

    // 多重表示抑止のため、表示済みフラグを立てる
    event.setMapActiveMessageShown(true);
  };

  /**
   * 新しいページの表示
   */
  Window_MapActiveMessage.prototype.newPage = function (textState) {
    // コンテンツを一時領域に書く
    this.contents = Window_MapActiveMessage.tempMessageBuffer;
    this.contents.clear();
    this.resetFontSettings();
    textState.x = this.newLineX();
    textState.y = 0;
    textState.left = this.newLineX();
    textState.height = this.calcTextHeight(textState, false);
    this._allTextHeight = this.calcTextHeight(textState, true);

    this.updateMessage();

    // コンテンツを一時領域から正式に反映
    this.createContents();
    this.contents.blt(
      Window_MapActiveMessage.tempMessageBuffer,
      0,
      0,
      this._allTextWidth,
      this._allTextHeight,
      0,
      0,
      this._allTextWidth,
      this._allTextHeight
    );
  };

  /**
   * メッセージの表示位置を設定
   */
  Window_MapActiveMessage.prototype.updatePosition = function () {
    if (isNullOrUndefined(this._event)) {
      return;
    }

    // 画面外に出る場合は消去
    if (!this.isEventInScreen()) {
      this.hide();
      return;
    }

    // 吹き出しの枠ぶんのマージン
    var margin = Const.balloonFrameInfo.size;

    var balloonOffsetY =
      Const.balloonVertexSize.height - Params.balloonOffsetY - margin;
    var heightOffset =
      this.height +
      (!isNullOrUndefined(this._characterSprite)
        ? this._characterSprite.patternHeight()
        : $gameMap.tileHeight());

    // デフォルトの位置は上
    var x = this._event.screenX() - this.width / 2;
    var y = this._event.screenY() - (heightOffset + balloonOffsetY);
    this._balloonPosition = Const.balloonPosition.above;

    // 画面左右にははみ出させない
    x = Math.min(Math.max(x, margin), Graphics.boxWidth - this.width - margin);

    // 画面上側にはみ出る場合は下に表示
    if (y < margin) {
      y = this._event.screenY() + balloonOffsetY;
      this._balloonPosition = Const.balloonPosition.below;
    }

    // 画面下側にはみ出る場合は上に表示
    if (y + this.height > Graphics.boxHeight - margin) {
      y -= heightOffset + balloonOffsetY;
      this._balloonPosition = Const.balloonPosition.above;
    }

    this.x = x;
    this.y = y;

    if (!isNullOrUndefined(this._balloonSprite)) {
      // 吹き出しの頂点表示を考慮した位置に移動
      this._balloonSprite.followOwner();
    }
  };

  /**
   * ウィンドウのサイズを更新
   */
  Window_MapActiveMessage.prototype.updateWindowSize = function () {
    var offset = this.standardPadding() * 2;
    this.width = this._allTextWidth + offset;
    this.height = this._allTextHeight + offset;
  };

  /**
   * 不透明度の更新
   */
  Window_MapActiveMessage.prototype.updateOpacity = function () {
    var opacity = 255;
    if (this.isFadingIn()) {
      // フェードイン
      opacity =
        (255 * (this._initialDisplayDuration - this._duration)) /
        Params.fadeFrameCount;
    } else if (this.isFadingOut()) {
      // フェードアウト
      opacity = (255 * this._duration) / Params.fadeFrameCount;
    }

    this.contentsOpacity = opacity;
    if (!isNullOrUndefined(this._balloonSprite)) {
      this._balloonSprite.opacity = opacity;
    }
  };

  /**
   * 吹き出しの再描画
   */
  Window_MapActiveMessage.prototype.refreshBalloon = function () {
    if (!isNullOrUndefined(this._balloonSprite)) {
      this._balloonSprite.refresh();
    }
  };

  /**
   * プレイヤーとの距離を確認
   */
  Window_MapActiveMessage.prototype.checkPlayerDistance = function () {
    // 強制表示 or 消去中は距離判定しない
    if (this.isForced() || this._duration <= Params.fadeFrameCount) {
      return;
    }

    // 表示範囲外に出た場合は消す
    var distance = $gamePlayer.calcDistanceForMapActiveMessage(this._event);
    if (distance > this._event.getMapActiveMessageRange()) {
      this.fadeOut();
    }
  };

  Window_MapActiveMessage.prototype.update = function () {
    Window_Base.prototype.update.call(this);

    if (!isNullOrUndefined(this._balloonSprite)) {
      this._balloonSprite.update();
    }

    if (!this.isDisplaying()) {
      return;
    }

    this._duration--;
    this.updateOpacity();
    this.updatePosition();
    this.checkPlayerDistance();

    // 表示が終了したら初期化
    if (!this.isDisplaying()) {
      debuglog("[MapActiveMessage] Finished to display");
      this.initMembers();
    }
  };

  /**
   * メッセージの更新
   */
  Window_MapActiveMessage.prototype.updateMessage = function () {
    if (isNullOrUndefined(this._textState)) {
      return false;
    }

    while (!this.isEndOfText(this._textState)) {
      this.processCharacter(this._textState);
      this._allTextWidth = Math.max(this._allTextWidth, this._textState.x);
    }

    this.updateWindowSize();

    return true;
  };

  /**
   * 吹き出しの頂点位置を取得
   */
  Window_MapActiveMessage.prototype.getBalloonVertexX = function () {
    if (isNullOrUndefined(this._event)) {
      return 0;
    }

    return (
      this._event.screenX() -
      this.x -
      Const.balloonFrameInfo.size -
      Const.balloonVertexSize.width / 2 +
      Params.balloonMargin
    );
  };

  /**
   * 改行時の描画先 X 座標
   */
  Window_MapActiveMessage.prototype.newLineX = function () {
    return 0;
  };

  /**
   * 改行の処理
   */
  Window_MapActiveMessage.prototype.processNewLine = function (textState) {
    this._allTextWidth = Math.max(this._allTextWidth, textState.x);

    Window_Base.prototype.processNewLine.call(this, textState);
  };

  /**
   * 改ページの処理
   */
  Window_MapActiveMessage.prototype.processNewPage = function (textState) {
    Window_Base.prototype.processNewPage.call(this, textState);
    if (textState.text[textState.index] === "\n") {
      textState.index++;
    }

    textState.y = this.contents.height;
  };

  /**
   * テキスト終端か
   */
  Window_MapActiveMessage.prototype.isEndOfText = function (textState) {
    return textState.index >= textState.text.length;
  };

  /**
   * 改ページが必要か
   */
  Window_MapActiveMessage.prototype.needsNewPage = function (textState) {
    return (
      !this.isEndOfText(textState) &&
      textState.y + textState.height > this.contents.height
    );
  };

  //-----------------------------------------------------------------------------
  // Scene_Map

  var _Scene_Map_createAllWindows = Scene_Map.prototype.createAllWindows;
  Scene_Map.prototype.createAllWindows = function () {
    _Scene_Map_createAllWindows.call(this);

    this.createActiveMessageWindow();
  };

  /**
   * アクティブメッセージウィンドウの作成
   */
  Scene_Map.prototype.createActiveMessageWindow = function () {
    if (!isNullOrUndefined(this._activeMessageWindowLayer)) {
      return;
    }

    var width = Graphics.boxWidth;
    var height = Graphics.boxHeight;
    var x = (Graphics.width - width) / 2;
    var y = (Graphics.height - height) / 2;
    this._activeMessageWindowLayer = new WindowLayer();
    this._activeMessageWindowLayer.move(x, y, width, height);
    this.addChild(this._activeMessageWindowLayer);

    Window_MapActiveMessage.preloadWindowskin();
  };

  var _Scene_Map_update = Scene_Map.prototype.update;
  Scene_Map.prototype.update = function () {
    _Scene_Map_update.call(this);

    this.updateActiveMessageDisplay();
  };

  var _Scene_Map_stop = Scene_Map.prototype.stop;
  Scene_Map.prototype.stop = function () {
    _Scene_Map_stop.call(this);

    $gameTemp.clearMapActiveMessage();
  };

  var _Scene_Map_terminate = Scene_Map.prototype.terminate;
  Scene_Map.prototype.terminate = function () {
    _Scene_Map_terminate.call(this);

    this.destroyActiveMessageWindows();
  };

  /**
   * アクティブメッセージウィンドウの破棄
   */
  Scene_Map.prototype.destroyActiveMessageWindows = function () {
    this._activeMessageWindowLayer.removeChildren();
    this.removeChild(this._activeMessageWindowLayer);
    this._activeMessageWindowLayer = null;
  };

  /**
   * アクティブメッセージの表示を更新
   */
  Scene_Map.prototype.updateActiveMessageDisplay = function () {
    if (!$gameSystem.isMapActiveMessageEnabled() || $gameMap.isEventRunning()) {
      // メッセージを表示できないときは非表示にしつつ各種フラグを解除
      $gameTemp.clearMapActiveMessage();
      $gameMap.clearActiveMessageShownFlags();
      this._activeMessageWindowLayer.children.forEach(function (child) {
        child.fadeOut();
      });
      return;
    }

    // 表示が完了したものを削除
    this._activeMessageWindowLayer.children
      .filter(function (child) {
        return !child.isDisplaying();
      })
      .forEach(function (item) {
        this._activeMessageWindowLayer.removeChild(item);
      }, this);

    // 要求されているメッセージを表示できるだけ表示
    while ($gameTemp.isMapActiveMessageReady()) {
      if (!this.displayActiveMessage()) {
        break;
      }
    }
  };

  /**
   * 指定されたイベントのアクティブメッセージが表示されているか判定
   */
  Scene_Map.prototype.isActiveMessageDisplayed = function (event) {
    var layer = this._activeMessageWindowLayer;
    for (var i = 0; i < layer.children.length; i++) {
      var window = layer.children[i];
      if (window.isDisplaying() && window.isSameEvent(event)) {
        return true;
      }
    }

    return false;
  };

  /**
   * アクティブメッセージの表示
   */
  Scene_Map.prototype.displayActiveMessage = function () {
    var layer = this._activeMessageWindowLayer;

    // 最大数に達していたら表示を諦める
    // (children には吹き出しも含まれるので / 2)
    if (layer.children.length / 2 >= Params.messageCountMax) {
      return false;
    }

    // 予約されているメッセージを表示
    var message = $gameTemp.popNextMapActiveMessage();
    while (!isNullOrUndefined(message)) {
      // まだ表示していないもののみ表示
      if (!this.isActiveMessageDisplayed(message.event)) {
        var character = this._spriteset.findCharacterSpriteByEvent(
          message.event
        );
        var balloon = new Sprite_MapActiveMessageBalloon();
        var window = new Window_MapActiveMessage();
        window.setBalloonSprite(balloon);
        window.display(
          message.text,
          message.event,
          character,
          message.isForced
        );
        layer.addChild(window);
      }

      message = $gameTemp.popNextMapActiveMessage();
    }

    return true;
  };

  var _Scene_Map_snapForBattleBackground =
    Scene_Map.prototype.snapForBattleBackground;
  Scene_Map.prototype.snapForBattleBackground = function () {
    // アクティブメッセージはキャプチャしない
    var layer = this._activeMessageWindowLayer;
    if (!isNullOrUndefined(layer)) {
      layer.visible = false;
    }

    _Scene_Map_snapForBattleBackground.call(this);

    if (!isNullOrUndefined(layer)) {
      layer.visible = true;
    }
  };
})();


code:
//=============================================================================
// LoadComSim.js
//=============================================================================

/*:ja
 * @plugindesc ver1.00 メニューコマンドにロードを追加します。
 * @author まっつＵＰ
 *
 * @param loadtext
 * @desc コマンド「ロード」のコマンド名です。
 * @default ロード
 *
 * @help
 *
 * RPGで笑顔を・・・
 *
 * このヘルプとパラメータの説明をよくお読みになってからお使いください。
 *
 * コマンド「ロード」はイベントテスト中またはセーブデータがないときは選択不能になります。
 *
 * このプラグインを利用する場合は
 * readmeなどに「まっつＵＰ」の名を入れてください。
 * また、素材のみの販売はダメです。
 * 上記以外の規約等はございません。
 * もちろんツクールMVで使用する前提です。
 * 何か不具合ありましたら気軽にどうぞ。
 *
 * 免責事項：
 * このプラグインを利用したことによるいかなる損害も制作者は一切の責任を負いません。
 *
 */

(function () {
  var parameters = PluginManager.parameters("LoadComSim");
  var LCSloadtext = String(parameters["loadtext"] || "ロード");

  var _Scene_Menu_createCommandWindow =
    Scene_Menu.prototype.createCommandWindow;
  Scene_Menu.prototype.createCommandWindow = function () {
    _Scene_Menu_createCommandWindow.call(this);
    this._commandWindow.setHandler("load", this.commandLoad.bind(this));
  };

  Scene_Menu.prototype.commandLoad = function () {
    //新規
    SceneManager.push(Scene_Load);
  };

  var _Window_MenuCommand_addSaveCommand =
    Window_MenuCommand.prototype.addSaveCommand;
  Window_MenuCommand.prototype.addSaveCommand = function () {
    _Window_MenuCommand_addSaveCommand.call(this);
    var enabled = this.isLoadEnabled();
    this.addCommand(LCSloadtext, "load", enabled);
  };

  Window_MenuCommand.prototype.isLoadEnabled = function () {
    //新規
    if (DataManager.isEventTest()) return false; //この行はイベントテスト中かどうか判定しています。
    return DataManager.isAnySavefileExists();
  };
})();


code:
//=============================================================================
// Lunatlazur_ActorNameWindow.js
// ----------------------------------------------------------------------------
// Copyright (c) 2018 Taku Aoi
// This plugin is released under the zlib License.
// http://zlib.net/zlib_license.html
// ----------------------------------------------------------------------------
// Version
// 1.0.0 2018/04/01
// ----------------------------------------------------------------------------
// [Web]    : https://lunatlazur.com/
// [Twitter]: https://twitter.com/lunatlazur/
// [GitHub] : https://github.com/Lunatlazur/
//=============================================================================
/*:
 * @plugindesc Show actor name window
 * @author Taku Aoi
 * @help This plugin shows speaker's name window.
 *
 * Input the character name with \N<Character name> format
 * to display the speaker's name window.
 *
 * The same font as the message window is used for this window.
 */
/*:ja
 * @plugindesc 名前ウィンドウ表示プラグイン
 * @author あおいたく
 * @help このプラグインは名前ウィンドウを表示できるようにします。
 *
 * \N<キャラクター名> 形式でメッセージ内にキャラクターの名前を記述することで
 * メッセージウィンドウの上部に名前ウィンドウを表示するようになります。
 *
 * 名前ウィンドウのフォントはメッセージウィンドウのものが使われます。
 *
 * @param テキストカラー
 * @desc 名前を表示するテキストの色番号を指定します。
 * @default 1
 * @type number
 *
 */
var __extends =
  (this && this.__extends) ||
  (function () {
    var extendStatics =
      Object.setPrototypeOf ||
      ({ __proto__: [] } instanceof Array &&
        function (d, b) {
          d.__proto__ = b;
        }) ||
      function (d, b) {
        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
      };
    return function (d, b) {
      extendStatics(d, b);
      function __() {
        this.constructor = d;
      }
      d.prototype =
        b === null
          ? Object.create(b)
          : ((__.prototype = b.prototype), new __());
    };
  })();
(function () {
  var pluginName = "Lunatlazur_ActorNameWindow";
  function getValue(params) {
    var names = [];
    for (var _i = 1; _i < arguments.length; _i++) {
      names[_i - 1] = arguments[_i];
    }
    var found = null;
    names.forEach(function (name) {
      if (!!params[name]) {
        found = params[name];
      }
    });
    return found;
  }
  function asNumber(params) {
    var names = [];
    for (var _i = 1; _i < arguments.length; _i++) {
      names[_i - 1] = arguments[_i];
    }
    return parseInt(getValue.apply(void 0, [params].concat(names)), 10);
  }
  var parameters = PluginManager.parameters(pluginName);
  var params = {
    textColor: asNumber(parameters, "テキストカラー"),
  };
  var Window_ActorName = /** @class */ (function (_super) {
    __extends(Window_ActorName, _super);
    function Window_ActorName(_) {
      var _this = _super.call(this) || this;
      _this.initialize.apply(_this, arguments);
      return _this;
    }
    Window_ActorName.prototype.initialize = function (parentWindow) {
      this._parentWindow = parentWindow;
      _super.prototype.initialize.call(this, 0, 0, 240, this.windowHeight());
      this._padding = 4;
      this._text = "";
      this._openness = 0;
      this.deactivate();
      this.hide();
    };
    Window_ActorName.prototype.standardFontFace = function () {
      if (this._parentWindow) {
        return this._parentWindow.standardFontFace();
      } else {
        return _super.prototype.standardFontFace.call(this);
      }
    };
    Window_ActorName.prototype.windowWidth = function () {
      this.resetFontSettings();
      return Math.ceil(
        this.textWidth(this._text) +
          this.padding * 2 +
          this.standardPadding() * 4
      );
    };
    Window_ActorName.prototype.windowHeight = function () {
      return this.lineHeight() + this.padding * 2;
    };
    Window_ActorName.prototype.contentsWidth = function () {
      return this.width - this.padding * 2;
    };
    Window_ActorName.prototype.contentsHeight = function () {
      return this.lineHeight();
    };
    Window_ActorName.prototype.update = function () {
      _super.prototype.update.call(this);
      if (this.active || this.isClosed() || this.isClosing()) {
        return;
      }
      if (this._parentWindow.isClosing()) {
        this._openness = this._parentWindow.openness;
      }
      this.close();
    };
    Window_ActorName.prototype.setText = function (text) {
      this._text = text;
      this.refresh();
    };
    Window_ActorName.prototype.refresh = function () {
      this.width = this.windowWidth();
      this.createContents();
      this.contents.clear();
      this.resetFontSettings();
      this.changeTextColor(this.textColor(params.textColor));
      this.drawText(
        this._text,
        this.standardPadding() * 2,
        0,
        this.contents.width
      );
    };
    Window_ActorName.prototype.updatePlacement = function () {
      if (this._parentWindow.y === 0) {
        this.y = this._parentWindow.y + this._parentWindow.windowHeight();
      } else {
        this.y = this._parentWindow.y - this.windowHeight();
      }
    };
    Window_ActorName.prototype.updateBackground = function () {
      this.setBackgroundType(this._parentWindow._background);
    };
    Window_ActorName.prototype.processActorName = function (text) {
      var _this = this;
      return text.replace(/\x1bN\<(.*?)\>/gi, function (whole) {
        var args = [];
        for (var _i = 1; _i < arguments.length; _i++) {
          args[_i - 1] = arguments[_i];
        }
        _this.setText(args[0]);
        _this.show();
        _this.open();
        _this.activate();
        return "";
      });
    };
    return Window_ActorName;
  })(Window_Base);
  var Window_Message_createSubWindows =
    Window_Message.prototype.createSubWindows;
  Window_Message.prototype.createSubWindows = function () {
    Window_Message_createSubWindows.call(this);
    this._nameWindow = new Window_ActorName(this);
  };
  var Window_Message_subWindows = Window_Message.prototype.subWindows;
  Window_Message.prototype.subWindows = function () {
    return Window_Message_subWindows.call(this).concat([this._nameWindow]);
  };
  var Window_Message_startMessage = Window_Message.prototype.startMessage;
  Window_Message.prototype.startMessage = function () {
    this._nameWindow.deactivate();
    Window_Message_startMessage.call(this);
  };
  var Window_Message_terminateMessage =
    Window_Message.prototype.terminateMessage;
  Window_Message.prototype.terminateMessage = function () {
    this._nameWindow.deactivate();
    Window_Message_terminateMessage.call(this);
  };
  Window_Message.prototype.convertEscapeCharacters = function (text) {
    text = Window_Base.prototype.convertEscapeCharacters.call(this, text);
    text = this._nameWindow.processActorName(text);
    return text;
  };
  var Window_Message_updatePlacement = Window_Message.prototype.updatePlacement;
  Window_Message.prototype.updatePlacement = function () {
    Window_Message_updatePlacement.call(this);
    if (this._nameWindow.active) {
      this._nameWindow.updatePlacement();
    }
  };
  var Window_Message_updateBackground =
    Window_Message.prototype.updateBackground;
  Window_Message.prototype.updateBackground = function () {
    Window_Message_updateBackground.call(this);
    if (this._nameWindow.active) {
      this._nameWindow.updateBackground();
    }
  };
})();