code:
//=============================================================================
// TMPlugin - ログウィンドウ
// バージョン: 1.1.1
// 最終更新日: 2019/03/11
// 配布元    : https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2017 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc マップシーンにログウィンドウを表示します。
 *
 * @author tomoaky (https://hikimoki.sakura.ne.jp/)
 *
 * @param logWindowX
 * @type number
 * @min -1000
 * @desc ログウィンドウの X 座標。
 * 初期値: 0
 * @default 0
 *
 * @param logWindowY
 * @type number
 * @min -1000
 * @desc ログウィンドウの Y 座標。
 * 初期値: 460
 * @default 460
 *
 * @param logWindowWidth
 * @type number
 * @desc ログウィンドウの幅。
 * 初期値: 480
 * @default 480
 *
 * @param lines
 * @type number
 * @desc ログウィンドウの行数。
 * 初期値: 6
 * @default 6
 *
 * @param lineHeight
 * @type number
 * @desc ログウィンドウの１行の高さ。
 * 初期値: 24
 * @default 24
 *
 * @param padding
 * @type number
 * @desc ログウィンドウの余白の大きさ。
 * 初期値: 10
 * @default 10
 *
 * @param fontSize
 * @type number
 * @desc ログウィンドウのフォントサイズ。
 * 初期値: 20
 * @default 20
 *
 * @param startVisible
 * @type boolean
 * @desc ゲーム開始時の表示状態。
 * 初期値: ON（ true = ON 表示 / false = OFF 非表示 )
 * @default true
 *
 * @param opacity
 * @type number
 * @max 255
 * @desc ウィンドウフレームと背景の不透明度。
 * 初期値: 255 ( 0 ～ 255 )
 * @default 255
 *
 * @param collideOpacity
 * @type number
 * @max 255
 * @desc プレイヤーと重なったときの不透明度。
 * 初期値: 128（ 0 ～ 255 ）
 * @default 128
 *
 * @param messageBusyHide
 * @type boolean
 * @desc メッセージウィンドウ表示中はログウィンドウを隠す。
 * 初期値: ON（ true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param eventBusyHide
 * @type boolean
 * @desc イベント起動中はログウィンドウを隠す。
 * 初期値: ON（ true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param maxLogs
 * @type number
 * @desc 保存するログの最大行数。
 * 初期値: 30
 * @default 30
 *
 * @param autoDelete
 * @type variable
 * @desc 指定したゲーム変数に代入された値の間隔で、自動的にテキストを
 * 削除する。単位はフレーム数（ 60フレーム = 1秒 ）
 * @default 0
 *
 * @help
 * TMPlugin - ログウィンドウ ver1.1.1
 *
 * 使い方:
 *
 *   プラグインを導入するとマップシーンにログウィンドウが追加されます。
 *   プラグインコマンドを使って手動で書き込むか、転記モードで
 *   自動的に書き込むことでログウィンドウにテキストを表示できます。
 *
 *   このプラグインは RPGツクールMV Version 1.6.1 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   showLogWindow
 *     ログウィンドウを表示する。
 *
 *   hideLogWindow
 *     ログウィンドウを隠す。
 *
 *   addLog テキスト
 *     テキストをログウィンドウに追加する。
 *     一部の制御文字も使えます（\V[n], \N[n], \P[n], \G, \C[n]）
 *
 *   deleteLog
 *     一番古いテキストをひとつ削除する。
 *
 *   startMirrorLogWindow
 *     イベントコマンド『文章の表示』をトレースする転記モードを有効化。
 *
 *   stopMirrorLogWindow
 *     startMirrorLogWindow で有効化した機能を無効化します。
 *
 *   startAutoLogWindow
 *     『TMJumpAction.js』などの対応プラグインと併用した場合に
 *     敵撃破時の報酬情報を自動でログに追記する機能を有効化します。
 *     この機能はゲーム開始時には自動的にオンになっています。
 *
 *   stopAutoLogWindow
 *     startAutoLogWindow で有効化した機能を無効化します。
 *
 *   openLogScene
 *     ログ確認シーンへ移行します。
 *
 *
 * プラグインパラメータ補足:
 *
 *   padding
 *     テキストの表示領域とウィンドウフレーム外側までのドット数です。
 *     ウィンドウの高さ（縦方向の大きさ）は以下の式で算出されます。
 *     １行の高さ(lineHeight) * 行数(lines) + 余白(padding) * 2
 *     画面の下部ぴったりにウィンドウを表示したい場合は縦方向の
 *     画面サイズから上記の式の結果を引いた値を logWindowY に
 *     設定してください。
 *
 *   collideOpacity
 *     opacity よりも大きい値を設定した場合、ログの内容には
 *     collideOpacity を適用し、ウィンドウフレームと背景には
 *     opacity を適用します。
 *
 *   autoDelete
 *     指定したゲーム変数の値が 0 の場合は、自動削除の機能が
 *     停止します。
 */

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

(function () {
  parameters = PluginManager.parameters("TMLogWindow");
  logWindowX = +(parameters["logWindowX"] || 0);
  logWindowY = +(parameters["logWindowY"] || 464);
  logWindowWidth = +(parameters["logWindowWidth"] || 480);
  logWindowLines = +(parameters["lines"] || 6);
  logWindowLineHeight = +(parameters["lineHeight"] || 24);
  logWindowPadding = +(parameters["padding"] || 10);
  logWindowFontSize = +(parameters["fontSize"] || 20);
  logWindowStartVisible = JSON.parse(parameters["startVisible"]);
  logWindowOpacity = +(parameters["opacity"] || 255);
  logWindowCollideOpacity = +(parameters["collideOpacity"] || 128);
  logWindowMessageBusyHide = JSON.parse(parameters["messageBusyHide"]);
  logWindowEventBusyHide = JSON.parse(parameters["eventBusyHide"]);
  logWindowMaxLogs = +(parameters["maxLogs"] || 20);
  logWindowAutoDelete = +(parameters["autoDelete"] || 0);

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

  Game_Temp.prototype.dummyWindow = function () {
    if (!this._dummyWindow) {
      this._dummyWindow = new Window_Base(0, 0, 64, 64);
    }
    return this._dummyWindow;
  };

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

  var _Game_System_initialize = Game_System.prototype.initialize;
  Game_System.prototype.initialize = function () {
    _Game_System_initialize.call(this);
    this._visibleLogWindow = logWindowStartVisible;
    this._mirrorLogWindow = false;
    this._autoLogWindow = true;
    this._actionLog = [];
  };

  Game_System.prototype.isVisibleLogWindow = function () {
    return this._visibleLogWindow;
  };

  Game_System.prototype.isMirrorLogWindow = function () {
    return this._mirrorLogWindow;
  };

  Game_System.prototype.isAutoLogWindow = function () {
    return this._autoLogWindow;
  };

  Game_System.prototype.setVisibleLogWindow = function (visible) {
    this._visibleLogWindow = visible;
  };

  Game_System.prototype.setMirrorMode = function (flag) {
    this._mirrorLogWindow = flag;
  };

  Game_System.prototype.setAutoMode = function (flag) {
    this._autoLogWindow = flag;
  };

  Game_System.prototype.addLog = function (text) {
    text = $gameTemp.dummyWindow().convertEscapeCharacters(text);
    this._actionLog.push(text);
    if (this._actionLog.length > logWindowMaxLogs) {
      this._actionLog.shift();
    }
    this._needsActionLogRefresh = true;
  };

  Game_System.prototype.deleteLog = function () {
    if (this._actionLog.length > 0) {
      this._actionLog.shift();
      this._needsActionLogRefresh = true;
    }
  };

  Game_System.prototype.actionLog = function () {
    return this._actionLog;
  };

  //-----------------------------------------------------------------------------
  // Game_Message
  //

  var _Game_Message_add = Game_Message.prototype.add;
  Game_Message.prototype.add = function (text) {
    _Game_Message_add.call(this, text);
    if ($gameSystem.isMirrorLogWindow()) {
      $gameSystem.addLog(text);
    }
  };

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

  // レベルアップの表示
  var _Game_Actor_displayLevelUp = Game_Actor.prototype.displayLevelUp;
  Game_Actor.prototype.displayLevelUp = function (newSkills) {
    _Game_Actor_displayLevelUp.call(this, newSkills);
    if ($gameSystem.isAutoLogWindow() && !$gameParty.inBattle()) {
      var text = TextManager.levelUp.format(
        this._name,
        TextManager.level,
        this._level
      );
      $gameSystem.addLog(text);
    }
  };

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

  var _Game_Event_gainRewards = Game_Event.prototype.gainRewards;
  Game_Event.prototype.gainRewards = function () {
    if ($gameSystem.isAutoLogWindow()) {
      var battler = this.battler();
      var exp = battler.exp();
      var gold = battler.gold();
      var text = battler.name() + $dataStates[battler.deathStateId()].message2;
      var rewardText = "";
      if (exp > 0) {
        rewardText += "" + exp + "\\C[16]" + TextManager.expA + "\\C[0]";
      }
      if (gold > 0) {
        if (exp > 0) {
          rewardText += " / ";
        }
        rewardText +=
          "" + gold + "\\C[16]" + TextManager.currencyUnit + "\\C[0]";
      }
      if (rewardText) {
        text += " ( " + rewardText + " )";
      }
      $gameSystem.addLog(text);
    }
    _Game_Event_gainRewards.call(this);
  };

  var _Game_Event_gainRewardItem = Game_Event.prototype.gainRewardItem;
  Game_Event.prototype.gainRewardItem = function (item, y) {
    _Game_Event_gainRewardItem.call(this, item, y);
    if ($gameSystem.isAutoLogWindow()) {
      var text = TextManager.obtainItem.format(item.name);
      $gameSystem.addLog(text);
    }
  };

  //-----------------------------------------------------------------------------
  // Game_Interpreter
  //

  // プラグインコマンド
  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "showLogWindow") {
      $gameSystem.setVisibleLogWindow(true);
    } else if (command === "hideLogWindow") {
      $gameSystem.setVisibleLogWindow(false);
    } else if (command === "addLog") {
      $gameSystem.addLog(args[0]);
    } else if (command === "deleteLog") {
      $gameSystem.deleteLog();
    } else if (command === "startMirrorLogWindow") {
      $gameSystem.setMirrorMode(true);
    } else if (command === "stopMirrorLogWindow") {
      $gameSystem.setMirrorMode(false);
    } else if (command === "startAutoLogWindow") {
      $gameSystem.setAutoMode(true);
    } else if (command === "stopAutoLogWindow") {
      $gameSystem.setAutoMode(false);
    } else if (command === "openLogScene") {
      SceneManager.push(Scene_Log);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MapLog
  //

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

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

  Window_MapLog.prototype.initialize = function () {
    var x = logWindowX;
    var y = logWindowY;
    var wight = this.windowWidth();
    var height = this.windowHeight();
    Window_Base.prototype.initialize.call(this, x, y, wight, height);
    this.openness = $gameSystem.isVisibleLogWindow() ? 255 : 0;
    this.opacity = 255;
    this.contentsOpacity = 255;
    this._hideCount = 0;
    this._autoDeleteCount = 0;
    this.refresh();
  };

  Window_MapLog.prototype.standardFontSize = function () {
    return logWindowFontSize;
  };

  // ウィンドウの幅を取得
  Window_MapLog.prototype.windowWidth = function () {
    return logWindowWidth;
  };

  // ウィンドウの高さを取得
  Window_MapLog.prototype.windowHeight = function () {
    return this.fittingHeight(logWindowLines);
  };

  // 標準パディングを取得
  Window_MapLog.prototype.standardPadding = function () {
    return logWindowPadding;
  };

  // ウィンドウの１行の高さを取得
  Window_MapLog.prototype.lineHeight = function () {
    return logWindowLineHeight;
  };

  // フレーム更新
  Window_MapLog.prototype.update = function () {
    Window_Base.prototype.update.call(this);
    if (logWindowAutoDelete > 0) {
      var maxCount = $gameVariables.value(logWindowAutoDelete);
      if (maxCount > 0) {
        var actionLog = $gameSystem.actionLog();
        if (actionLog.length > 0) {
          this._autoDeleteCount++;
        }
        if (this._autoDeleteCount >= maxCount) {
          $gameSystem.deleteLog();
          this._autoDeleteCount = 0;
        }
      }
    }
    if (this.updateVisibility()) {
      this.open();
      if ($gameSystem._needsActionLogRefresh) {
        this.refresh();
        $gameSystem._needsActionLogRefresh = false;
      }
      this.updateOpacity();
    } else {
      this.close();
    }
  };

  // ウィンドウ表示状態の更新
  Window_MapLog.prototype.updateVisibility = function () {
    if (!$gameSystem.isVisibleLogWindow()) {
      return false;
    }
    if (
      (logWindowEventBusyHide && $gameMap.isEventRunning()) ||
      (logWindowMessageBusyHide && $gameMessage.isBusy())
    ) {
      this._hideCount++;
    } else {
      this._hideCount = 0;
    }
    return this._hideCount < 10;
  };

  // 不透明度の更新
  Window_MapLog.prototype.updateOpacity = function () {
    if (
      this.x < $gamePlayer.screenX() + 24 &&
      this.x + this.windowWidth() > $gamePlayer.screenX() - 24 &&
      this.y < $gamePlayer.screenY() &&
      this.y + this.windowHeight() > $gamePlayer.screenY() - 48
    ) {
      this.opacity = Math.min(logWindowCollideOpacity, logWindowOpacity);
      this.contentsOpacity = logWindowCollideOpacity;
    } else {
      this.opacity = logWindowOpacity;
      this.contentsOpacity = 255;
    }
  };

  // リフレッシュ
  Window_MapLog.prototype.refresh = function () {
    this.contents.clear();
    var actionLog = $gameSystem.actionLog();
    var lh = this.lineHeight();
    var n = Math.min(logWindowLines, actionLog.length);
    for (var i = 0; i < n; i++) {
      this.drawTextEx(actionLog[actionLog.length - n + i], 0, lh * i);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MenuLog
  //

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

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

  Window_MenuLog.prototype.initialize = function () {
    Window_Selectable.prototype.initialize.call(
      this,
      0,
      0,
      Graphics.boxWidth,
      Graphics.boxHeight
    );
    this._data = $gameSystem.actionLog();
    this.refresh();
    this.select(Math.max(this._data.length - 1, 0));
    this.activate();
  };

  Window_MenuLog.prototype.standardFontSize = function () {
    return logWindowFontSize;
  };

  Window_MenuLog.prototype.standardPadding = function () {
    return logWindowPadding;
  };

  Window_MenuLog.prototype.lineHeight = function () {
    return logWindowLineHeight;
  };

  Window_MenuLog.prototype.maxItems = function () {
    return this._data ? this._data.length : 1;
  };

  Window_MenuLog.prototype.item = function () {
    var index = this.index();
    return this._data && index >= 0 ? this._data[index] : null;
  };

  Window_MenuLog.prototype.drawItem = function (index) {
    var item = this._data[index];
    if (item) {
      var rect = this.itemRectForText(index);
      this.drawTextEx(item, 0, rect.y);
    }
  };

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

  var _Scene_Map_createDisplayObjects =
    Scene_Map.prototype.createDisplayObjects;
  Scene_Map.prototype.createDisplayObjects = function () {
    _Scene_Map_createDisplayObjects.call(this);
    this.createMapLogWindow();
  };

  // ログウィンドウの作成
  Scene_Map.prototype.createMapLogWindow = function () {
    this._mapLogWindow = new Window_MapLog();
    this.addChild(this._mapLogWindow);
  };

  var _Scene_Map_terminate = Scene_Map.prototype.terminate;
  Scene_Map.prototype.terminate = function () {
    if (!SceneManager.isNextScene(Scene_Battle)) {
      this._mapLogWindow.hide();
    }
    _Scene_Map_terminate.call(this);
  };

  var _Scene_Map_launchBattle = Scene_Map.prototype.launchBattle;
  Scene_Map.prototype.launchBattle = function () {
    this._mapLogWindow.hide();
    this.removeChild(this._mapLogWindow);
    this._mapLogWindow = null;
    _Scene_Map_launchBattle.call(this);
  };

  //-----------------------------------------------------------------------------
  // Scene_Log
  //

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

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

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

  Scene_Log.prototype.create = function () {
    Scene_MenuBase.prototype.create.call(this);
    this.createCreditsWindow();
  };

  Scene_Log.prototype.createCreditsWindow = function () {
    this._logWindow = new Window_MenuLog();
    this._logWindow.setHandler("ok", this.popScene.bind(this));
    this._logWindow.setHandler("cancel", this.popScene.bind(this));
    this.addWindow(this._logWindow);
  };
})();


code:
//=============================================================================
// TMPlugin - マップＨＰゲージ
// バージョン: 1.4.4
// 最終更新日: 2019/11/04
// 配布元　　: https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc マップシーンに顔グラフィックとＨＰゲージを表示します。
 * 必要に応じてＭＰや変数などをゲージで表示することもできます。
 *
 * @author tomoaky (https://hikimoki.sakura.ne.jp/)
 *
 * @param gaugeWindowX
 * @type number
 * @min -1000
 * @desc ＨＰゲージウィンドウのＸ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowY
 * @type number
 * @min -1000
 * @desc ＨＰゲージウィンドウのＹ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowWidth
 * @type number
 * @desc ＨＰゲージウィンドウの幅
 * 初期値: 288
 * @default 288
 *
 * @param gaugeWindowHeight
 * @type number
 * @desc ＨＰゲージウィンドウの高さ
 * 初期値: 64
 * @default 64
 *
 * @param gaugeA
 * @type struct<Gauge>
 * @desc ゲージＡのパラメータ
 * @default {"type":"HP","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeB
 * @type struct<Gauge>
 * @desc ゲージＢのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeC
 * @type struct<Gauge>
 * @desc ゲージＣのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeD
 * @type struct<Gauge>
 * @desc ゲージＤのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param faceOffsetX
 * @type number
 * @min -1000
 * @desc 顔グラフィックのＸ座標補正値
 * 初期値: -4 ( -1000 で顔グラフィックを使用しない)
 * @default -4
 *
 * @param faceOffsetY
 * @type number
 * @min -1000
 * @desc 顔グラフィックのＹ座標補正値
 * 初期値: -4
 * @default -4
 *
 * @param stateIconMax
 * @type number
 * @desc ステートアイコンを表示する個数
 * 初期値: 4
 * @default 4
 *
 * @param stateIconX
 * @type number
 * @min -1000
 * @desc ステートアイコンのＸ座標
 * 初期値: 156
 * @default 156
 *
 * @param stateIconY
 * @type number
 * @min -1000
 * @desc ステートアイコンのＹ座標
 * 初期値: 24
 * @default 24
 *
 * @param stateIconScale
 * @type number
 * @desc ステートアイコンの拡大率（ % ）
 * 初期値: 100
 * @default 100
 *
 * @param stateIconOpacity
 * @type number
 * @desc ステートアイコンの不透明度（ 0 ~ 255 ）
 * 初期値: 255
 * @default 255
 *
 * @param goldWidth
 * @type number
 * @desc 所持金表示の幅
 * 初期値: 0 ( 0 で非表示 )
 * @default 0
 *
 * @param goldX
 * @type number
 * @min -9999
 * @desc 所持金表示のＸ座標
 * 初期値: 12
 * @default 12
 *
 * @param goldY
 * @type number
 * @min -1000
 * @desc 所持金表示のＹ座標
 * 初期値: 12
 * @default 12
 *
 * @param vnMax
 * @type boolean
 * @desc ゲージタイプ VN の最大値を表示するかどうか
 * 初期値: OFF ( true = ON 表示 / false = OFF 非表示 )
 * @default false
 *
 * @param shakeTime
 * @type number
 * @desc ダメージを受けたときにウィンドウを揺らす時間（フレーム）
 * 初期値: 20 ( 0 で揺らさない )
 * @default 20
 *
 * @param startVisible
 * @type boolean
 * @desc ゲーム開始時の表示状態
 * 初期値: ON（ true = ON 表示 / false = OFF 非表示 ）
 * @default true
 *
 * @param windowOpacity
 * @type number
 * @desc ＨＰゲージウィンドウの不透明度
 * 初期値: 255
 * @default 255
 *
 * @param collideOpacity
 * @type number
 * @max 255
 * @desc プレイヤーと重なったときの不透明度
 * 初期値: 128（ 0 ～ 255 ）
 * @default 128
 *
 * @param messageBusyHide
 * @type boolean
 * @desc メッセージウィンドウ表示中はＨＰゲージウィンドウを隠す
 * 初期値: ON ( true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param eventBusyHide
 * @type boolean
 * @desc イベント起動中はＨＰゲージウィンドウを隠す
 * 初期値: ON（ true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param useBattleScene
 * @type boolean
 * @desc 戦闘シーンでもＨＰゲージウィンドウを表示する。
 * 初期値: OFF（ true = ON 表示 / false = OFF 非表示 )
 * @default false
 *
 * @param gaugeWindowBattleX
 * @type number
 * @min -1000
 * @desc 戦闘シーンのＨＰゲージウィンドウのＸ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowBattleY
 * @type number
 * @min -1000
 * @desc 戦闘シーンのＨＰゲージウィンドウのＹ座標
 * 初期値: 0
 * @default 0
 *
 * @help
 * TMPlugin - マップＨＰゲージ ver1.4.4
 *
 * 使い方:
 *
 *   プラグインパラメータをいじってお好みのＨＰゲージを表示してください。
 *
 *   このプラグインは RPGツクールMV Version 1.6.2 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   showHpGauge
 *     ＨＰゲージウィンドウを表示します。
 *     プラグインパラメータ startVisible が 0 の場合、
 *     このコマンドが実行されるまでＨＰゲージは表示されません。
 *
 *   showHpGauge A
 *     ゲージＡを表示します。プラグインパラメータでタイプが設定されている場合、
 *     ゲーム開始時に自動的に表示状態になります。
 *
 *   hideHpGauge
 *     ＨＰゲージウィンドウを隠します。showHpGauge コマンドが実行されるまで
 *     表示されないままです。
 *
 *   hideHpGauge B
 *     ゲージＢを隠します。showHpGauge B コマンドが実行されるまで
 *     表示されないままです。
 *
 *   moveHpGaugeWindow 100 200
 *     ＨＰゲージウィンドウの位置を X座標 = 100 / Y座標 = 200 の位置へ
 *     移動します。
 *
 *
 * プラグインパラメータ補足:
 *
 *   gaugeA ～ gaugeD
 *
 *     param
 *       ゲージのタイプが VN の場合に、ゲージの現在値として扱う
 *       ゲーム変数番号を設定してください。
 *
 *     max
 *       ゲージのタイプが VN の場合に、ゲージの最大値として扱う
 *       ゲーム変数番号を指定してください。
 *       このパラメータに設定した番号のゲーム変数に値を代入することで、
 *       初めて最大値として機能します。
 *       この設定はゲージの長さにのみ影響します、変数の値が最大値を
 *       超えなくなるような機能はありません。
 *
 *   windowOpacity / collideOpacity
 *     windowOpacity はウィンドウフレーム及び背景に影響し、collideOpacity
 *     はゲージや顔グラフィックにも影響します。
 *     windowOpacity の値が collideOpacity よりも低い場合、プレイヤーと
 *     重なった際の不透明度として windowOpacity の値が適用されます。
 *     ただし、ゲージと顔グラフィックに関しては通常どおり collideOpacity の
 *     値が適用されます。
 *
 *   faceOffsetX
 *     この値を -1000 に設定すると顔グラフィックが非表示となります。
 *
 *   vnMax
 *     値が true なら最大値も表示しますが、現在値と最大値を表示するための
 *     スペースが足りない（ゲージの長さが短い）場合は vnMax の設定に関わらず
 *     強制的に現在値のみの表示になります。
 */
/*~struct~Gauge:
 *
 * @param type
 * @type select
 * @option なし
 * @value
 * @option HP
 * @option MP
 * @option TP
 * @option LV
 * @option VN
 * @desc ゲージのタイプ（HP / MP / TP / LV / VN）
 * 初期値: HP
 * @default HP
 *
 * @param x
 * @type number
 * @min -1000
 * @desc ゲージのＸ座標（ウィンドウ内の左端が 0 ）
 * 初期値: 12
 * @default 12
 *
 * @param y
 * @type number
 * @min -1000
 * @desc ゲージのＹ座標（ウィンドウ内の上端が 0 ）
 * 初期値: 12
 * @default 12
 *
 * @param width
 * @type number
 * @desc ゲージの長さ
 * 初期値: 144
 * @default 144
 *
 * @param height
 * @type number
 * @desc ゲージの表示領域（数値とゲージ合わせて）の高さ
 * 初期値: 36
 * @default 36
 *
 * @param fontSize
 * @type number
 * @desc フォントサイズ
 * 初期値: 28
 * @default 28
 *
 * @param param
 * @type variable
 * @desc ゲージのタイプが VN のときに現在値とするゲーム変数番号
 * 初期値: 0
 * @default 0
 *
 * @param max
 * @type variable
 * @desc ゲージのタイプが VN のときに最大値とするゲーム変数番号
 * 初期値: 0
 * @default 0
 *
 * @param name
 * @type string
 * @desc ゲージのタイプが VN のときに表示するパラメータ名
 * 初期値: AP
 * @default AP
 *
 * @param color
 * @type string
 * @desc ゲージのタイプが LV / VN のときのゲージカラー
 * 初期値: #ff60c0 #ffa0e0
 * @default #ff60c0 #ffa0e0
 */

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

(function () {
  var parameters = PluginManager.parameters("TMMapHpGauge");
  var gaugeWindowX = +(parameters["gaugeWindowX"] || 0);
  var gaugeWindowY = +(parameters["gaugeWindowY"] || 0);
  var gaugeWindowWidth = +(parameters["gaugeWindowWidth"] || 288);
  var gaugeWindowHeight = +(parameters["gaugeWindowHeight"] || 64);
  var gauges = [];
  ["A", "B", "C", "D"].forEach(function (code, i) {
    gauges[i] = JSON.parse(parameters["gauge" + code]);
    gauges[i].x = +gauges[i].x;
    gauges[i].y = +gauges[i].y;
    gauges[i].width = +gauges[i].width;
    gauges[i].height = +gauges[i].height;
    gauges[i].fontSize = +gauges[i].fontSize;
    gauges[i].param = +gauges[i].param;
    gauges[i].max = +gauges[i].max;
    gauges[i].color = gauges[i].color.split(" ");
  });
  var faceOffsetX = +(parameters["faceOffsetX"] || -4);
  var faceOffsetY = +(parameters["faceOffsetY"] || -4);
  var stateIconMax = +(parameters["stateIconMax"] || 4);
  var stateIconX = +(parameters["stateIconX"] || 156);
  var stateIconY = +(parameters["stateIconY"] || 24);
  var stateIconScale = +(parameters["stateIconScale"] || 100);
  var stateIconOpacity = +(parameters["stateIconOpacity"] || 255);
  var goldWidth = +(parameters["goldWidth"] || 0);
  var goldX = +(parameters["goldX"] || 0);
  var goldY = +(parameters["goldY"] || 0);
  var vnMax = JSON.parse(parameters["vnMax"] || "false");
  var shakeTime = +(parameters["shakeTime"] || 20);
  var collideOpacity = +(parameters["collideOpacity"] || 128);
  var startVisible = JSON.parse(parameters["startVisible"] || "true");
  var windowOpacity = +(parameters["windowOpacity"] || 255);
  var messageBusyHide = JSON.parse(parameters["messageBusyHide"] || "true");
  var eventBusyHide = JSON.parse(parameters["eventBusyHide"] || "true");
  var useBattleScene = JSON.parse(parameters["useBattleScene"] || "false");
  var gaugeWindowBattleX = +(parameters["gaugeWindowBattleX"] || 0);
  var gaugeWindowBattleY = +(parameters["gaugeWindowBattleY"] || 0);

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

  Game_System.prototype.isVisibleMapHpGauge = function () {
    if (this._visibleMapHpGauge == null) this._visibleMapHpGauge = startVisible;
    return this._visibleMapHpGauge;
  };

  Game_System.prototype.setVisibleMapHpGauge = function (flag) {
    this._visibleMapHpGauge = flag;
  };

  Game_System.prototype.isVisibleMapHpGauges = function (gaugeId) {
    if (this._visibleMapHpGauges == null) {
      this._visibleMapHpGauges = [];
      for (var i = 0; i < gauges.length; i++) {
        this._visibleMapHpGauges[i] = gauges[i].type !== "";
      }
    }
    return this._visibleMapHpGauges[gaugeId];
  };

  Game_System.prototype.setVisibleMapHpGauges = function (gaugeId, flag) {
    this._visibleMapHpGauges[gaugeId] = flag;
  };

  //-----------------------------------------------------------------------------
  // Game_Interpreter
  //

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "showHpGauge") {
      if (args[0]) {
        var gaugeId = ["A", "B", "C", "D"].indexOf(args[0]);
        $gameSystem.setVisibleMapHpGauges(gaugeId, true);
      } else {
        $gameSystem.setVisibleMapHpGauge(true);
      }
    } else if (command === "hideHpGauge") {
      if (args[0]) {
        var gaugeId = ["A", "B", "C", "D"].indexOf(args[0]);
        $gameSystem.setVisibleMapHpGauges(gaugeId, false);
      } else {
        $gameSystem.setVisibleMapHpGauge(false);
      }
    } else if (command === "moveHpGaugeWindow") {
      $gameSystem._mapHpGaugeWindowX = +args[0];
      $gameSystem._mapHpGaugeWindowY = +args[1];
      if (SceneManager._scene._mapHpGaugeWindow) {
        SceneManager._scene._mapHpGaugeWindow.x = +args[0];
        SceneManager._scene._mapHpGaugeWindow.y = +args[1];
        SceneManager._scene._mapHpGaugeWindow._baseX = +args[0];
      }
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MapHpGauge
  //

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

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

  Window_MapHpGauge.prototype.initialize = function () {
    if (SceneManager.isNextScene(Scene_Battle)) {
      var x = gaugeWindowBattleX;
      var y = gaugeWindowBattleY;
    } else {
      var x =
        $gameSystem._mapHpGaugeWindowX != null
          ? $gameSystem._mapHpGaugeWindowX
          : gaugeWindowX;
      var y =
        $gameSystem._mapHpGaugeWindowY != null
          ? $gameSystem._mapHpGaugeWindowY
          : gaugeWindowY;
    }
    var wight = gaugeWindowWidth;
    var height = gaugeWindowHeight;
    Window_Base.prototype.initialize.call(this, x, y, wight, height);
    this.openness = $gameSystem.isVisibleMapHpGauge() ? 255 : 0;
    this.opacity = windowOpacity;
    this._gaugeParams = [];
    this._gaugeVisible = [];
    for (var i = 0; i < gauges.length; i++) {
      this._gaugeParams.push({ param: -1, max: -1 });
      this._gaugeVisible[i] = $gameSystem.isVisibleMapHpGauges(i);
    }
    this._icons = [];
    this._gold = 0;
    this._actorId = -1;
    this._faceName = "";
    this._faceIndex = "";
    this._shakeDuration = 0;
    this._baseX = x;
    this._needFaceRefresh = false;
    this._hideCount = 0;
  };

  Window_MapHpGauge.prototype.lineHeight = function () {
    return this._lineHeight || 36;
  };

  Window_MapHpGauge.prototype.standardPadding = function () {
    return 0;
  };

  Window_MapHpGauge.prototype.setShake = function (power) {
    this._shakeDuration = power;
  };

  Window_MapHpGauge.prototype.update = function () {
    Window_Base.prototype.update.call(this);
    if (this.updateVisibility()) {
      this.open();
      if (this.isNeedRefresh()) {
        var actor = $gameParty.leader();
        for (var i = 0; i < gauges.length; i++) {
          this._gaugeVisible[i] = $gameSystem.isVisibleMapHpGauges(i);
          var gauge = gauges[i];
          if (gauge.type === "HP") {
            this._gaugeParams[i].param = actor.hp;
            this._gaugeParams[i].max = actor.mhp;
          } else if (gauge.type === "MP") {
            this._gaugeParams[i].param = actor.mp;
            this._gaugeParams[i].max = actor.mmp;
          } else if (gauge.type === "TP") {
            this._gaugeParams[i].param = actor.tp;
            this._gaugeParams[i].max = actor.maxTp();
          } else if (gauge.type === "LV") {
            this._gaugeParams[i].param = actor.currentExp();
            this._gaugeParams[i].max = actor.nextLevelExp();
            this._gaugeParams[i].subParam = actor.level;
          } else if (gauge.type === "VN") {
            this._gaugeParams[i].param = $gameVariables.value(gauge.param);
            this._gaugeParams[i].max = $gameVariables.value(gauge.max);
          }
        }
        this._icons = actor.stateIcons().concat(actor.buffIcons());
        this._gold = $gameParty.gold();
        this._actorId = actor.actorId();
        this._faceName = actor.faceName();
        this._faceIndex = actor.faceIndex();
        this.refresh();
      }
      this.updateShake();
      this.updateOpacity();
    } else {
      this.close();
    }
  };

  Window_MapHpGauge.prototype.updateVisibility = function () {
    if (!$gameSystem.isVisibleMapHpGauge()) {
      return false;
    }
    if ($gameParty.inBattle()) {
      return true;
    }
    if (
      (eventBusyHide && $gameMap.isEventRunning()) ||
      (messageBusyHide && $gameMessage.isBusy())
    ) {
      this._hideCount++;
    } else {
      this._hideCount = 0;
    }
    return this._hideCount < 10 && $gameParty.leader();
  };

  Window_MapHpGauge.prototype.isNeedRefresh = function () {
    var actor = $gameParty.leader();
    if (actor) {
      var result = false;
      if (this._actorId !== actor.actorId()) {
        this.setShake(1);
        return true;
      }
      for (var i = 0; i < gauges.length; i++) {
        if (this._gaugeVisible[i] !== $gameSystem.isVisibleMapHpGauges(i)) {
          result = true;
        }
        var gauge = gauges[i];
        var gaugeParam = this._gaugeParams[i];
        if (gauge.type === "HP") {
          if (gaugeParam.param !== actor.hp || gaugeParam.max !== actor.mhp) {
            if (gaugeParam.param > actor.hp) {
              this.setShake(shakeTime);
            }
            result = true;
          }
        } else if (gauge.type === "MP") {
          if (gaugeParam.param !== actor.mp || gaugeParam.max !== actor.mmp) {
            result = true;
          }
        } else if (gauge.type === "TP") {
          if (
            gaugeParam.param !== actor.tp ||
            gaugeParam.max !== actor.maxTp()
          ) {
            result = true;
          }
        } else if (gauge.type === "LV") {
          if (
            gaugeParam.param !== actor.currentExp() ||
            gaugeParam.max !== actor.nextLevelExp() ||
            gaugeParam.subParam !== actor.level
          ) {
            result = true;
          }
        } else if (gauge.type === "VN") {
          if (
            gaugeParam.param !== $gameVariables.value(gauge.param) ||
            gaugeParam.max !== $gameVariables.value(gauge.max)
          ) {
            result = true;
          }
        }
      }
      if (stateIconMax > 0) {
        var icons = actor.stateIcons().concat(actor.buffIcons());
        if (this._icons.toString() !== icons.toString()) {
          result = true;
        }
      }
      if (goldWidth > 0 && this._gold !== $gameParty.gold()) {
        result = true;
      }
    }
    if (this._needFaceRefresh) {
      this.refreshFace();
      if (!this._needFaceRefresh) {
        result = true;
      }
    }
    return result;
  };

  Window_MapHpGauge.prototype.updateShake = function () {
    if (this._shakeDuration > 0) {
      this._shakeDuration--;
      this.x = this._baseX;
      if (this._shakeDuration > 0) {
        this.x += Math.floor(
          Math.sin(((this._shakeDuration % 10) * Math.PI) / 5) * 8
        );
      }
    }
  };

  Window_MapHpGauge.prototype.updateOpacity = function () {
    if (
      this.x < $gamePlayer.screenX() + 24 &&
      this.x + gaugeWindowWidth > $gamePlayer.screenX() - 24 &&
      this.y < $gamePlayer.screenY() &&
      this.y + gaugeWindowHeight > $gamePlayer.screenY() - 48
    ) {
      this.opacity = Math.min(collideOpacity, windowOpacity);
      this.contentsOpacity = collideOpacity;
    } else {
      this.opacity = windowOpacity;
      this.contentsOpacity = 255;
    }
  };

  Window_MapHpGauge.prototype.refresh = function () {
    this.contents.clear();
    var actor = $gameParty.leader();
    if (actor) {
      this.refreshFace();
      for (var i = 0; i < gauges.length; i++) {
        if (!$gameSystem.isVisibleMapHpGauges(i)) {
          continue;
        }
        var gauge = gauges[i];
        this._lineHeight = gauge.height;
        this.contents.fontSize = gauge.fontSize;
        if (gauge.type === "HP") {
          this.drawActorHp(actor, gauge.x, gauge.y, gauge.width);
        } else if (gauge.type === "MP") {
          this.drawActorMp(actor, gauge.x, gauge.y, gauge.width);
        } else if (gauge.type === "TP") {
          this.drawActorTp(actor, gauge.x, gauge.y, gauge.width);
        } else if (gauge.type === "LV") {
          this.drawLvGauge(actor, gauge);
        } else if (gauge.type === "VN") {
          this.drawVnGauge(this._gaugeParams[i], gauge);
        }
      }
      for (var i = 0; i < stateIconMax; i++) {
        if (!this._icons[i]) break;
        var x =
          stateIconX +
          i * Math.floor((Window_Base._iconWidth * stateIconScale) / 100);
        this.drawIcon(this._icons[i], x, stateIconY);
      }
      if (goldWidth > 0) {
        this.drawCurrencyValue(
          this._gold,
          TextManager.currencyUnit,
          goldX,
          goldY,
          goldWidth
        );
      }
      this._lineHeight = 36;
    }
  };

  Window_MapHpGauge.prototype.drawIcon = function (iconIndex, x, y) {
    var bitmap = ImageManager.loadSystem("IconSet");
    var pw = Window_Base._iconWidth;
    var ph = Window_Base._iconHeight;
    var sx = (iconIndex % 16) * pw;
    var sy = Math.floor(iconIndex / 16) * ph;
    var dw = Math.floor((pw * stateIconScale) / 100);
    var dh = Math.floor((ph * stateIconScale) / 100);
    var lastPaintOpacity = this.contents.paintOpacity;
    this.contents.paintOpacity = stateIconOpacity;
    this.contents.blt(bitmap, sx, sy, pw, ph, x, y, dw, dh);
    this.contents.paintOpacity = lastPaintOpacity;
  };

  Window_MapHpGauge.prototype.drawLvGauge = function (actor, gauge) {
    if (actor.isMaxLevel()) {
      var value1 = "-------";
      var value2 = "-------";
      var rate = 1;
    } else {
      var n = actor.currentLevelExp();
      var value1 = actor.currentExp() - n;
      var value2 = actor.nextLevelExp() - n;
      var rate = value1 / value2;
    }
    this.drawGauge(
      gauge.x,
      gauge.y,
      gauge.width,
      rate,
      gauge.color[0],
      gauge.color[1]
    );
    this.changeTextColor(this.systemColor());
    this.drawText(TextManager.levelA, gauge.x, gauge.y, 44);
    var color = this.normalColor();
    this.changeTextColor(color);
    var width = this.textWidth(TextManager.levelA) + 4;
    this.drawText(actor.level, gauge.x + width, gauge.y, 44);
    width = gauge.width - width - this.textWidth("" + actor.level);
    this.drawCurrentAndMax(
      value1,
      value2,
      gauge.x + gauge.width - width,
      gauge.y,
      width,
      color,
      color
    );
  };

  Window_MapHpGauge.prototype.drawVnGauge = function (params, gauge) {
    var rate = params.max === 0 ? 0 : params.param / params.max;
    this.drawGauge(
      gauge.x,
      gauge.y,
      gauge.width,
      rate,
      gauge.color[0],
      gauge.color[1]
    );
    this.changeTextColor(this.systemColor());
    this.drawText(gauge.name, gauge.x, gauge.y, this.textWidth(gauge.name));
    this.changeTextColor(this.normalColor());
    if (vnMax) {
      this.drawVnCurrentAndMax(
        gauge.name,
        params.param,
        params.max,
        gauge.x,
        gauge.y,
        gauge.width
      );
    } else {
      this.drawText(
        params.param,
        gauge.x + gauge.width - 64,
        gauge.y,
        64,
        "right"
      );
    }
  };

  Window_MapHpGauge.prototype.drawVnCurrentAndMax = function (
    name,
    current,
    max,
    x,
    y,
    width
  ) {
    var labelWidth = this.textWidth(name);
    var valueWidth = this.textWidth("0" + max);
    var slashWidth = this.textWidth("/");
    var x1 = x + width - valueWidth;
    var x2 = x1 - slashWidth;
    var x3 = x2 - valueWidth;
    this.changeTextColor(this.normalColor());
    if (x3 >= x + labelWidth) {
      this.drawText(current, x3, y, valueWidth, "right");
      this.drawText("/", x2, y, slashWidth, "right");
      this.drawText(max, x1, y, valueWidth, "right");
    } else {
      this.drawText(current, x1, y, valueWidth, "right");
    }
  };

  Window_MapHpGauge.prototype.refreshFace = function () {
    if (faceOffsetX === -1000) {
      return;
    }
    var actor = $gameParty.leader();
    var bitmap = ImageManager.loadFace(actor.faceName());
    this._needFaceRefresh = bitmap.width === 0;
    if (!this._needFaceRefresh) {
      var x = gaugeWindowWidth - 144 + faceOffsetX;
      var y = faceOffsetY;
      var height = Math.min(gaugeWindowHeight, 144);
      this.drawFace(actor.faceName(), actor.faceIndex(), x, y, 144, height);
    }
  };

  //-----------------------------------------------------------------------------
  // Scene_Base
  //

  Scene_Base.prototype.createMapHpGaugeWindow = function () {
    this._mapHpGaugeWindow = new Window_MapHpGauge();
    this.addChild(this._mapHpGaugeWindow);
  };

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

  var _Scene_Map_createDisplayObjects =
    Scene_Map.prototype.createDisplayObjects;
  Scene_Map.prototype.createDisplayObjects = function () {
    _Scene_Map_createDisplayObjects.call(this);
    this.createMapHpGaugeWindow();
  };

  var _Scene_Map_terminate = Scene_Map.prototype.terminate;
  Scene_Map.prototype.terminate = function () {
    if (!SceneManager.isNextScene(Scene_Battle)) this._mapHpGaugeWindow.hide();
    _Scene_Map_terminate.call(this);
    this.removeChild(this._mapHpGaugeWindow);
  };

  var _Scene_Map_launchBattle = Scene_Map.prototype.launchBattle;
  Scene_Map.prototype.launchBattle = function () {
    this._mapHpGaugeWindow.hide();
    _Scene_Map_launchBattle.call(this);
  };

  //-----------------------------------------------------------------------------
  // Scene_Battle
  //

  var _Scene_Battle_createDisplayObjects =
    Scene_Battle.prototype.createDisplayObjects;
  Scene_Battle.prototype.createDisplayObjects = function () {
    _Scene_Battle_createDisplayObjects.call(this);
    if (useBattleScene) {
      this.createMapHpGaugeWindow();
    }
  };

  var _Scene_Battle_terminate = Scene_Battle.prototype.terminate;
  Scene_Battle.prototype.terminate = function () {
    _Scene_Battle_terminate.call(this);
    if (this._mapHpGaugeWindow) {
      this.removeChild(this._mapHpGaugeWindow);
    }
  };
})();

repo_name: Idkwtcm/violated

license: unknown


code:
//=============================================================================
// TMPlugin - 移動機能拡張
// バージョン: 1.3.1
// 最終更新日: 2017/06/16
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2015 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc 壁衝突音やリージョンによる通行設定などの機能を追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param passableRegionId
 * @type number
 * @desc タイルに関係なく通行を可能にするリージョン番号
 * 初期値: 251
 * @default 251
 *
 * @param dontPassRegionId
 * @type number
 * @desc タイルに関係なく通行を不可にするリージョン番号
 * 初期値: 252
 * @default 252
 *
 * @param knockWallSe
 * @desc 壁衝突時に鳴らす効果音のファイル名
 * 初期値: Blow1
 * @default Blow1
 * @require 1
 * @dir audio/se/
 * @type file
 *
 * @param knockWallSeParam
 * @type string
 * @desc 壁衝突時に鳴らす効果音のパラメータ
 * 初期値: {"volume":90, "pitch":100}
 * @default {"volume":90, "pitch":100}
 *
 * @param knockWallPan
 * @type number
 * @desc 壁衝突効果音の左右バランス
 * 初期値: 75
 * @default 75
 *
 * @param knockWallInterval
 * @type number
 * @desc 壁衝突効果音の再生間隔（フレーム数）
 * 初期値: 30
 * @default 30
 *
 * @param turnKeyCode
 * @type string
 * @desc その場で向き変更に使うキー
 * 初期値: S
 * @default S
 *
 * @param movableRegion1
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定１番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion2
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定２番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion3
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定３番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion4
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定４番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion5
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定５番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion6
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定６番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion7
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定７番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion8
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定８番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion9
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定９番
 * 設定例: 1,2,3
 * @default
 *
 * @param movableRegion10
 * @type string
 * @desc イベントの移動可能リージョンタイプ設定１０番
 * 設定例: 1,2,3
 * @default
 *
 * @help
 * TMPlugin - 移動機能拡張 ver1.3.1
 *
 * 使い方:
 *
 *   Ｓキーを押しながら方向キーを押すと、移動せずにプレイヤーの向きだけを
 *   変えることができます。マウス（タップ）操作の場合はプレイヤーがいる場所
 *   をクリックすることで、時計回りに９０度回転します。
 *
 *   その場で移動せずに向きを変更する機能で使用するキーは turnKeyCode の値を
 *   変更することで設定できます。ＸやＺなど標準機能ですでに使用しているキーは
 *   設定しないでください。
 *
 *   メモ欄タグを使って、イベントごとに移動可能なリージョンを変更できます。
 *   プラグインパラメータで移動可能リージョンタイプをカスタマイズしてから
 *   利用してください。
 *   たとえば movableRegion1 の値を 1,2,3 にして、イベントのメモ欄に
 *   <movableRegion:1> というタグを書いた場合、そのイベントはリージョンが
 *   １～３番の場所のみ移動できるようになります。
 *
 *   このプラグインは RPGツクールMV Version 1.5.0 で動作確認をしています。
 *
 *
 * メモ欄タグ（イベント）:
 *
 *   <movableRegion:1>
 *     移動可能リージョンタイプを１番に設定する
 *
 *   <stepSwitchOnA:64>
 *     イベントが移動してリージョン６４番を踏むとセルフスイッチＡをオン
 *     Ａ以外のセルフスイッチを使用する場合は stepSwitchOnB のようにして
 *     ください。
 *
 *   <stepSwitchOffB:65>
 *     イベントが移動してリージョン６５番を踏むとセルフスイッチＢをオフ
 *
 *   上記タグはイベントコマンド『注釈』に書き込むことでも機能します。
 *   メモ欄と注釈の両方にタグがあった場合、注釈の方が優先されます。
 *
 *
 * プラグインコマンド:
 *
 *   regionLocate 3 20
 *     ３番のイベントをリージョン２０番が設定されている座標のどこかへ場所移動
 *     させます。
 *     イベント番号が 0 ならコマンドを実行したイベント自体、-1 ならプレイヤー
 *     を対象とします。
 */

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

var TMPlugin = TMPlugin || {};
if (!TMPlugin.EventBase) {
  TMPlugin.EventBase = true;
  (function () {
    var _Game_Event_setupPage = Game_Event.prototype.setupPage;
    Game_Event.prototype.setupPage = function () {
      _Game_Event_setupPage.call(this);
      if (this._pageIndex >= 0) this.loadCommentParams();
    };

    Game_Event.prototype.loadCommentParams = function () {
      this._commentParams = {};
      var re = /<([^<>:]+)(:?)([^>]*)>/g;
      var list = this.list();
      for (var i = 0; i < list.length; i++) {
        var command = list[i];
        if ((command && command.code == 108) || command.code == 408) {
          for (;;) {
            var match = re.exec(command.parameters[0]);
            if (match) {
              this._commentParams[match[1]] =
                match[2] === ":" ? match[3] : true;
            } else {
              break;
            }
          }
        } else {
          break;
        }
      }
    };

    Game_Event.prototype.loadTagParam = function (paramName) {
      return this._commentParams[paramName] || this.event().meta[paramName];
    };
  })();
} // TMPlugin.EventBase

(function () {
  var parameters = PluginManager.parameters("TMMoveEx");
  var passableRegionId = +(parameters["passableRegionId"] || 251);
  var dontPassRegionId = +(parameters["dontPassRegionId"] || 252);
  var knockWallSe = JSON.parse(parameters["knockWallSeParam"] || "{}");
  knockWallSe.name = parameters["knockWallSe"] || "";
  var knockWallPan = +(parameters["knockWallPan"] || 75);
  var knockWallInterval = +(parameters["knockWallInterval"] || 30);
  var movableRegionType = [];
  for (var i = 1; i <= 10; i++) {
    movableRegionType[i] = parameters["movableRegion" + i].split(",");
  }

  //-----------------------------------------------------------------------------
  // Input
  //

  Input.keyMapper[parameters["turnKeyCode"].charCodeAt()] = "turn";

  //-----------------------------------------------------------------------------
  // 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 (regionId === passableRegionId) return true;
    if (regionId === dontPassRegionId) return false;
    return _Game_Map_checkPassage.call(this, x, y, bit);
  };

  Game_Map.prototype.regionPoints = function (regionId) {
    var result = [];
    for (var x = 0; x < this.width(); x++) {
      for (var y = 0; y < this.height(); y++) {
        if (this.regionId(x, y) === regionId && this.eventIdXy(x, y) === 0) {
          result.push(new Point(x, y));
        }
      }
    }
    return result;
  };

  Game_Map.prototype.regionPointRandom = function (regionId) {
    var regionPoints = this.regionPoints(regionId);
    if (regionPoints.length === 0) return null;
    return regionPoints[Math.randomInt(regionPoints.length)];
  };

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

  var _Game_Player_moveStraight = Game_Player.prototype.moveStraight;
  Game_Player.prototype.moveStraight = function (d) {
    _Game_Player_moveStraight.call(this, d);
    if (!this.isMovementSucceeded()) {
      var x2 = $gameMap.roundXWithDirection(this.x, d);
      var y2 = $gameMap.roundYWithDirection(this.y, d);
      if (
        this.isNormal() &&
        ($gameMap.boat().pos(x2, y2) || $gameMap.ship().pos(x2, y2))
      )
        return;
      if (
        this.isInVehicle() &&
        this.vehicle().isLandOk(this.x, this.y, this.direction())
      )
        return;
      var d2 = this.reverseDir(d);
      if (
        !$gameMap.isPassable(this.x, this.y, d) ||
        !$gameMap.isPassable(x2, y2, d2)
      ) {
        this._knockWallCount =
          this._knockWallCount == null ? 0 : this._knockWallCount;
        if (
          this._knockWallCount + knockWallInterval <= Graphics.frameCount ||
          this._lastKnockWallDir !== d
        ) {
          if (d === 4) {
            knockWallSe.pan = -knockWallPan;
          } else if (d === 6) {
            knockWallSe.pan = knockWallPan;
          } else {
            knockWallSe.pan = 0;
          }
          AudioManager.playSe(knockWallSe);
          this._knockWallCount = Graphics.frameCount;
          this._lastKnockWallDir = d;
        }
      }
    }
  };

  var _Game_Player_moveByInput = Game_Player.prototype.moveByInput;
  Game_Player.prototype.moveByInput = function () {
    if (!this.isMoving() && this.canMove()) {
      var direction = this.getInputDirection();
      if (Input.isPressed("turn") && direction > 0) {
        this.setDirection(direction);
        return;
      }
      if (TouchInput.isTriggered() && $gameTemp.isDestinationValid()) {
        var x = $gameTemp.destinationX();
        var y = $gameTemp.destinationY();
        if (this.pos(x, y)) {
          this.turnRight90();
          return;
        }
      }
    }
    _Game_Player_moveByInput.call(this);
  };

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

  var _Game_Event_isMapPassable = Game_Event.prototype.isMapPassable;
  Game_Event.prototype.isMapPassable = function (x, y, d) {
    var movableRegion = this.loadTagParam("movableRegion");
    if (movableRegion) {
      var x2 = $gameMap.roundXWithDirection(x, d);
      var y2 = $gameMap.roundYWithDirection(y, d);
      var region = $gameMap.regionId(x2, y2);
      return movableRegionType[+movableRegion].indexOf("" + region) >= 0;
    } else {
      return _Game_Event_isMapPassable.call(this, x, y, d);
    }
  };

  var _Game_Event_moveStraight = Game_Event.prototype.moveStraight;
  Game_Event.prototype.moveStraight = function (d) {
    _Game_Event_moveStraight.call(this, d);
    ["A", "B", "C", "D"].forEach(function (code) {
      var regionId = this.loadTagParam("stepSwitchOn" + code);
      if (regionId && this.regionId() === +regionId) {
        var key = [$gameMap.mapId(), this.eventId(), code];
        $gameSelfSwitches.setValue(key, true);
      } else {
        regionId = this.loadTagParam("stepSwitchOff" + code);
        if (regionId && this.regionId() === +regionId) {
          var key = [$gameMap.mapId(), this.eventId(), code];
          $gameSelfSwitches.setValue(key, false);
        }
      }
    }, this);
  };

  //-----------------------------------------------------------------------------
  // Game_Interpreter
  //

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "regionLocate") {
      var character = this.character(+args[0]);
      if (character) {
        var point = $gameMap.regionPointRandom(+args[1]);
        if (point) character.locate(point.x, point.y);
      }
    }
  };
})();


code:
//=============================================================================
// TemplateEvent.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 2.1.3 2020/03/16 プラグインパラメータ『上書き対象項目』の初期値を設定
// 2.1.2 2019/06/09 EventReSpawn.jsで生成したテンプレートイベントがgetTemplateIdを取得できない問題を修正
// 2.1.1 2019/04/14 2.1.0の機能で、統合ではなく上書きできる機能を追加
// 2.1.0 2019/04/07 テンプレートイベントと個別イベントとでメモ欄を統合できる機能を追加
// 2.0.0 2018/10/21 イベント設定の項目ごとにテンプレートイベントの設定を固有イベントで上書きできるよう修正
//                  それに伴い、上書きに関する既存設定を見直しました。
// 1.8.3 2018/10/16 1.8.2の競合対策によって、別のプラグインと競合が発生する可能性がある記述を修正
// 1.8.2 2018/10/14 OnlineAvatar.jsとの併用時、起動時にエラーになる問題を解消
// 1.8.1 2018/10/14 ParallaxTitle.jsとの競合を解消
// 1.8.0 2018/05/27 セルフ変数のキーに数値ではなく文字列を使用できるよう修正
// 1.7.1 2017/09/01 スクリプトヘルプの誤記を修正
// 1.7.0 2017/08/29 プラグインコマンドで制御文字\sv[n]が利用できる機能を追加
// 1.6.1 2017/08/26 セルフ変数に文字列が入っている場合でも出現条件の注釈が正しく動作するよう修正
// 1.6.0 2017/08/19 セルフ変数の一括操作のコマンドおよびセルフ変数を外部から操作するスクリプトを追加
// 1.5.1 2017/08/15 文章のスクロール表示でセルフ変数が正しく表示できていなかった問題を修正
// 1.5.0 2017/08/14 セルフ変数の操作を「移動ルートの設定」からも行えるよう修正
// 1.4.1 2017/07/21 SAN_MapGenerator.jsとの競合を解消
// 1.4.0 2017/07/16 セルフ変数機能を追加
// 1.3.0 2017/07/07 固有処理呼び出し中にテンプレートイベントのIDと名称を取得できるスクリプトを追加
// 1.2.0 2017/06/09 設定を固有イベントで上書きする機能を追加。それに伴い既存のパラメータ名称を一部変更
// 1.1.2 2017/06/03 固有イベントのグラフィックで上書きした場合は、オプションと向き、パターンも固有イベントで上書きするよう変更
// 1.1.1 2017/05/25 場所移動直後にアニメパターンが一瞬だけ初期化されてしまう問題を修正
// 1.1.0 2017/04/22 テンプレートイベントIDに変数の値を指定できる機能を追加
// 1.0.2 2017/04/09 イベント生成系のプラグインで発生する可能性のある競合を解消
// 1.0.1 2016/06/28 固有イベントのページ数がテンプレートイベントのページ数より少ない場合に発生するエラーを修正
// 1.0.0 2016/06/12 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Template Event Plugin
 * @author triacontane
 *
 * @param TemplateMapId
 * @desc The map ID where the template event resides.
 * @default 1
 * @type number
 *
 * @param KeepEventId
 * @desc Maintain the event ID of the caller when invoking the map event.
 * @default false
 * @type boolean
 *
 * @param OverrideTarget
 * @desc メモ欄で上書き(テンプレートイベントより固有イベントの設定を優先)指定したイベントの上書き対象項目を設定します。
 * @default {"Image":"true","Direction":"false","Move":"false","Priority":"false","Trigger":"false","Option":"false"}
 * @type struct<override>
 *
 * @param AutoOverride
 * @desc メモ欄で上書き設定をしなくても「上書き対象項目」の設定を上書きします。
 * @default false
 * @type boolean
 *
 * @param IntegrateNote
 * @desc テンプレートイベントと固有イベントのメモ欄を統合もしくは上書きします。
 * @default 0
 * @type select
 * @option None
 * @value 0
 * @option Integrate
 * @value 1
 * @option Override
 * @value 2
 *
 * @help TemplateEvent.js[Template Event Plugin]
 *
 * You can template commonly used events.
 * Please define the template event in the map prepared exclusively.
 * Just by writing a predetermined description in the note of the actual event,
 * It can be replaced dynamically.
 *
 * You can also call up the source event from the template event.
 * It is effective when you want to do some unique processing,
 * such as treasure boxes and place movement events.
 * Describe the appearance and event processing of the common part
 * in the template event,
 * We describe only the unique part such as item acquisition and
 * location destination designation in the original event.
 *
 * It also provides a function to call an arbitrary map event like a common event.
 * Events to be called can be specified by ID and event name.
 *
 * Procedure
 * 1.Create a template map and place a template event.
 *
 * 2.Write a memo field of the event you want to replace
 * with the template event. Both ID and event name can be specified.
 * <TE:1>   It is replaced with the event of ID [1] of the template map.
 * <TE:aaa> It is replaced with the event of event name [aaa] of the template map.
 * <TE:\v[1]> It is replaced with the event of ID of template map [value of variable [1]].
 *
 * In principle, all settings except initial placement will be replaced with
 * template event settings If you specify graphics as an exception and when you
 * write a memo field (* 1)
 * Priority is given to the settings of unique events for the following settings.
 * Image
 * Autonomous Movement
 * Options
 * Priority
 * Trigger
 *
 * *1 Write it in the memo field of the unique event as follows.
 * <TEOverRide>
 *
 * Plugin Command
 *
 * TE_CALL_ORIGIN_EVENT [PageIndex]
 *  Call up the event processing of the replacement source. After processing is completed,
 *  it returns to the original processing. If you omit the page number, the running page
 *  number is applied as it is. It is effective only when described in the template event.
 *
 *  ex
 *  TE_CALL_ORIGIN_EVENT 1
 *
 * TE_CALL_MAP_EVENT [EventId] [PageIndex]
 *  Call up another event processing in the same map. After processing is completed,
 *  it returns to the original processing. If you specify an event ID other than a numeric value,
 *  it calls processing of an event that is treated as an event name and whose event name matches.
 *  It is valid even if it is described in the template event.
 *
 *  ex1
 *  TE_CALL_MAP_EVENT 5 1
 *
 *  ex2
 *  TE_CALL_MAP_EVENT aaa 1
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc テンプレートイベントプラグイン
 * @author トリアコンタン
 *
 * @param TemplateMapId
 * @text テンプレートマップID
 * @desc テンプレートイベントが存在するマップIDです。
 * @default 1
 * @type number
 *
 * @param KeepEventId
 * @text イベントIDを維持
 * @desc マップイベントを呼び出す際に、呼び出し元のイベントIDを維持します。対象を「このイベント」にした際の挙動が変わります。
 * @default false
 * @type boolean
 *
 * @param OverrideTarget
 * @text 上書き対象項目
 * @desc メモ欄で上書き(テンプレートイベントより固有イベントの設定を優先)指定したイベントの上書き対象項目を設定します。
 * @default {"Image":"true","Direction":"false","Move":"false","Priority":"false","Trigger":"false","Option":"false"}
 * @type struct<override>
 *
 * @param AutoOverride
 * @text 自動上書き
 * @desc メモ欄で上書き設定をしなくても「上書き対象項目」の設定を上書きします。
 * @default false
 * @type boolean
 *
 * @param IntegrateNote
 * @text メモ欄統合
 * @desc テンプレートイベントと固有イベントのメモ欄を統合もしくは上書きします。
 * @default 0
 * @type select
 * @option 何もしない
 * @value 0
 * @option 統合
 * @value 1
 * @option 上書き
 * @value 2
 *
 * @help TemplateEvent.js[テンプレートイベントプラグイン]
 *
 * 汎用的に使用するイベントをテンプレート化できます。
 * テンプレートイベントは、専用に用意したマップに定義してください。
 * 実際のイベントのメモ欄に所定の記述をするだけで、テンプレートイベントと
 * 動的に置き換えることができます。
 *
 * またテンプレートイベントから置き換え元のイベントを呼び出すことができます。
 * 宝箱や場所移動イベント等、一部だけ固有の処理をしたい場合に有効です。
 * 外観や共通部分のイベント処理をテンプレートイベントに記述し、
 * アイテム入手や場所移動先指定など固有部分だけを元のイベントに記述します。
 *
 * 任意のマップイベントをコモンイベントのように呼び出す機能も提供します。
 * IDおよびイベント名で呼び出すイベントを指定可能です。
 *
 * 利用手順
 * 1.テンプレートマップを作成して、テンプレートイベントを配置します。
 *
 * 2.テンプレートイベントに置き換えたいイベントのメモ欄を記述します。
 *   IDとイベント名の双方が指定可能です。
 * <TE:1>   テンプレートマップのID[1]のイベントに置き換わります。
 * <TE:aaa> テンプレートマップのイベント名[aaa]のイベントに置き換わります。
 * <TE:\v[1]> テンプレートマップのID[変数[1]の値]のイベントに置き換わります。
 *
 * 原則、初期配置以外の全設定はテンプレートイベントの設定に置き換わりますが
 * 例外としてメモ欄(※1)を記述した場合は
 * 以下の任意の設定について固有イベントの設定で上書きします。
 * ・画像
 * ・自律移動
 * ・オプション
 * ・プライオリティ
 * ・トリガー
 *
 * ※1 固有イベントのメモ欄に以下の通り記述します。
 * <TE上書き>
 * <TEOverRide>
 *
 * ・セルフ変数機能
 * イベントに対してセルフ変数（そのイベント専用の変数）を定義できます。
 * プラグインコマンドから操作し、文章の表示やイベント出現条件として使用可能です。
 *
 * 「文章の表示」で使用する場合
 * 制御文字「\sv[n](n:インデックス)」で表示できます。
 *
 * 「イベント出現条件」で使用する場合
 * 対象ページのイベントコマンドの先頭を「注釈」にして
 * 以下の書式で条件を指定してください。複数指定も可能です。
 *
 * \TE{条件}
 *
 * 条件はJavaScriptとしてで記述し、制御文字が使用可能です。
 * 指定例：
 * \TE{\sv[1] >= 3}      # セルフ変数[1]が3以上の場合
 * \TE{\sv[2] === \v[1]} # セルフ変数[2]が変数[1]と等しい場合
 * \TE{\sv[3] === 'AAA'} # セルフ変数[3]が'AAA'と等しい場合
 *
 * 「条件分岐」などのスクリプトで使用する場合
 * 以下のスクリプトで指定したインデックスのセルフ変数が取得できます。
 * this.getSelfVariable(n)
 * 指定例：
 * this.getSelfVariable(1) !== 0 # セルフ変数[1]が3以上の場合
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * TE固有イベント呼び出し [ページ番号]
 * TE_CALL_ORIGIN_EVENT [ページ番号]
 *  置き換え元のイベント処理を呼び出します。処理完了後、元の処理に戻ります。
 *  ページ番号を省略すると、実行中のページ番号がそのまま適用されます。
 *  テンプレートイベントに記述した場合のみ有効です。
 *
 *  例1:置き換え元イベントの1ページ目を呼び出します。
 *  TE固有イベント呼び出し 1
 *
 * TEマップイベント呼び出し [イベントID] [ページ番号]
 * TE_CALL_MAP_EVENT [イベントID] [ページ番号]
 *  同一マップ内の別イベント処理を呼び出します。処理完了後、元の処理に戻ります。
 *  イベントIDに数値以外を指定すると、イベント名として扱われ
 *  イベント名が一致するイベントの処理を呼び出します。
 *  テンプレートイベントに記述した場合以外でも有効です。
 *
 *  例1:ID[5]のイベントの1ページ目を呼び出します。
 *  TEマップイベント呼び出し 5 1
 *
 *  例2:[aaa]という名前のイベントの1ページ目を呼び出します。
 *  TEマップイベント呼び出し aaa 1
 *
 * TEセルフ変数の操作 [インデックス] [操作種別] [オペランド]
 * TE_SET_SELF_VARIABLE [インデックス] [操作種別] [オペランド]
 *  セルフ変数を操作します。
 *  インデックス : 操作対象のセルフ変数のインデックスです。1以上の数値を指定
 *  操作種別     : 操作種別です。以下の通り指定してください。
 *   0 : 代入
 *   1 : 加算
 *   2 : 減算
 *   3 : 乗算
 *   4 : 除算
 *   5 : 剰余
 *  オペランド   : 設定値です。数値を指定してください。
 * ※セルフ変数に数値以外を設定したい場合は、スクリプトで指定してください。
 *
 *  例1:インデックス[1]のセルフ変数に値[100]を代入します。
 *  TE_SET_SELF_VARIABLE 1 0 100
 *
 *  例2:インデックス[3]のセルフ変数から値[50]を減算します。
 *  TE_SET_SELF_VARIABLE 3 2 50
 *
 *  例2:インデックス[5]のセルフ変数に値[セルフ変数[1]の値]を加算します。
 *  TE_SET_SELF_VARIABLE 5 1 \sv[1]
 *
 * TEセルフ変数の一括操作 [開始INDEX] [終了INDEX] [操作種別] [オペランド]
 * TE_SET_RANGE_SELF_VARIABLE [開始INDEX] [終了INDEX] [操作種別] [オペランド]
 *  セルフ変数を一括操作します。
 *
 * 本プラグインのすべてのプラグインコマンドで制御文字\sv[n]を使用できます。
 *
 * ・スクリプト（イベントコマンドのスクリプト、変数の操作から実行）
 * 固有処理呼び出し中にテンプレートイベントのIDと名称を取得します。
 *  this.character(0).getTemplateId();
 *  this.character(0).getTemplateName();
 *
 * 指定したインデックスのセルフ変数を取得します。
 *  this.getSelfVariable(index);
 *
 * セルフ変数に値を設定します。
 * このスクリプトは「移動ルートの設定」でも実行できます。
 * formulaFlgをtrueに設定すると、operandを計算式として評価します。
 *  this.controlSelfVariable(index, type, operand, formulaFlg);
 *
 * セルフ変数に値を一括設定します。
 * このスクリプトは「移動ルートの設定」でも実行できます。
 *  this.controlSelfVariableRange(start, end, type, operand, formulaFlg);
 *
 * 外部のイベントのセルフ変数を操作します。
 *  $gameSelfSwitches.setVariableValue([マップID, イベントID, INDEX], 設定値);
 *
 * 外部のイベントのセルフ変数を取得します。
 *  $gameSelfSwitches.getVariableValue([マップID, イベントID, INDEX]);
 *
 * SAN_MapGenerator.jsと組み合わせる場合
 * このプラグインをSAN_MapGenerator.jsより下に定義してください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~override:
 *
 * @param Image
 * @text 画像
 * @desc イベントの画像および画像インデックスです。
 * @type boolean
 * @default false
 *
 * @param Direction
 * @text 向き
 * @desc イベントの向き及びアニメパターンです。
 * @type boolean
 * @default false
 *
 * @param Move
 * @text 自律移動
 * @desc イベントの自律移動です。
 * @type boolean
 * @default false
 *
 * @param Priority
 * @text プライオリティ
 * @desc イベントのプライオリティです。
 * @type boolean
 * @default false
 *
 * @param Trigger
 * @text トリガー
 * @desc イベントのトリガーです。
 * @type boolean
 * @default false
 *
 * @param Option
 * @text オプション
 * @desc イベントのオプションです。
 * @type boolean
 * @default false
 */

var $dataTemplateEvents = null;

(function () {
  "use strict";
  var metaTagPrefix = "TE";

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

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

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

  var convertEscapeCharacters = function (text) {
    if (isNotAString(text)) text = "";
    text = text.replace(/\\/g, "\x1b");
    text = text.replace(/\x1b\x1b/g, "\\");
    text = text.replace(
      /\x1bV\[(\d+)]/gi,
      function () {
        return $gameVariables.value(parseInt(arguments[1]));
      }.bind(this)
    );
    text = text.replace(
      /\x1bV\[(\d+)]/gi,
      function () {
        return $gameVariables.value(parseInt(arguments[1]));
      }.bind(this)
    );
    text = text.replace(
      /\x1bN\[(\d+)]/gi,
      function () {
        var actor =
          parseInt(arguments[1]) >= 1
            ? $gameActors.actor(parseInt(arguments[1]))
            : null;
        return actor ? actor.name() : "";
      }.bind(this)
    );
    text = text.replace(
      /\x1bP\[(\d+)]/gi,
      function () {
        var actor =
          parseInt(arguments[1]) >= 1
            ? $gameParty.members()[parseInt(arguments[1]) - 1]
            : null;
        return actor ? actor.name() : "";
      }.bind(this)
    );
    text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
    return text;
  };

  var isNotAString = function (args) {
    return String(args) !== args;
  };

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

  var convertAllArguments = function (args) {
    return args.map(function (arg) {
      return convertEscapeCharacters(arg);
    });
  };

  var setPluginCommand = function (commandName, methodName) {
    pluginCommandMap.set(metaTagPrefix + commandName, methodName);
  };

  var pluginCommandMap = new Map();
  setPluginCommand("固有イベント呼び出し", "execCallOriginEvent");
  setPluginCommand("_CALL_ORIGIN_EVENT", "execCallOriginEvent");
  setPluginCommand("マップイベント呼び出し", "execCallMapEvent");
  setPluginCommand("_CALL_MAP_EVENT", "execCallMapEvent");
  setPluginCommand("セルフ変数の操作", "execControlSelfVariable");
  setPluginCommand("_SET_SELF_VARIABLE", "execControlSelfVariable");
  setPluginCommand("セルフ変数の一括操作", "execControlSelfVariableRange");
  setPluginCommand("_SET_RANGE_SELF_VARIABLE", "execControlSelfVariableRange");

  //=============================================================================
  // パラメータの取得と整形
  //=============================================================================
  /**
   * Create plugin parameter. param[paramName] ex. param.commandPrefix
   * @param pluginName plugin name(EncounterSwitchConditions)
   * @returns {Object} Created parameter
   */
  var createPluginParameter = function (pluginName) {
    var paramReplacer = function (key, value) {
      if (value === "null") {
        return value;
      }
      if (value[0] === '"' && value[value.length - 1] === '"') {
        return value;
      }
      try {
        return JSON.parse(value);
      } catch (e) {
        return value;
      }
    };
    var parameter = JSON.parse(
      JSON.stringify(PluginManager.parameters(pluginName), paramReplacer)
    );
    PluginManager.setParameters(pluginName, parameter);
    return parameter;
  };
  var param = createPluginParameter("TemplateEvent");

  //=============================================================================
  // Game_Interpreter
  //  プラグインコマンドを追加定義します。
  //=============================================================================
  var _Game_Interpreter_command101 = Game_Interpreter.prototype.command101;
  Game_Interpreter.prototype.command101 = function () {
    if (!$gameMessage.isBusy()) {
      $gameMessage.setEventId(this._eventId);
    }
    return _Game_Interpreter_command101.apply(this, arguments);
  };

  var _Game_Interpreter_command105 = Game_Interpreter.prototype.command105;
  Game_Interpreter.prototype.command105 = function () {
    if (!$gameMessage.isBusy()) {
      $gameMessage.setEventId(this._eventId);
    }
    return _Game_Interpreter_command105.apply(this, arguments);
  };

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.apply(this, arguments);
    var pluginCommandMethod = pluginCommandMap.get(command.toUpperCase());
    if (pluginCommandMethod) {
      this[pluginCommandMethod](
        this.convertAllSelfVariables(convertAllArguments(args))
      );
    }
  };

  Game_Interpreter.prototype.execCallOriginEvent = function (args) {
    this.callOriginEvent(getArgNumber(args[0]));
  };

  Game_Interpreter.prototype.execCallMapEvent = function (args) {
    var pageIndex = getArgNumber(args[1], 1);
    var eventId = getArgNumber(args[0]);
    if ($gameMap.event(eventId)) {
      this.callMapEventById(pageIndex, eventId);
    } else if (args[0] !== "") {
      this.callMapEventByName(pageIndex, args[0]);
    } else {
      this.callMapEventById(pageIndex, this._eventId);
    }
  };

  Game_Interpreter.prototype.execControlSelfVariable = function (args) {
    var selfIndex = getArgNumber(args[0], 0) || args[0];
    var controlType = getArgNumber(args[1], 0, 5);
    var operand = isNaN(Number(args[2])) ? args[2] : getArgNumber(args[2]);
    this.controlSelfVariable(selfIndex, controlType, operand, false);
  };

  Game_Interpreter.prototype.execControlSelfVariableRange = function (args) {
    var selfStartIndex = getArgNumber(args[0], 0) || args[0];
    var selfEndIndex = getArgNumber(args[1], 0) || args[0];
    var controlType = getArgNumber(args[2], 0, 5);
    var operand = isNaN(Number(args[3])) ? args[3] : getArgNumber(args[3]);
    this.controlSelfVariableRange(
      selfStartIndex,
      selfEndIndex,
      controlType,
      operand,
      false
    );
  };

  Game_Interpreter.prototype.callOriginEvent = function (pageIndex) {
    var event = $gameMap.event(this._eventId);
    if (event && event.hasTemplate()) {
      this.setupAnotherList(null, event.getOriginalPages(), pageIndex);
    }
  };

  Game_Interpreter.prototype.callMapEventById = function (pageIndex, eventId) {
    var event = $gameMap.event(eventId);
    if (event) {
      this.setupAnotherList(
        param.KeepEventId ? null : eventId,
        event.getPages(),
        pageIndex
      );
    }
  };

  Game_Interpreter.prototype.callMapEventByName = function (
    pageIndex,
    eventName
  ) {
    var event = DataManager.searchDataItem($dataMap.events, "name", eventName);
    if (event) {
      this.setupAnotherList(
        param.KeepEventId ? null : event.id,
        event.pages,
        pageIndex
      );
    }
  };

  Game_Interpreter.prototype.setupAnotherList = function (
    eventId,
    pages,
    pageIndex
  ) {
    var page = pages[pageIndex - 1 || this._pageIndex] || pages[0];
    if (!eventId) eventId = this.isOnCurrentMap() ? this._eventId : 0;
    this.setupChild(page.list, eventId);
  };

  Game_Interpreter.prototype.controlSelfVariable = function (
    index,
    type,
    operand,
    formulaFlg
  ) {
    var character = this.character(0);
    if (character) {
      character.controlSelfVariable(index, type, operand, formulaFlg);
    }
  };

  Game_Interpreter.prototype.controlSelfVariableRange = function (
    startIndex,
    endIndex,
    type,
    operand,
    formulaFlg
  ) {
    var character = this.character(0);
    if (character) {
      character.controlSelfVariableRange(
        startIndex,
        endIndex,
        type,
        operand,
        formulaFlg
      );
    }
  };

  Game_Interpreter.prototype.getSelfVariable = function (selfVariableIndex) {
    var character = this.character(0);
    return character ? character.getSelfVariable(selfVariableIndex) : 0;
  };

  Game_Interpreter.prototype.convertAllSelfVariables = function (args) {
    return args.map(function (arg) {
      return $gameSelfSwitches.convertSelfVariableCharacter(
        this._eventId,
        arg,
        false
      );
    }, this);
  };

  //=============================================================================
  // Game_Message
  //  メッセージ表示中のイベントIDを保持します。
  //=============================================================================
  var _Game_Message_clear = Game_Message.prototype.clear;
  Game_Message.prototype.clear = function () {
    _Game_Message_clear.apply(this, arguments);
    this._eventId = 0;
  };

  Game_Message.prototype.setEventId = function (id) {
    this._eventId = id;
  };

  Game_Message.prototype.getEventId = function () {
    return this._eventId;
  };

  //=============================================================================
  // Game_System
  //  ロード完了時に必要ならセルフ変数を初期化します。
  //=============================================================================
  var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
  Game_System.prototype.onAfterLoad = function () {
    _Game_System_onAfterLoad.apply(this, arguments);
    $gameSelfSwitches.clearVariableIfNeed();
  };

  //=============================================================================
  // Game_SelfSwitches
  //  セルフ変数を追加します。
  //=============================================================================
  var _Game_SelfSwitches_initialize = Game_SelfSwitches.prototype.initialize;
  Game_SelfSwitches.prototype.initialize = function () {
    _Game_SelfSwitches_initialize.apply(this, arguments);
    this.clearVariable();
  };

  Game_SelfSwitches.prototype.clearVariable = function () {
    this._variableData = {};
  };

  Game_SelfSwitches.prototype.clearVariableIfNeed = function () {
    if (!this._variableData) {
      this.clearVariable();
    }
  };

  Game_SelfSwitches.prototype.getVariableValue = function (key) {
    return this._variableData.hasOwnProperty(key) ? this._variableData[key] : 0;
  };

  Game_SelfSwitches.prototype.setVariableValue = function (key, value) {
    if (this._variableData[key] === value) {
      return;
    }
    if (value !== undefined && value !== 0) {
      this._variableData[key] = value;
    } else {
      delete this._variableData[key];
    }
    this.onChange();
  };

  Game_SelfSwitches.prototype.makeSelfVariableKey = function (eventId, index) {
    return eventId > 0 ? [$gameMap.mapId(), eventId, index] : null;
  };

  Game_SelfSwitches.prototype.convertSelfVariableCharacter = function (
    eventId,
    text,
    scriptFlag
  ) {
    text = text.replace(
      /\x1bSV\[(\w+)]/gi,
      function () {
        var key = this.makeSelfVariableKey(eventId, arguments[1]);
        var value = this.getVariableValue(key);
        return isNotAString(value) || !scriptFlag ? value : "'" + value + "'";
      }.bind(this)
    );
    return text;
  };

  //=============================================================================
  // Game_Event
  //  テンプレートイベントマップをロードしてグローバル変数に保持します。
  //=============================================================================
  var _Game_Event_initialize = Game_Event.prototype.initialize;
  Game_Event.prototype.initialize = function (mapId, eventId) {
    var event = $dataMap.events[eventId];
    this.setTemplate(event);
    _Game_Event_initialize.apply(this, arguments);
    if (this.hasTemplate()) {
      this.setPosition(event.x, event.y);
      this.refreshBushDepth();
    }
  };

  var _Game_Event_setupPageSettings = Game_Event.prototype.setupPageSettings;
  Game_Event.prototype.setupPageSettings = function () {
    _Game_Event_setupPageSettings.apply(this, arguments);
    if (this.hasTemplate() && param.OverrideTarget && this._override) {
      this.overridePageSettings();
    }
  };

  Game_Event.prototype.overridePageSettings = function () {
    var page = this.getOriginalPage();
    if (!page) {
      return;
    }
    var image = page.image;
    var target = param.OverrideTarget;
    if (target.Image) {
      if (image.tileId > 0) {
        this.setTileImage(image.tileId);
      } else {
        this.setImage(image.characterName, image.characterIndex);
      }
    }
    if (target.Direction) {
      if (this._originalDirection !== image.direction) {
        this._originalDirection = image.direction;
        this._prelockDirection = 0;
        this.setDirectionFix(false);
        this.setDirection(image.direction);
      }
      if (this._originalPattern !== image.pattern) {
        this._originalPattern = image.pattern;
        this.setPattern(image.pattern);
      }
    }
    if (target.Move) {
      this.setMoveSpeed(page.moveSpeed);
      this.setMoveFrequency(page.moveFrequency);
      this.setMoveRoute(page.moveRoute);
      this._moveType = page.moveType;
    }
    if (target.Priority) {
      this.setPriorityType(page.priorityType);
    }
    if (target.Option) {
      this.setWalkAnime(page.walkAnime);
      this.setStepAnime(page.stepAnime);
      this.setDirectionFix(page.directionFix);
      this.setThrough(page.through);
    }
    if (target.Trigger) {
      this._trigger = page.trigger;
      if (this._trigger === 4) {
        this._interpreter = new Game_Interpreter();
      } else {
        this._interpreter = null;
      }
    }
  };

  Game_Event.prototype.setTemplate = function (event) {
    var templateId = this.generateTemplateId(event);
    if (templateId) {
      this._templateId = templateId;
      this._templateEvent = $dataTemplateEvents[this._templateId];
      this._override =
        param.AutoOverride || !!getMetaValues(event, ["OverRide", "上書き"]);
      if (param.IntegrateNote > 0) {
        this.integrateNote(event, param.IntegrateNote);
      }
    } else {
      this._templateId = 0;
      this._templateEvent = null;
      this._override = false;
    }
  };

  Game_Event.prototype.generateTemplateId = function (event) {
    var value = getMetaValues(event, "");
    if (!value) {
      return 0;
    }
    var templateId = getArgNumber(value, 0, $dataTemplateEvents.length - 1);
    if (!templateId) {
      var template = DataManager.searchDataItem(
        $dataTemplateEvents,
        "name",
        value
      );
      if (template) {
        templateId = template.id;
      }
    }
    return templateId;
  };

  Game_Event.prototype.integrateNote = function (event, type) {
    this._templateEvent = JsonEx.makeDeepCopy(this._templateEvent);
    this._templateEvent.note =
      (type === 1 ? this._templateEvent.note : "") + event.note;
    DataManager.extractMetadata(this._templateEvent);
  };

  Game_Event._userScripts = ["getTemplateId", "getTemplateName"];
  Game_Event.prototype.getTemplateId = function () {
    return this._templateId;
  };

  Game_Event.prototype.getTemplateName = function () {
    return this.hasTemplate() ? this._templateEvent.name : "";
  };

  Game_Event.prototype.hasTemplate = function () {
    return this._templateId > 0;
  };

  var _Game_Event_event = Game_Event.prototype.event;
  Game_Event.prototype.event = function () {
    return this.hasTemplate()
      ? this._templateEvent
      : _Game_Event_event.apply(this, arguments);
  };

  Game_Event.prototype.getOriginalPages = function () {
    var eventId = isExistPlugin("SAN_MapGenerator")
      ? this._dataEventId
      : this._eventId;
    return $dataMap.events[eventId].pages;
  };

  Game_Event.prototype.getOriginalPage = function () {
    return this.getOriginalPages()[this._pageIndex];
  };

  Game_Event.prototype.getPages = function () {
    return this.event().pages;
  };

  var _Game_Event_meetsConditions = Game_Event.prototype.meetsConditions;
  Game_Event.prototype.meetsConditions = function (page) {
    return (
      _Game_Event_meetsConditions.apply(this, arguments) &&
      this.meetsConditionsForSelfVariable(page)
    );
  };

  Game_Event.prototype.meetsConditionsForSelfVariable = function (page) {
    var comment = this.getStartComment(page);
    return !(
      comment && this.execConditionScriptForSelfVariable(comment) === false
    );
  };

  Game_Event.prototype.getStartComment = function (page) {
    return page.list
      .filter(function (command) {
        return command && (command.code === 108 || command.code === 408);
      })
      .reduce(function (prev, command) {
        return prev + command.parameters[0];
      }, "");
  };

  Game_Event.prototype.execConditionScriptForSelfVariable = function (note) {
    var scripts = [];
    note.replace(
      /\\TE{(.+?)}/gi,
      function () {
        scripts.push(arguments[1]);
      }.bind(this)
    );
    return scripts.every(function (script) {
      script = convertEscapeCharacters(script);
      script = $gameSelfSwitches.convertSelfVariableCharacter(
        this._eventId,
        script,
        true
      );
      return eval(script);
    }, this);
  };

  Game_Event.prototype.getSelfVariableKey = function (index) {
    return $gameSelfSwitches.makeSelfVariableKey(this._eventId, index);
  };

  Game_Event.prototype.controlSelfVariable = function (
    index,
    type,
    operand,
    formulaFlg
  ) {
    var key = this.getSelfVariableKey(index);
    if (key) {
      this.operateSelfVariable(key, type, formulaFlg ? eval(operand) : operand);
    }
  };

  Game_Event.prototype.controlSelfVariableRange = function (
    startIndex,
    endIndex,
    type,
    operand,
    formulaFlg
  ) {
    for (var index = startIndex; index <= endIndex; index++) {
      this.controlSelfVariable(index, type, operand, formulaFlg);
    }
  };

  Game_Event.prototype.getSelfVariable = function (selfVariableIndex) {
    var key = this.getSelfVariableKey(selfVariableIndex);
    return $gameSelfSwitches.getVariableValue(key);
  };

  Game_Event.prototype.operateSelfVariable = function (
    key,
    operationType,
    value
  ) {
    var oldValue = $gameSelfSwitches.getVariableValue(key);
    switch (operationType) {
      case 0: // Set
        $gameSelfSwitches.setVariableValue(key, (oldValue = value));
        break;
      case 1: // Add
        $gameSelfSwitches.setVariableValue(key, oldValue + value);
        break;
      case 2: // Sub
        $gameSelfSwitches.setVariableValue(key, oldValue - value);
        break;
      case 3: // Mul
        $gameSelfSwitches.setVariableValue(key, oldValue * value);
        break;
      case 4: // Div
        $gameSelfSwitches.setVariableValue(key, oldValue / value);
        break;
      case 5: // Mod
        $gameSelfSwitches.setVariableValue(key, oldValue % value);
        break;
    }
  };

  //=============================================================================
  // DataManager
  //  データ検索用の共通処理です。
  //=============================================================================
  if (!DataManager.searchDataItem) {
    DataManager.searchDataItem = function (dataArray, columnName, columnValue) {
      var result = 0;
      dataArray.some(function (dataItem) {
        if (dataItem && dataItem[columnName] === columnValue) {
          result = dataItem;
          return true;
        }
        return false;
      });
      return result;
    };
  }

  var _Window_Base_convertEscapeCharacters =
    Window_Base.prototype.convertEscapeCharacters;
  Window_Base.prototype.convertEscapeCharacters = function (text) {
    text = _Window_Base_convertEscapeCharacters.apply(this, arguments);
    return $gameSelfSwitches.convertSelfVariableCharacter(
      $gameMessage.getEventId(),
      text,
      false
    );
  };

  //=============================================================================
  // Scene_Boot
  //  テンプレートイベントマップをロードしてグローバル変数に保持します。
  //=============================================================================
  var _Scene_Boot_create = Scene_Boot.prototype.create;
  Scene_Boot.prototype.create = function () {
    _Scene_Boot_create.apply(this, arguments);
    this._templateMapGenerator = this.templateMapLoadGenerator();
    $dataMap = {};
  };

  var _Scene_Boot_isReady = Scene_Boot.prototype.isReady;
  Scene_Boot.prototype.isReady = function () {
    var isReady = _Scene_Boot_isReady.apply(this, arguments);
    return this._templateMapGenerator.next().done && isReady;
  };

  Scene_Boot.prototype.templateMapLoadGenerator = function* () {
    while (!DataManager.isMapLoaded()) {
      yield false;
    }
    // Resolve conflict for OnlineAvatar.js
    if (!$gamePlayer) {
      $gamePlayer = { isTransferring: function () {} };
    }
    DataManager.loadMapData(param.TemplateMapId);
    $gamePlayer = null;
    while (!DataManager.isMapLoaded()) {
      yield false;
    }
    $dataTemplateEvents = $dataMap.events;
    $dataMap = {};
    return true;
  };
})();