//=============================================================================
// KMS_DebugUtil.js
//   Last update: 2018/01/06
//=============================================================================

/*:
 * @target MZ
 * @plugindesc
 * [v0.1.1] Improve debug functions.
 *
 * @author Kameo (Kamesoft)
 *
 * @param Variable input digits
 * @default 9
 * @desc Specify digits for inputting values. The parameter range is from 1 to 15.
 *
 * @param Map grid color
 * @default rgba(255, 255, 255, 0.6)
 * @desc Specify grid color for map transfer mode.
 *
 * @param Watch window font size
 * @default 18
 * @desc Font size for the watch window's text.
 *
 * @param Watch highlight color
 * @default rgba(255, 224, 192, 0.6)
 * @desc Specify background color for updated watch items by CSS color.
 *
 * @param Watch window width
 * @default 360
 * @desc Specify watch window width by pixel.
 *
 * @param Watch window position
 * @default 0
 * @desc
 *  Specify watch window position.
 *  0: TopLeft  1: TopRight  2: BottomLeft  3: BottomRight
 *
 * @help
 *
 * ## Plugin command
 *
 * DebugUtil watch S 10     # Add switch:10 to the watch window
 * DebugUtil watch V 20     # Add variable:20 to the watch window
 */

/*:ja
 * @target MZ
 * @plugindesc
 * [v0.1.1] 標準のデバッグ画面を差し替え、様々な機能を追加します。
 *
 * @author かめお (Kamesoft)
 *
 * @param Variable input digits
 * @default 9
 * @desc 変数入力時の桁数を指定します。最大値は 15 です。
 *
 * @param Map grid color
 * @default rgba(255, 255, 255, 0.6)
 * @desc マップ移動画面のグリッド色を CSS カラーで指定します。
 *
 * @param Watch window font size
 * @default 18
 * @desc ウォッチウィンドウのフォントサイズを指定します。(標準のウィンドウでは 28 です)
 *
 * @param Watch highlight color
 * @default rgba(255, 224, 192, 0.6)
 * @desc ウォッチしている値が変化したときの背景色を CSS カラーで指定します。
 *
 * @param Watch window width
 * @default 360
 * @desc ウォッチウィンドウの幅をピクセル単位で指定します。
 *
 * @param Watch window position
 * @default 0
 * @desc
 *  ウォッチウィンドウの表示位置を指定します。
 *  0: 左上  1: 右上  2: 左下  3: 右下
 *
 * ■ プラグインコマンド
 *
 * DebugUtil watch S 10     # スイッチ ID:10 をウォッチウィンドウに追加
 * DebugUtil watch V 20     # 変数 ID:20 をウォッチウィンドウに追加
 */

// テストプレイ時のみ有効
if (Utils.isOptionValid("test")) {
  var KMS = KMS || {};

  // MapData の一時読み込み先
  var $dataKmsTemporallyMapData = null;

  // セーブデータからの復元を可能にするため、セーブデータに入るクラスをグローバルスコープに置く
  function DebugWatchItemForSave() {
    this.initialize.apply(this, arguments);
  }

  (function () {
    "use strict";

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

      pixiVersion: (function () {
        var match = /^(\d+)\..*/gi.exec(PIXI.VERSION);
        return match ? parseInt(match[1]) : 0;
      })(),

      mapTileScale: 0.5, // マップ移動画面のタイル表示倍率
      mapGridLineWidth: 2, // マップ移動画面のグリッドの線幅

      watchUpdateDuration: 30, // ウォッチ更新通知のアニメーション時間

      WatchItemType: {
        user: -1, // ユーザー定義 (TODO: 現状非対応)
        none: 0, // なし
        switch: 1, // スイッチ
        variable: 2, // 変数
      },

      // ウォッチ項目の編集モード
      WatchItemEditMode: {
        add: 0, // 追加
        edit: 1, // 編集
      },

      // ウォッチウィンドウ表示位置
      WatchWindowPosition: {
        topLeft: 0, // 左上
        topRight: 1, // 右上
        bottomLeft: 2, // 左下
        bottomRight: 3, // 右下
      },
    };

    var PluginName = "KMS_" + Const.pluginCode;

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

    KMS.DebugUtil = {};

    // デバッグコマンドのリスト
    KMS.DebugUtil.debugCommands = [];

    // データベースリロード時に呼び出す処理のリスト
    KMS.DebugUtil.databaseReloadHandlers = [];

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

    var pluginParams = PluginManager.parameters(PluginName);
    var Params = {};
    Params.variableInputDigits = Math.min(
      Math.max(
        parseIntWithDefault(pluginParams["Variable input digits"], 9),
        1
      ),
      15
    );
    Params.formationButton = pluginParams["Formation button"] || "shift";
    Params.mapGridColor =
      pluginParams["Map grid color"] || "rgba(255, 255, 255, 0.6)";
    Params.watchFontSize = Math.max(
      parseIntWithDefault(pluginParams["Watch window font size"], 18),
      1
    );
    Params.watchUpdateColor =
      pluginParams["Watch update color"] || "rgba(255, 224, 192, 0.6)";
    Params.watchWindowPosition = parseIntWithDefault(
      pluginParams["Watch window position"],
      0
    );
    Params.watchWindowWidth = Math.max(
      parseIntWithDefault(pluginParams["Watch window width"], 360),
      1
    );
    Params.WatchWindowPosition = Math.min(
      Math.max(
        parseIntWithDefault(
          pluginParams["Watch window position"],
          Const.WatchWindowPosition.topLeft
        ),
        Const.WatchWindowPosition.topLeft
      ),
      Const.WatchWindowPosition.bottomRight
    );

    // デバッグログ
    var debuglog;
    if (Const.debug) {
      debuglog = function () {
        console.log.apply(console, 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 "watch": // ウォッチ ( {S|V} {id} )
          {
            var id = parseInt(args[2]);
            if (!id) {
              console.error(
                "[%s %s] Invalid ID: %s",
                Const.pluginCode,
                args[0],
                args[2]
              );
              return;
            }

            var item = new DebugWatchItem();
            switch (args[1].toUpperCase()) {
              case "S":
                item.setupSwitch(id);
                break;

              case "V":
                item.setupVariable(id);
                break;

              default:
                console.error(
                  "[%s %s] Invalid type: %s",
                  Const.pluginCode,
                  args[0],
                  args[1]
                );
                return;
            }
            $gameTemp.registerDebugWatchItem(item);
          }
          break;

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

    /**
     * 日本語環境か否か
     */
    var isJp = (function () {
      var language =
        (navigator.languages && navigator.languages[0]) ||
        navigator.browserLanguage ||
        navigator.userLanguage ||
        navigator.language;
      if (language) {
        return language.substr(0, 2) === "ja";
      } else {
        return false;
      }
    })();

    /**
     * 指定桁数を指定文字で埋めた文字列を返す
     */
    function padDigits(number, digits, pad) {
      var holder = Array(digits + 1).join(pad);
      return (holder + number).slice(-digits);
    }

    /**
     * 他プラグインの影響を除いた素のパラメータ強化値 (Game_Actor に対して呼ぶ)
     */
    var originalParamPlus = function (paramId) {
      return this._paramPlus[paramId];
    };

    /**
     * 文字列であるか判定
     */
    function isString(obj) {
      return typeof obj === "string" || obj instanceof String;
    }

    /**
     * アイテム系のオブジェクトであるか判定
     */
    function isItemObject(item) {
      return (
        DataManager.isSkill(item) ||
        DataManager.isItem(item) ||
        DataManager.isWeapon(item) ||
        DataManager.isArmor(item)
      );
    }

    /**
     * アクターが作成されているか
     * ($gameActors に対して呼ぶ)
     */
    function isActorCreated(actorId) {
      return !!this._data[actorId];
    }

    /**
     * アクターがパーティ内に存在するか
     * ($gameParty に対して呼ぶ)
     */
    function containsActor(actorId) {
      return this._actors.contains(actorId);
    }

    /**
     * outActor を inActor の位置に加入させ、outActor を外す
     * ($gameParty に対して呼ぶ)
     */
    function replaceActor(inActorId, outActorId) {
      if (this._actors.contains(outActorId)) {
        for (var i = 0; i < this._actors.length; i++) {
          if (this._actors[i] !== outActorId) {
            continue;
          }

          if (inActorId) {
            // in/out を入れ替える
            this._actors[i] = inActorId;
            break;
          } else {
            // in がなしの場合は out を外すだけ
            this.removeActor(outActorId);
            return;
          }
        }
      } else if (inActorId) {
        // in だけ存在する場合は単純に追加
        this.addActor(inActorId);
        return;
      } else {
        // out が不在で、in も存在しないので何もしない
        return;
      }

      $gamePlayer.refresh();
      $gameMap.requestRefresh();
    }

    //-----------------------------------------------------------------------------
    // KMS

    /**
     * デバッグコマンドの登録
     *
     * command には id, name, onSelect の 3 つを持たせる。
     */
    KMS.DebugUtil.registerCommand = function (command) {
      // 有効判定
      function isValid(cmd) {
        return cmd.id && cmd.name && cmd.onSelect;
      }

      // 一致判定
      function isSame(lhs, rhs) {
        return lhs.id === rhs.id;
      }

      if (!isValid(command)) {
        // 未指定のパラメータがある
        return false;
      }

      var exists = KMS.DebugUtil.debugCommands.some(function (item) {
        return isSame(item, command);
      });
      if (exists) {
        // 登録済み
        console.log(
          '[%s] Command "%s" is already registered',
          Const.pluginCode,
          command.id
        );
        return false;
      }

      KMS.DebugUtil.debugCommands.push(command);
      return true;
    };

    /**
     * データベースリロード時に呼び出す処理を登録
     */
    KMS.DebugUtil.registerDatabaseReloadHandler = function (handler) {
      if (!handler) {
        return false;
      }

      // 一致判定
      function isSame(lhs, rhs) {
        return lhs === rhs;
      }

      var exists = KMS.DebugUtil.databaseReloadHandlers.some(function (item) {
        return isSame(item, command);
      });
      if (exists) {
        // 登録済み
        console.log(
          "[%s] Specified reload handler is already registered",
          Const.pluginCode
        );
        return false;
      }

      KMS.DebugUtil.databaseReloadHandlers.push(handler);
      return true;
    };

    //-----------------------------------------------------------------------------
    // DebugWatchItemForSave
    //
    // セーブデータに残す情報のみに絞ったウォッチ項目

    DebugWatchItemForSave.constructor = DebugWatchItemForSave;

    Object.defineProperties(DebugWatchItemForSave.prototype, {
      type: {
        get: function () {
          return this._type;
        },
        set: function (value) {
          this._type = value;
        },
        configurable: true,
      },
      id: {
        get: function () {
          return this._id;
        },
        set: function (value) {
          this._id = value;
        },
        configurable: true,
      },
    });

    DebugWatchItemForSave.prototype.initialize = function () {
      this._type = Const.WatchItemType.switch;
      this._id = 1;
    };

    /**
     * 実際の表示用ウォッチ項目に変換
     */
    DebugWatchItemForSave.prototype.toActualItem = function () {
      var item = new DebugWatchItem();
      switch (this._type) {
        case Const.WatchItemType.switch:
          item.setupSwitch(this._id);
          break;

        case Const.WatchItemType.variable:
          item.setupVariable(this._id);
          break;

        default:
          console.error(
            "%s: toDisplayItem() failed. Invalid item type (%d)",
            Const.pluginCode,
            this._type
          );
          return null;
      }

      return item;
    };

    //-----------------------------------------------------------------------------
    // DebugWatchItem
    //
    // ウォッチウィンドウに表示する項目

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

    DebugWatchItem.prototype.constructor = DebugWatchItem;

    Object.defineProperties(DebugWatchItem.prototype, {
      type: {
        get: function () {
          return this._type;
        },
        configurable: true,
      },
      typeSymbol: {
        get: function () {
          return this._typeSymbol;
        },
        configurable: true,
      },
      typename: {
        get: function () {
          return this._typename;
        },
        configurable: true,
      },
      id: {
        get: function () {
          return this._id;
        },
        configurable: true,
      },
      name: {
        get: function () {
          return this._name;
        },
        configurable: true,
      },
    });

    /**
     * デフォルトの取得関数
     */
    DebugWatchItem.defaultGetter = function () {
      return "";
    };

    /**
     * スイッチ用の生値取得関数
     */
    DebugWatchItem.switchRawValueGetter = function () {
      return $gameSwitches.value(this._id);
    };

    /**
     * スイッチ用の表示値取得関数
     */
    DebugWatchItem.switchDispValueGetter = function () {
      return this._getterRaw.call(this) ? "ON" : "OFF";
    };

    /**
     * 変数用の値取得関数
     */
    DebugWatchItem.variableValueGetter = function () {
      return $gameVariables.value(this._id);
    };

    /**
     * 初期化
     */
    DebugWatchItem.prototype.initialize = function () {
      this.invalidate();
    };

    /**
     * ユーザー定義か
     */
    DebugWatchItem.prototype.isUserDef = function () {
      return this._type === Const.WatchItemType.user;
    };

    /**
     * 一致判定
     */
    DebugWatchItem.prototype.equals = function (rhs) {
      if (!(rhs instanceof DebugWatchItem) || this._type !== rhs._type) {
        // タイプ違い
        return false;
      }

      if (this.isUserDef() && rhs.isUserDef()) {
        // ユーザー定義の場合は名前以外完全一致を要求
        return (
          this._id === rhs._id &&
          this._getterRaw === rhs._getterRaw &&
          this._getterDisp === rhs._getterDisp
        );
      } else {
        return this._id === rhs._id;
      }
    };

    /**
     * 生値を取得
     */
    DebugWatchItem.prototype.getRaw = function () {
      return this._getterRaw.call(this);
    };

    /**
     * 表示用の値を取得
     */
    DebugWatchItem.prototype.getDisp = function () {
      return this._getterDisp.call(this);
    };

    /**
     * 値を監視して更新を通知
     */
    DebugWatchItem.prototype.checkUpdate = function () {
      var currValue = this.getRaw();
      if (this._lastValue !== currValue) {
        this._lastValue = currValue;
        return true;
      } else {
        return false;
      }
    };

    /**
     * 無効化
     */
    DebugWatchItem.prototype.invalidate = function () {
      this._type = Const.WatchItemType.none;
      this._typeSymbol = "";
      this._typename = "";
      this._id = 0;
      this._name = "";
      this._getterRaw = DebugWatchItem.defaultGetter;
      this._getterDisp = DebugWatchItem.defaultGetter;
      this._lastValue = null;
    };

    /**
     * スイッチを表示するようにセットアップ
     */
    DebugWatchItem.prototype.setupSwitch = function (switchId) {
      this._type = Const.WatchItemType.switch;
      this._id = switchId.clamp(1, $dataSystem.switches.length - 1);
      this.refresh();
    };

    /**
     * 変数を表示するようにセットアップ
     */
    DebugWatchItem.prototype.setupVariable = function (variableId) {
      this._type = Const.WatchItemType.variable;
      this._id = variableId.clamp(1, $dataSystem.variables.length - 1);
      this.refresh();
    };

    /**
     * 表示する情報の再構築 (データベースリロード時にも呼ぶ)
     */
    DebugWatchItem.prototype.refresh = function () {
      switch (this._type) {
        case Const.WatchItemType.switch:
          if (this._id >= $dataSystem.switches.length) {
            this.invalidate();
            return;
          }
          this._typeSymbol = "S";
          this._typename = isJp ? "スイッチ" : "Switch";
          this._name = $dataSystem.switches[this._id];
          this._getterRaw = DebugWatchItem.switchRawValueGetter;
          this._getterDisp = DebugWatchItem.switchDispValueGetter;
          break;

        case Const.WatchItemType.variable:
          if (this._id >= $dataSystem.variables.length) {
            this.invalidate();
            return;
          }
          this._typeSymbol = "V";
          this._typename = isJp ? "変数" : "Variable";
          this._name = $dataSystem.variables[this._id];
          this._getterRaw = DebugWatchItem.variableValueGetter;
          this._getterDisp = DebugWatchItem.variableValueGetter;
          break;

        default:
          // 何もしない
          break;
      }

      // 更新通知用の初期値を取得
      this._lastValue = this.getRaw();
    };

    /**
     * セーブ用のデータに変換
     */
    DebugWatchItem.prototype.toSaveItem = function () {
      var item = new DebugWatchItemForSave();
      item.type = this._type;
      item.id = this._id;

      return item;
    };

    /**
     * 別の項目からコピー
     */
    DebugWatchItem.prototype.copyFrom = function (item) {
      if (!item) {
        this.invalidate();
        return;
      }

      switch (item.type) {
        case Const.WatchItemType.switch:
          this.setupSwitch(item.id);
          break;

        case Const.WatchItemType.variable:
          this.setupVariable(item.id);
          break;

        default:
          this.invalidate();
          break;
      }
    };

    //-----------------------------------------------------------------------------
    // DataManager

    /**
     * データベースファイルの同期読み込み
     *  ※ 警告が出るので使わない
     */
    /*
DataManager.loadDataFileSync = function(name, src)
{
    var xhr = new XMLHttpRequest();
    var url = 'data/' + src;
    xhr.open('GET', url, false);
    xhr.overrideMimeType('application/json');
    window[name] = null;
    xhr.send(null);

    if (xhr.status < 400)
    {
        window[name] = JSON.parse(xhr.responseText);
        DataManager.onLoad(window[name]);
    }
    else
    {
        DataManager._errorUrl = DataManager._errorUrl || url;
    }
};
*/

    /**
     * 一時マップデータの読み込み
     */
    DataManager.loadKmsTemporallyMapData = function (mapId) {
      if (mapId > 0) {
        var filename = "Map%1.json".format(mapId.padZero(3));
        this.loadDataFile("$dataKmsTemporallyMapData", filename);
      } else {
        var dataBackup = $dataMap;
        this.makeEmptyMap();

        $dataKmsTemporallyMapData = $dataMap;
        $dataMap = dataBackup;
      }
    };

    /**
     * 一時マップデータの読み込みが完了しているか
     */
    DataManager.isKmsTemporallyMapLoaded = function () {
      this.checkError();
      return !!$dataKmsTemporallyMapData;
    };

    //-----------------------------------------------------------------------------
    // TextManager

    TextManager.DebugUtil = {};

    var simpleGetter = function (text) {
      return {
        get: function () {
          return text;
        },
        configurable: true,
      };
    };

    Object.defineProperties(TextManager.DebugUtil, {
      sceneTitle: simpleGetter(isJp ? "デバッグメニュー" : "Debug menu"),

      // コマンド名
      itemNumber: simpleGetter(
        isJp ? "アイテム所持数変更" : "Edit item numbers"
      ),
      actorParam: simpleGetter(isJp ? "アクター編集" : "Edit actor's param"),
      member: simpleGetter(isJp ? "メンバー変更" : "Edit party"),
      reloadMap: simpleGetter(isJp ? "マップ再読み込み" : "Reload map"),
      loadDatabase: simpleGetter(
        isJp ? "データベース再読み込み" : "Reload database"
      ),
      transfer: simpleGetter(isJp ? "場所移動" : "Transfer"),
      switchVar: simpleGetter(
        isJp ? "スイッチ・変数操作" : "Edit switches/variables"
      ),
      selfSwitch: simpleGetter(
        isJp ? "セルフスイッチ操作" : "Edit self-switches"
      ),
      systemValue: simpleGetter(isJp ? "システム値操作" : "Edit system values"),
      watchWindow: simpleGetter(
        isJp ? "スイッチ・変数監視" : "Watch switches/variables"
      ),
      encounter: simpleGetter(isJp ? "エンカウント" : "Encounter"),
      dispPassage: simpleGetter(isJp ? "通行可否表示" : "Display passage"),

      // パラメータ名
      battleCount: simpleGetter(isJp ? "戦闘回数" : "Battle count"),
      winCount: simpleGetter(isJp ? "勝利回数" : "Victory count"),
      escapeCount: simpleGetter(isJp ? "逃走回数" : "Escape count"),
      saveCount: simpleGetter(isJp ? "セーブ回数" : "Save count"),

      // その他
      activeParty: simpleGetter(isJp ? "パーティ内メンバー" : "Active member"),
      reserveParty: simpleGetter(
        isJp ? "パーティ外メンバー" : "Reserve member"
      ),
      addToParty: simpleGetter(isJp ? "追加" : "Add"),
      removeFromParty: simpleGetter(isJp ? "外す" : "Remove"),
      tilePosition: simpleGetter(isJp ? "移動先" : "Position"),
      mapSize: simpleGetter(isJp ? "マップサイズ" : "Map size"),
      encounterRandom: simpleGetter(
        isJp ? "現在のマップからランダム" : "Random in current map"
      ),
      addWatchItem: simpleGetter(isJp ? "追加" : "Add"),
      watchItemType: simpleGetter(isJp ? "タイプ" : "Type"),
      watchItemRemove: simpleGetter(isJp ? "削除" : "Remove"),
    });

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

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

      this.clearDebugWatchRefreshRequest();
      this.clearDebugWatchItem();
    };

    /**
     * ウォッチウィンドウを再構築するか
     */
    Game_Temp.prototype.isDebugWatchRefreshRequested = function () {
      return this._debugWatchRefreshRequested;
    };

    /**
     * ウォッチウィンドウの再構築要求
     */
    Game_Temp.prototype.requestDebugWatchRefresh = function () {
      this._debugWatchRefreshRequested = true;
    };

    /**
     * ウォッチウィンドウの再構築要求を解除
     */
    Game_Temp.prototype.clearDebugWatchRefreshRequest = function () {
      this._debugWatchRefreshRequested = false;
    };

    /**
     * ウォッチウィンドウに表示する項目を登録
     */
    Game_Temp.prototype.registerDebugWatchItem = function (item) {
      if (!item) {
        return;
      }

      for (var i = 0; i < this._debugWatchItems.length; i++) {
        if (this._debugWatchItems[i].equals(item)) {
          // 同じ設定のものが登録済み
          return;
        }
      }

      var newItem = new DebugWatchItem();
      newItem.copyFrom(item);
      this._debugWatchItems.push(newItem);
      this.requestDebugWatchRefresh();
    };

    /**
     * ウォッチウィンドウに表示する項目を差し替え
     */
    Game_Temp.prototype.replaceDebugWatchItem = function (item, index) {
      if (!item || this._debugWatchItems.length <= index) {
        return;
      }

      this._debugWatchItems[index] = item;
      this.requestDebugWatchRefresh();
    };

    /**
     * ウォッチウィンドウに表示する項目を解除
     */
    Game_Temp.prototype.removeDebugWatchItem = function (item) {
      if (!item) {
        return;
      }

      this._debugWatchItems = this._debugWatchItems.filter(function (v) {
        return !v.equals(item);
      });

      this.requestDebugWatchRefresh();
    };

    /**
     * ウォッチウィンドウに表示する項目を全解除
     */
    Game_Temp.prototype.clearDebugWatchItem = function () {
      this._debugWatchItems = [];
    };

    /**
     * ウォッチウィンドウに表示する項目の一覧を取得
     */
    Game_Temp.prototype.getDebugWatchItemList = function () {
      return this._debugWatchItems;
    };

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

    var _Game_System_onBeforeSave = Game_System.prototype.onBeforeSave;
    Game_System.prototype.onBeforeSave = function () {
      _Game_System_onBeforeSave.call(this);

      this.createDebugWatchItemsForSave();
    };

    var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
    Game_System.prototype.onAfterLoad = function () {
      _Game_System_onAfterLoad.call(this);

      this.restoreDebugWatchItemsFromSave();
    };

    /**
     * セーブ用のウォッチ項目リストを作成
     *
     * DebugWatchItem の全メンバを保存すると無駄があるので、最小限の情報のみ保存する
     */
    Game_System.prototype.createDebugWatchItemsForSave = function () {
      var list = $gameTemp.getDebugWatchItemList();
      if (list.length === 0) {
        // ウォッチリストが空なら何もセーブしない
        delete this._debugWatchItemList;
        return;
      }

      this._debugWatchItemList = [];
      list.forEach(function (item) {
        this._debugWatchItemList.push(item.toSaveItem());
      }, this);
    };

    /**
     * セーブ用のウォッチ項目リストからウォッチリストを復元
     */
    Game_System.prototype.restoreDebugWatchItemsFromSave = function () {
      if (!this._debugWatchItemList) {
        return;
      }

      $gameTemp.clearDebugWatchItem();
      this._debugWatchItemList.forEach(function (item) {
        $gameTemp.registerDebugWatchItem(item.toActualItem());
      }, this);
    };

    //-----------------------------------------------------------------------------
    // Sprite_DebugMapDestination
    //
    // デバッグ画面で移動先タイルを強調表示するスプライト

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

    Sprite_DebugMapDestination.prototype = Object.create(
      Sprite_Destination.prototype
    );
    Sprite_DebugMapDestination.prototype.constructor =
      Sprite_DebugMapDestination;

    Sprite_DebugMapDestination.prototype.initialize = function () {
      Sprite_Destination.prototype.initialize.call(this);
      this.blendMode = 0;

      this._map = null;
      this._destination = new Point();
      this._visibleArea = new Rectangle();
    };

    /**
     * 参照するマップオブジェクトを設定
     */
    Sprite_DebugMapDestination.prototype.setMap = function (map) {
      this._map = map;
    };

    /**
     * 目的地のタイル座標を設定
     */
    Sprite_DebugMapDestination.prototype.setDestination = function (x, y) {
      this._destination.x = x;
      this._destination.y = y;
    };

    /**
     * 可視領域を設定
     */
    Sprite_DebugMapDestination.prototype.setVisibleArea = function (
      x,
      y,
      width,
      height
    ) {
      this._visibleArea.x = x;
      this._visibleArea.y = y;
      this._visibleArea.width = width;
      this._visibleArea.height = height;
    };

    Sprite_DebugMapDestination.prototype.update = function () {
      // 判定自体を書き直すので、Sprite の方を呼ぶ
      Sprite.prototype.update.call(this);

      if (this.visible) {
        this.updateAnimation();
        this.updatePosition();
      } else {
        this._frameCount = 0;
      }
    };

    Sprite_DebugMapDestination.prototype.updatePosition = function () {
      if (!this._map) {
        return;
      }

      var tileWidth = this._map.tileWidth();
      var tileHeight = this._map.tileHeight();
      this.x = (this._map.adjustX(this._destination.x) + 0.5) * tileWidth;
      this.y = (this._map.adjustY(this._destination.y) + 0.5) * tileHeight;

      // 可視領域外に出た場合は消す
      if (
        this.x < this._visibleArea.x ||
        this.y < this._visibleArea.y ||
        this.x > this._visibleArea.width ||
        this.y > this._visibleArea.height
      ) {
        this.opacity = 0;
      }
    };

    //-----------------------------------------------------------------------------
    // Sprite_DebugWatchUpdate
    //
    // ウォッチウィンドウで値の更新を通知するスプライト

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

    Sprite_DebugWatchUpdate.prototype = Object.create(Sprite.prototype);
    Sprite_DebugWatchUpdate.prototype.constructor = Sprite_DebugWatchUpdate;

    Sprite_DebugWatchUpdate.prototype.initialize = function () {
      Sprite.prototype.initialize.call(this);

      this._duration = 0;
      this.visible = false;
    };

    /**
     * 更新アニメーションを実行
     */
    Sprite_DebugWatchUpdate.prototype.animate = function () {
      this._duration = Const.watchUpdateDuration;
      this.visible = true;
    };

    /**
     * セットアップ
     */
    Sprite_DebugWatchUpdate.prototype.setup = function (x, y, width, height) {
      this._bitmap = new Bitmap(width, height);
      this._bitmap.fillRect(0, 0, width, height, Params.watchUpdateColor);
      this.setFrame(0, 0, width, height);
      //this.blendMode = Graphics.BLEND_ADD;
      this.move(x, y);
    };

    Sprite_DebugWatchUpdate.prototype.update = function () {
      Sprite.prototype.update.call(this);

      if (this.visible) {
        this.updateAnimation();
      }
    };

    /**
     * アニメーションの更新
     */
    Sprite_DebugWatchUpdate.prototype.updateAnimation = function () {
      this.opacity = (255 * this._duration) / Const.watchUpdateDuration;

      this._duration--;
      if (this._duration < 0) {
        this.visible = false;
      }
    };

    //-----------------------------------------------------------------------------
    // MZ対応のための拡張

    function _textPadding() {
      return 6;
    }
    function _standardPadding() {
      return $gameSystem.windowPadding();
    }
    function _standardFontSize() {
      return $gameSystem.mainFontSize();
    }

    function _itemRectForText(window, index) {
      var rect = window.itemRect(index);
      rect.x += _textPadding();
      rect.width -= _textPadding() * 2;
      return rect;
    }

    //-----------------------------------------------------------------------------
    // Window_DebugEdit

    /**
     * 現在のモードを取得
     */
    Window_DebugEdit.prototype.getMode = function () {
      return this._mode;
    };

    //-----------------------------------------------------------------------------
    // Window_DebugTitle
    //
    // デバッグ画面で機能名を表示するウィンドウ

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

    Window_DebugTitle.prototype = Object.create(Window_Help.prototype);
    Window_DebugTitle.prototype.constructor = Window_DebugTitle;

    Window_DebugTitle.prototype.initialize = function (width, numLines) {
      const wx = 0;
      const wy = 0;
      const ww = Graphics.boxWidth;
      const wh = this.fittingHeight(numLines);
      Window_Help.prototype.initialize.call(
        this,
        new Rectangle(wx, wy, ww, wh)
      );

      this.width = width;
      this.createContents();
    };

    Window_DebugTitle.prototype.refresh = function () {
      this.contents.clear();

      var x = _textPadding();
      var w = this.contentsWidth() - _textPadding() * 2;
      this.contents.drawText(this._text, x, 0, w, this.lineHeight(), "center");
    };

    //-----------------------------------------------------------------------------
    // Window_DebugCommand
    //
    // デバッグ機能を選択するウィンドウ

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

    Window_DebugCommand.prototype = Object.create(Window_Command.prototype);
    Window_DebugCommand.prototype.constructor = Window_DebugCommand;

    Window_DebugCommand.prototype.initialize = function (x, y) {
      const rect = new Rectangle(x, y, 240, this.fittingHeight(6));
      Window_Command.prototype.initialize.call(this, rect);
      this.selectLast();
      this.activate();
      this.refresh();
    };
    Window_DebugCommand.prototype.numVisibleRows = function () {
      return Math.ceil(this.maxItems() / this.maxCols());
    };

    Window_DebugCommand._lastCommandSymbol = null;

    Window_DebugCommand.initCommandPosition = function () {
      this._lastCommandSymbol = null;
    };

    Window_DebugCommand.prototype.windowWidth = function () {
      return Graphics.boxWidth - 64;
    };

    Window_DebugCommand.prototype.maxCols = function () {
      return 2;
    };

    Window_DebugCommand.prototype.makeCommandList = function () {
      this.addCommand(TextManager.DebugUtil.itemNumber, "itemNumber");
      this.addCommand(TextManager.DebugUtil.actorParam, "actorParam");
      this.addCommand(TextManager.DebugUtil.member, "member");
      this.addCommand(TextManager.DebugUtil.reloadMap, "reloadMap");
      this.addCommand(TextManager.DebugUtil.loadDatabase, "loadDatabase");
      this.addCommand(TextManager.DebugUtil.transfer, "transfer");
      this.addCommand(TextManager.DebugUtil.switchVar, "switchVar");
      this.addCommand(TextManager.DebugUtil.selfSwitch, "selfSwitch");
      this.addCommand(TextManager.DebugUtil.systemValue, "systemValue");
      this.addCommand(TextManager.DebugUtil.watchWindow, "watchWindow");
      this.addCommand(TextManager.DebugUtil.encounter, "encounter");
      //this.addCommand(TextManager.DebugUtil.dispPassage,  'dispPassage');
      //this.addCommand(TextManager.DebugUtil.loadJs, 'loadJs');

      // 追加コマンド
      KMS.DebugUtil.debugCommands.forEach(function (command) {
        this.addCommand(command.name, command.id);
      }, this);
    };

    Window_DebugCommand.prototype.processOk = function () {
      Window_DebugCommand._lastCommandSymbol = this.currentSymbol();
      Window_Command.prototype.processOk.call(this);
    };

    Window_DebugCommand.prototype.selectLast = function () {
      if (Window_DebugCommand._lastCommandSymbol) {
        this.selectSymbol(Window_DebugCommand._lastCommandSymbol);
      } else {
        this.selectSymbol("itemNumber");
      }
    };

    //-----------------------------------------------------------------------------
    // Window_DebugNumberInput
    //
    // デバッグモードで値を入力するためのウィンドウ

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

    Window_DebugNumberInput.prototype = Object.create(
      Window_NumberInput.prototype
    );
    Window_DebugNumberInput.prototype.constructor = Window_DebugNumberInput;

    Object.defineProperty(Window_DebugNumberInput.prototype, "number", {
      get: function () {
        return this._number * (this._isNegative ? -1 : 1);
      },
      configurable: true,
    });

    Window_DebugNumberInput.prototype.initialize = function () {
      Window_NumberInput.prototype.initialize.call(this);
      this._number = 0;
      this._maxDigits = 1;
      this._isAllowNegative = false;
      this._isNegative = false;
      this._caption = null;
      this._okCallback = null;
    };

    Window_DebugNumberInput.prototype.windowWidth = function () {
      var captionWidth = _standardPadding() * 2;
      if (isItemObject(this._caption)) {
        captionWidth += this.textWidth(this._caption.name) + 32 + 4;
      } else if (isString(this._caption)) {
        captionWidth += this.textWidth(this._caption) + 4;
      }

      var originWidth = Window_NumberInput.prototype.windowWidth.call(this);
      return Math.max(originWidth, captionWidth);
    };

    Window_DebugNumberInput.prototype.windowHeight = function () {
      return this.fittingHeight(this._caption ? 2 : 1);
    };

    Window_DebugNumberInput.prototype.maxCols = function () {
      return (
        Window_NumberInput.prototype.maxCols.call(this) +
        (this._isAllowNegative ? 1 : 0)
      );
    };

    Window_NumberInput.prototype.maxItems = function () {
      return this.maxCols();
    };

    Window_DebugNumberInput.prototype.setAllowNegative = function (enabled) {
      this._isAllowNegative = enabled;
    };

    Window_DebugNumberInput.prototype.setCaption = function (caption) {
      this._caption = caption;
      this.updatePlacement();
      this.refresh();
    };

    /**
     * 値の入力を開始
     */
    Window_DebugNumberInput.prototype.start = function (
      number,
      maxDigits,
      callback
    ) {
      this._isNegative = number < 0;
      this._number = Math.abs(number);
      this._number = this._number.clamp(0, Math.pow(10, maxDigits) - 1);
      this._maxDigits = maxDigits;
      this._okCallback = callback;

      this.updatePlacement();
      this.placeButtons();
      //this.updateButtonsVisiblity();
      this.createContents();
      this.refresh();
      this.open();
      this.activate();
      this.select(this._maxDigits - 1 + (this._isAllowNegative ? 1 : 0));
    };

    Window_DebugNumberInput.prototype.changeDigit = function (up) {
      var index = this.index();

      if (this._isAllowNegative) {
        if (index === 0) {
          // +/- 切り替え
          this._isNegative = !this._isNegative;
          this.refresh();
          SoundManager.playCursor();
          return;
        }

        // +/- 部分の桁位置をずらす
        index--;
      }

      var place = Math.pow(10, this._maxDigits - 1 - index);
      var n = Math.floor(this._number / place) % 10;
      this._number -= n * place;
      if (up) {
        n = (n + 1) % 10;
      } else {
        n = (n + 9) % 10;
      }
      this._number += n * place;
      this.refresh();
      SoundManager.playCursor();
    };

    Window_DebugNumberInput.prototype.itemRect = function (index) {
      var rect = Window_NumberInput.prototype.itemRect.call(this, index);
      if (this._caption) {
        rect.y += this.lineHeight();
      }

      return rect;
    };

    Window_DebugNumberInput.prototype.drawItem = function (index) {
      var rect = this.itemRect(index);
      var align = "center";
      var sign = this._isAllowNegative ? (this._isNegative ? "-" : "+") : "";
      var s = "%1%2".format(sign, this._number.padZero(this._maxDigits));
      var c = s.slice(index, index + 1);
      this.resetTextColor();
      this.drawText(c, rect.x, rect.y, rect.width, align);
    };

    Window_DebugNumberInput.prototype.drawCaption = function () {
      if (!this._caption) {
        return;
      }

      if (isItemObject(this._caption)) {
        this.drawItemName(this._caption, 0, 0, this.contentsWidth());
      } else if (isString(this._caption)) {
        this.changeTextColor(this.systemColor());
        this.drawText(this._caption, 0, 0, this.contentsWidth());
        this.resetTextColor();
      }
    };

    Window_DebugNumberInput.prototype.refresh = function () {
      if (this.contents) {
        Window_NumberInput.prototype.refresh.call(this);
        this.drawCaption();
      }
    };

    /**
     * 表示位置・サイズの調整
     */
    Window_DebugNumberInput.prototype.updatePlacement = function () {
      this.width = this.windowWidth();
      this.height = this.windowHeight();
      this.x = (Graphics.boxWidth - this.width) / 2;
      this.y = (Graphics.boxHeight - this.height) / 2;
    };

    Window_DebugNumberInput.prototype.buttonY = function () {
      var spacing = 8;
      return this.height + spacing;
    };

    Window_DebugNumberInput.prototype.isCancelEnabled = function () {
      return true;
    };

    Window_DebugNumberInput.prototype.processOk = function () {
      SoundManager.playOk();

      if (this._okCallback) {
        this._okCallback(this.number);
      }

      this.updateInputData();
      this.deactivate();
      this.close();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugItemList
    //
    // アイテム所持数編集ウィンドウ

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

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

    Window_DebugItemList._lastIndex = 0;

    Window_DebugItemList.prototype.initialize = function (x, y, width, height) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.refresh();
      this.selectLast();
      this.hide();
    };

    Window_DebugItemList.prototype.maxCols = function () {
      return 4;
    };

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

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

    Window_DebugItemList.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugItemList._lastIndex);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugItemList.prototype.makeItemList = function () {
      this._data = $dataItems.slice(1);
      this._data = this._data.concat($dataWeapons.slice(1));
      this._data = this._data.concat($dataArmors.slice(1));
    };

    Window_DebugItemList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    Window_DebugItemList.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (!item) {
        return;
      }

      var numberWidth = this.numberWidth();
      var rect = _itemRectForText(this, index);
      this.drawItemName(item, rect.x, rect.y, rect.width - numberWidth);
      this.drawItemNumber(item, rect.x, rect.y, rect.width);
    };

    Window_DebugItemList.prototype.numberWidth = function () {
      return this.textWidth("000");
    };

    Window_DebugItemList.prototype.drawItemNumber = function (
      item,
      x,
      y,
      width
    ) {
      this.drawText(":", x, y, width - this.textWidth("00"), "right");
      this.drawText($gameParty.numItems(item), x, y, width, "right");
    };

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

    Window_DebugItemList.prototype.updateHelp = function () {
      this.setHelpWindowItem(this.item());
    };

    //-----------------------------------------------------------------------------
    // Window_DebugActorList
    //
    // デバッグモード用アクター選択ウィンドウ

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

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

    Window_DebugActorList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = [];
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugActorList._lastIndex = 0;

    Window_DebugActorList.prototype.maxCols = function () {
      return 1;
    };

    Window_DebugActorList.prototype.spacing = function () {
      return 48;
    };

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

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

    Window_DebugActorList.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugActorList.prototype.isEnabled = function (item) {
      return true;
    };

    Window_DebugActorList.prototype.select = function (index) {
      Window_Selectable.prototype.select.call(this, index);
      if (this._statusWindow) {
        this._statusWindow.setActor(this.item());
      }
    };

    Window_DebugActorList.prototype.setStatusWindow = function (window) {
      this._statusWindow = window;
      this.select(this.index());
    };

    Window_DebugActorList.prototype.makeItemList = function () {
      this._data = [];
      for (var i = 1; i < $dataActors.length; i++) {
        this._data.push($gameActors.actor(i));
      }
    };

    Window_DebugActorList.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugActorList._lastIndex);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugActorList.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (!item) {
        return;
      }

      this.changePaintOpacity(this.isEnabled(item));
      this.resetTextColor();

      var text = "%1:%2".format(item.actorId().padZero(4), item.name());
      var rect = _itemRectForText(this, index);
      this.drawText(text, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    };

    Window_DebugActorList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugActorParam
    //
    // デバッグ用アクターパラメータ変更ウィンドウ

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

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

    Window_DebugActorParam.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      this._data = [
        "level",
        "skill",
        "hp",
        "mp",
        "atk",
        "def",
        "mat",
        "mdf",
        "agi",
        "luk",
      ];
      this._paramId = {
        level: null,
        skill: null,
        hp: 0,
        mp: 1,
        atk: 2,
        def: 3,
        mat: 4,
        mdf: 5,
        agi: 6,
        luk: 7,
      };
      this._actor = null;

      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.createContents();
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugActorParam._lastIndex = 0;

    Window_DebugActorParam.prototype.maxCols = function () {
      return 1;
    };

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

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

    Window_DebugActorParam.prototype.paramId = function () {
      return this._paramId[this.item()];
    };

    Window_DebugActorParam.prototype.setActor = function (actor) {
      if (this._actor !== actor) {
        this._actor = actor;
        this.refresh();
      }
    };

    Window_DebugActorParam.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugActorParam._lastIndex);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugActorParam.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (!item) {
        return;
      }

      var rect = _itemRectForText(this, index);

      var paramName;
      var paramValue1;
      var paramValue2;
      var paramId = this._paramId[item];
      if (paramId != null) {
        // 通常パラメータはパラメータ名と現在値、加算値を表示
        paramName = TextManager.param(paramId) + "+";
        paramValue1 = originalParamPlus.call(this._actor, paramId);
        paramValue2 = this._actor.param(paramId);
      } else {
        paramName = TextManager[item];
        switch (item) {
          case "level":
            paramValue1 = this._actor.level;
            break;
          case "skill":
            paramValue1 = ">";
            break;
          default:
            return;
        }
      }

      this.changeTextColor(this.systemColor());
      this.drawText(paramName, 0, rect.y, 160);
      this.resetTextColor();
      this.drawText(paramValue1, 160, rect.y, 90, "right");
      if (paramValue2 != null) {
        this.drawText(
          "(%1)".format(padDigits(paramValue2, 6, " ")),
          270,
          rect.y,
          120
        );
      }
    };

    Window_DebugActorParam.prototype.refresh = function () {
      this.contents.clear();

      if (!this._actor) {
        return;
      }

      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugActorSkill
    //
    // デバッグ用アクタースキル編集ウィンドウ

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

    Window_DebugActorSkill.prototype = Object.create(
      Window_SkillList.prototype
    );
    Window_DebugActorSkill.prototype.constructor = Window_DebugActorSkill;

    Window_DebugActorSkill.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_SkillList.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.hide();
    };

    Window_DebugActorSkill.prototype.isCurrentItemEnabled = function () {
      return true;
    };

    Window_DebugActorSkill.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugActorSkill.prototype.isEnabled = function (item) {
      return this._actor && this._actor.isLearnedSkill(item.id);
    };

    Window_DebugActorSkill.prototype.makeItemList = function () {
      if (!this._actor) {
        this._data = [];
        return;
      }

      this._data = $dataSkills.filter(function (item) {
        return this.includes(item);
      }, this);
    };

    Window_DebugActorSkill.prototype.selectLast = function () {
      this.select(0);
    };

    Window_DebugActorSkill.prototype.drawItem = function (index) {
      var skill = this._data[index];
      if (!skill) {
        return;
      }

      var rect = _itemRectForText(this, index);
      this.changePaintOpacity(this.isEnabled(skill));
      this.drawItemName(skill, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    };

    /**
     * 項目の再描画
     */
    Window_DebugActorSkill.prototype.redrawItem = function (index) {
      this.clearItem(index);
      this.drawItem(index);
    };

    //-----------------------------------------------------------------------------
    // Window_DebugPartyListBase
    //
    // デバッグモード用パーティメンバー選択ウィンドウの基底クラス

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

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

    Window_DebugPartyListBase.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = [];
      this.refresh();
      this.hide();
    };

    Window_DebugPartyListBase.prototype.maxCols = function () {
      return 1;
    };

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

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

    Window_DebugPartyListBase.prototype.makeItemList = function () {
      this._data = [];

      // 継承先で追加
    };

    Window_DebugPartyListBase.prototype.drawItem = function (index) {
      this.drawItemBackground(index);

      var rect = _itemRectForText(this, index);
      var item = this._data[index];
      if (!item) {
        this.drawBlankItem(rect);
        return;
      }

      var name;
      var level;
      if (isActorCreated.call($gameActors, item)) {
        var actor = $gameActors.actor(item);
        name = actor.name();
        level = actor.level;
      } else {
        var actor = $dataActors[item];
        name = actor.name;
        level = "--";
      }

      this.drawText(name, rect.x, rect.y, rect.width);
      this.drawText(
        "%1%2".format(TextManager.levelA, level),
        rect.x,
        rect.y,
        rect.width,
        "right"
      );
    };

    /**
     * 空欄の描画
     */
    Window_DebugPartyListBase.prototype.drawBlankItem = function (rect) {
      // 継承先で実装
    };

    /**
     * 項目の背景描画
     */
    Window_DebugPartyListBase.prototype.drawItemBackground = function (index) {
      // 継承先で実装
    };

    Window_DebugPartyListBase.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugActivePartyList
    //
    // デバッグモードでパーティに加入しているメンバーを選択するウィンドウ

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

    Window_DebugActivePartyList.prototype = Object.create(
      Window_DebugPartyListBase.prototype
    );
    Window_DebugActivePartyList.prototype.constructor =
      Window_DebugActivePartyList;

    Window_DebugActivePartyList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      this._isFormationChangeMode = false;
      this._pendingIndex = -1;

      Window_DebugPartyListBase.prototype.initialize.call(
        this,
        x,
        y,
        width,
        height
      );
    };

    /**
     * 並び替え中のインデックスを取得
     */
    Window_DebugActivePartyList.prototype.getPendingIndex = function () {
      return this._pendingIndex;
    };

    /**
     * 並び替え中のインデックスを設定
     */
    Window_DebugActivePartyList.prototype.setPendingIndex = function (index) {
      this._pendingIndex = index;
    };

    /**
     * 並び替え状態か
     */
    Window_DebugActivePartyList.prototype.isFormationChangeMode = function () {
      return this._isFormationChangeMode;
    };

    /**
     * 並び替え状態を設定
     */
    Window_DebugActivePartyList.prototype.setFormationChangeMode = function (
      mode
    ) {
      this._isFormationChangeMode = !!mode;
      if (!this.isFormationChangeMode()) {
        this.setPendingIndex(-1);
      }
    };

    /**
     * 選択中の項目が有効か
     */
    Window_DebugActivePartyList.prototype.isCurrentItemEnabled = function () {
      if (this.isFormationChangeMode()) {
        var item = this._data[this.index()];
        return item && $gameActors.actor(item).isFormationChangeOk();
      } else {
        return true;
      }
    };

    Window_DebugActivePartyList.prototype.makeItemList = function () {
      Window_DebugPartyListBase.prototype.makeItemList.call(this);

      // パーティ内の全メンバーの ID を格納
      $gameParty.allMembers().forEach(function (actor) {
        this._data.push(actor.actorId());
      }, this);

      // 「追加」コマンド
      this._data.push(null);
    };

    Window_DebugActivePartyList.prototype.drawBlankItem = function (rect) {
      // 「追加」項目
      this.drawText(
        "( %1 )".format(TextManager.DebugUtil.addToParty),
        rect.x,
        rect.y,
        rect.width,
        "center"
      );
    };

    Window_DebugActivePartyList.prototype.drawItemBackground = function (
      index
    ) {
      if (index !== this._pendingIndex) {
        return;
      }

      var rect = this.itemRect(index);
      var color = this.pendingColor();
      this.changePaintOpacity(false);
      this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
      this.changePaintOpacity(true);
    };

    Window_DebugActivePartyList.prototype.processHandling = function () {
      if (this.isOpenAndActive() && this.isHandled("formation")) {
        if (this.isFormationChangeMode()) {
          // 並び替え決定
          if (
            this.isOkTriggered() ||
            Input.isTriggered(Params.formationButton)
          ) {
            this.processFormation();
            return;
          }
        } else {
          // 並び替え開始
          if (Input.isTriggered(Params.formationButton)) {
            this.processFormation();
            return;
          }
        }
      }

      // 入力が確定しなかったら元の処理
      Window_DebugPartyListBase.prototype.processHandling.call(this);
    };

    /**
     * 並び替え操作の処理
     */
    Window_DebugActivePartyList.prototype.processFormation = function () {
      if (!this.item() || !this.isCurrentItemEnabled()) {
        // 並び替え対象にできない
        this.playBuzzerSound();
        return;
      }

      this.playOkSound();
      this.updateInputData();
      //this.deactivate();
      this.callHandler("formation");
    };

    //-----------------------------------------------------------------------------
    // Window_DebugReservePartyList
    //
    // デバッグモードでパーティに加入しているメンバーを選択するウィンドウ

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

    Window_DebugReservePartyList.prototype = Object.create(
      Window_DebugPartyListBase.prototype
    );
    Window_DebugReservePartyList.prototype.constructor =
      Window_DebugReservePartyList;

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

    Window_DebugReservePartyList.prototype.makeItemList = function () {
      Window_DebugPartyListBase.prototype.makeItemList.call(this);

      // パーティ外の全メンバーの ID を格納
      for (var i = 1; i < $dataActors.length; i++) {
        if (!containsActor.call($gameParty, i)) {
          this._data.push(i);
        }
      }

      // 「外す」コマンド
      this._data.push(null);
    };

    Window_DebugReservePartyList.prototype.drawBlankItem = function (rect) {
      // 「外す」項目
      this.drawText(
        "( %1 )".format(TextManager.DebugUtil.removeFromParty),
        rect.x,
        rect.y,
        rect.width,
        "center"
      );
    };

    //-----------------------------------------------------------------------------
    // Window_DebugMapList
    //
    // デバッグモード用マップ選択ウィンドウ

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

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

    Window_DebugMapList.prototype.initialize = function (x, y, width, height) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = [];
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugMapList._lastIndex = 0;

    Window_DebugMapList.prototype.maxCols = function () {
      return 1;
    };

    Window_DebugMapList.prototype.spacing = function () {
      return 48;
    };

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

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

    Window_DebugMapList.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugMapList.prototype.isEnabled = function (item) {
      return true;
    };

    Window_DebugMapList.prototype.select = function (index) {
      Window_Selectable.prototype.select.call(this, index);
      if (this._eventListWindow) {
        this._eventListWindow.setMap(this.item());
      }
    };

    Window_DebugMapList.prototype.setEventListWindow = function (window) {
      this._eventListWindow = window;
      this.select(this.index());
    };

    Window_DebugMapList.prototype.makeItemList = function () {
      this._data = $dataMapInfos.filter(function (info) {
        return info != null;
      });
    };

    Window_DebugMapList.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugMapList._lastIndex);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugMapList.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (item == null) {
        return;
      }

      this.changePaintOpacity(this.isEnabled(item));
      this.resetTextColor();

      // マップ名描画
      var text = "%1:%2".format(item.id.padZero(3), item.name);
      var rect = _itemRectForText(this, index);
      this.drawText(text, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    };

    Window_DebugMapList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugMapTilePosition
    //
    // デバッグモード用タイル座標ウィンドウ

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

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

    Window_DebugMapTilePosition.prototype.initialize = function (x, y, width) {
      this._mapSize = { width: 0, height: 0 };
      this._position = { x: 0, y: 0 };

      var wh = this.fittingHeight(2);
      Window_Base.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, wh)
      );
    };

    /**
     * マップサイズの設定
     */
    Window_DebugMapTilePosition.prototype.setMapSize = function (
      width,
      height
    ) {
      this._mapSize.width = width;
      this._mapSize.height = height;

      // 今のところ直後に setPosition が呼ばれるので、refresh 不要
    };

    /**
     * カーソル位置の設定
     */
    Window_DebugMapTilePosition.prototype.setPosition = function (x, y) {
      this._position.x = x;
      this._position.y = y;
      this.refresh();
    };

    Window_DebugMapTilePosition.prototype.clear = function () {
      this.contents.clear();
    };

    Window_DebugMapTilePosition.prototype.refresh = function () {
      this.clear();

      this.changeTextColor(this.systemColor());
      this.drawText(TextManager.DebugUtil.mapSize, 0, 0, 160);
      this.drawText(
        TextManager.DebugUtil.tilePosition,
        0,
        this.lineHeight(),
        160
      );

      this.resetTextColor();
      this.drawText(
        "%1,%2".format(this._mapSize.width, this._mapSize.height),
        180,
        0,
        120
      );
      this.drawText(
        "%1,%2".format(this._position.x, this._position.y),
        180,
        this.lineHeight(),
        120
      );
    };

    //-----------------------------------------------------------------------------
    // Window_DebugMapTile
    //
    // デバッグモード用タイル選択ウィンドウ

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

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

    Window_DebugMapTile.prototype.initialize = function (x, y, width, height) {
      this._data = [];
      this._map = new Game_Map();
      this._positionWindow = null;

      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.createArrowSprites();

      // Pixi.js が古いと Tilemap が大きめに出るので、padding を増やす
      this.padding += Const.pixiVersion >= 4 ? 18 : 26;

      this.createBaseSprite();
      this.createGridSprite();
      this.createDestinationSprite();
      this.select(0);
      this.hide();
    };

    Window_DebugMapTile.prototype.maxCols = function () {
      return this._map.width();
    };

    Window_DebugMapTile.prototype.maxItems = function () {
      return this._data.length;
    };

    /**
     * 現在の列を取得
     */
    Window_DebugMapTile.prototype.col = function () {
      return Math.floor(this.index() % this.maxCols());
    };

    /**
     * 左端に表示している列を取得
     */
    Window_DebugMapTile.prototype.leftCol = function () {
      return Math.floor(this._scrollX / this.itemWidth());
    };

    /**
     * 左端に表示する列の最大値を取得
     */
    Window_DebugMapTile.prototype.maxLeftCol = function () {
      return Math.max(0, this.maxCols() - this.maxPageCols());
    };

    /**
     * 左端に表示する列を設定
     */
    Window_DebugMapTile.prototype.setLeftCol = function (col) {
      var scrollX = col.clamp(0, this.maxLeftCol()) * this.itemWidth();
      if (this._scrollX !== scrollX) {
        this.scrollTo(scrollX, this._scrollY);
        this._scrollX = scrollX;
        // this._scrollX = scrollX;
        this.refresh();
        // this.updateCursor();
      }
    };

    Window_DebugMapTile.prototype.resetScroll = function () {
      this.setTopRow(0);
      this.setLeftCol(0);
    };

    /**
     * ページ内の最大列数を取得
     */
    Window_DebugMapTile.prototype.maxPageCols = function () {
      var pageWidth = this.width - this.padding * 2;
      return Math.floor(pageWidth / this.itemWidth());
    };

    Window_DebugMapTile.prototype.maxPageItems = function () {
      return this.maxPageRows() * this.maxPageCols();
    };

    /**
     * 右端の列を取得
     */
    Window_DebugMapTile.prototype.rightCol = function () {
      return Math.max(0, this.leftCol() + this.maxPageCols() - 1);
    };

    /**
     * 右端に表示する列を設定
     */
    Window_DebugMapTile.prototype.setRightCol = function (col) {
      this.setLeftCol(col - (this.maxPageCols() - 1));
    };

    Window_DebugMapTile.prototype.spacing = function () {
      return 0;
    };

    Window_DebugMapTile.prototype.itemWidth = function () {
      return this._map.tileWidth() * Const.mapTileScale;
    };

    Window_DebugMapTile.prototype.itemHeight = function () {
      return this._map.tileHeight() * Const.mapTileScale;
    };

    Window_DebugMapTile.prototype.activate = function () {
      Window_Selectable.prototype.activate.call(this);

      if (this._destinationSprite) {
        this._destinationSprite.visible = true;
      }
    };

    Window_DebugMapTile.prototype.deactivate = function () {
      Window_Selectable.prototype.deactivate.call(this);

      if (this._destinationSprite) {
        this._destinationSprite.visible = false;
      }
    };

    Window_DebugMapTile.prototype.select = function (index) {
      Window_Selectable.prototype.select.call(this, index);

      if (this._positionWindow) {
        var cursor = this.getCursorTile();
        this._positionWindow.setPosition(cursor.x, cursor.y);
      }

      this.updateTilemap();
      this.updateDestinationPosition();
      this._stayCount = 0;
    };

    /**
     * 左スクロール
     */
    Window_DebugMapTile.prototype.scrollLeft = function () {
      if (this.leftCol() > 0) {
        this.setLeftCol(this.leftCol() - 1);
      }
    };

    /**
     * 右スクロール
     */
    Window_DebugMapTile.prototype.scrollRight = function () {
      if (this.leftCol() + 1 < this.maxCols()) {
        this.setLeftCol(this.leftCol() + 1);
      }
    };

    Window_DebugMapTile.prototype.updateArrows = function () {
      Window_Selectable.prototype.updateArrows.call(this);

      // 左右アローの表示
      var leftCol = this.leftCol();
      var maxLeftCol = this.maxLeftCol();
      this._rightArrowSprite.visible = maxLeftCol > 0 && leftCol < maxLeftCol;
      this._leftArrowSprite.visible = leftCol > 0;
    };

    Window_DebugMapTile.prototype.processWheel = function () {
      Window_Selectable.prototype.processWheel.call(this);

      if (this.isOpenAndActive()) {
        var threshold = 20;
        if (TouchInput.wheelX >= threshold) {
          this.scrollRight();
        }
        if (TouchInput.wheelX <= -threshold) {
          this.scrollLeft();
        }
      }
    };

    Window_DebugMapTile.prototype.onTouchSelect = function (triggered) {
      var lastIndex = this.index();
      Window_Selectable.prototype.onTouchSelect.call(this, triggered);

      if (this.index() !== lastIndex) {
        // カーソル移動が行われた場合は後続の処理は不要
        return;
      }

      if (this._stayCount >= 10) {
        // 左右端のタップ判定
        const touchPos = new Point(TouchInput.x, TouchInput.y);
        const localPos = this.worldTransform.applyInverse(touchPos);
        const winRect = new Rectangle(0, 0, this.width, this.height);

        //
        if (winRect.contains(localPos.x, localPos.y)) {
          var x = localPos.x;
          if (x < this.padding) {
            this.cursorLeft();
          } else if (x >= this.width - this.padding) {
            this.cursorRight();
          }
        }
      }

      if (this.index() !== lastIndex) {
        SoundManager.playCursor();
      }
    };

    Window_DebugMapTile.prototype.update = function () {
      Window_Selectable.prototype.update.call(this);
      this._stayCount++;
    };

    Window_DebugMapTile.prototype.hitTest = function (x, y) {
      // if (!this.isContentsArea(x, y))
      // {
      //     return -1;
      // }

      var cx = x - this.padding;
      var cy = y - this.padding;
      var maxCols = this.maxCols();
      var maxPageCols = this.maxPageCols();
      var topIndex = this.leftCol() + this.topRow() * maxCols;
      for (var i = 0; i < this.maxPageItems(); i++) {
        var topOffset = Math.floor(i / maxPageCols) * maxCols;
        var index = topIndex + topOffset + (i % maxPageCols);
        if (index < this.maxItems()) {
          var rect = this.itemRect(index);
          var right = rect.x + rect.width;
          var bottom = rect.y + rect.height;
          if (cx >= rect.x && cy >= rect.y && cx < right && cy < bottom) {
            return index;
          }
        }
      }

      return -1;
    };

    Window_DebugMapTile.prototype.ensureCursorVisible = function () {
      Window_Selectable.prototype.ensureCursorVisible.call(this);

      var col = this.col();
      if (col < this.leftCol()) {
        this.setLeftCol(col);
      } else if (col > this.rightCol()) {
        this.setRightCol(col);
      }
    };

    /**
     * 対象のマップを指定
     */
    Window_DebugMapTile.prototype.setupMap = function (mapId) {
      if (mapId === 0) {
        if (this._positionWindow) {
          this._positionWindow.clear();
        }
        this._baseSprite.visible = false;
        return;
      } else {
        this._baseSprite.visible = true;
      }

      // この時点でマップデータはロード済みでなければならない
      debuglog("Window_DebugMapTile.setupMap() called");
      this._map.setup(mapId);
      if (this._positionWindow) {
        this._positionWindow.setMapSize(this._map.width(), this._map.height());
      }

      this.makeItemList();
      this.select(0);
      this.refreshTilemap();
    };

    /**
     * 有効なマップが指定されているか
     */
    Window_DebugMapTile.prototype.isMapValid = function () {
      return this._map && this._map.mapId() > 0;
    };

    /**
     * マップ表示サイズの取得
     */
    Window_DebugMapTile.prototype.getMapDisplaySize = function () {
      return {
        width:
          (this._baseSprite.width + this._tilemap._margin * 2) /
          this._baseSprite.scale.x,

        height:
          (this._baseSprite.height + this._tilemap._margin * 2) /
          this._baseSprite.scale.y,
      };
    };

    /**
     * カーソル位置のタイル座標を取得
     */
    Window_DebugMapTile.prototype.getCursorTile = function () {
      return {
        x: this.index() % this._map.width(),
        y: Math.floor(this.index() / this._map.width()),
      };
    };

    /**
     * マップ転送用の情報を取得
     */
    Window_DebugMapTile.prototype.getTransferInfo = function () {
      var tile = this.getCursorTile();

      // とりあえず下向き、黒フェード固定
      return {
        mapId: this._map.mapId(),
        x: tile.x,
        y: tile.y,
        d: 2,
        fadeType: 0,
      };
    };

    /**
     * マップ位置ウィンドウの設定
     */
    Window_DebugMapTile.prototype.setPositionWindow = function (window) {
      this._positionWindow = window;
    };

    Window_DebugMapTile.prototype.itemRect = function (index) {
      var maxCols = this.maxCols();
      var rect = new Rectangle();
      rect.width = this.itemWidth();
      rect.height = this.itemHeight();
      rect.x =
        (index % maxCols) * (rect.width + this.spacing()) - this._scrollX;
      rect.y = Math.floor(index / maxCols) * rect.height - this._scrollY;
      return rect;
    };

    Window_DebugMapTile.prototype.isCursorVisible = function () {
      return false;
    };

    Window_DebugMapTile.prototype.makeItemList = function () {
      var tileCount = this._map.width() * this._map.height();
      this._data = Array.apply(null, { length: tileCount }).map(
        Number.call,
        Number
      );
    };

    /**
     * アロースプライトの作成
     */
    Window_DebugMapTile.prototype.createArrowSprites = function () {
      // あえて Window.prototype._refreshArrows に近い書き方
      var p = 12;
      var q = p * 2;
      var sx = 96 + q;
      var sy = 0 + q;

      this._leftArrowSprite = new Sprite();
      this._leftArrowSprite.bitmap = this.windowskin;
      this._leftArrowSprite.anchor.x = 0.5;
      this._leftArrowSprite.anchor.y = 0.5;
      this._leftArrowSprite.setFrame(sx, sy + p, p, q);
      this._leftArrowSprite.move(p, this.height / 2);
      this.addChild(this._leftArrowSprite);

      this._rightArrowSprite = new Sprite();
      this._rightArrowSprite.bitmap = this.windowskin;
      this._rightArrowSprite.anchor.x = 0.5;
      this._rightArrowSprite.anchor.y = 0.5;
      this._rightArrowSprite.setFrame(sx + p + q, sy + p, p, q);
      this._rightArrowSprite.move(this.width - p, this.height / 2);
      this.addChild(this._rightArrowSprite);
    };

    /**
     * ベーススプライトの作成
     */
    Window_DebugMapTile.prototype.createBaseSprite = function () {
      var sx = this.padding;
      var sy = this.padding;
      var sw = this.contentsWidth() - this.padding * 2;
      var sh = this.contentsHeight() - this.padding * 2;

      this._baseSprite = new Sprite();
      this._baseSprite.setFrame(0, 0, sw, sh);
      this._baseSprite.x = sx;
      this._baseSprite.y = sy;
      this._baseSprite.scale.x = Const.mapTileScale;
      this._baseSprite.scale.y = Const.mapTileScale;
      this.addChild(this._baseSprite);
    };

    /**
     * グリッドスプライトの作成
     */
    Window_DebugMapTile.prototype.createGridSprite = function () {
      var bw = this.contentsWidth() / Const.mapTileScale;
      var bh = this.contentsHeight() / Const.mapTileScale;

      this._gridSprite = new Sprite();
      this._gridSprite.bitmap = new Bitmap(bw, bh);
      this._baseSprite.addChild(this._gridSprite);
    };

    /**
     * グリッドスプライトの再描画
     */
    Window_DebugMapTile.prototype.refreshGridSprite = function () {
      var lineWidth = Const.mapGridLineWidth;

      function alignSize(value, align) {
        return value - (value % align) + lineWidth;
      }

      var color = Params.mapGridColor;
      var bitmap = this._gridSprite.bitmap;
      bitmap.clear();

      // グリッド描画用のサイズ計算
      //  * カーソルが当たる範囲のみ描画するように調整
      var dispSize = this.getMapDisplaySize();
      var tileWidth = this._tilemap.tileWidth;
      var tileHeight = this._tilemap.tileHeight;
      var mapWidth = this._map.width() * tileWidth;
      var mapHeight = this._map.height() * tileHeight;
      var dispWidth = alignSize(Math.min(dispSize.width, mapWidth), tileWidth);
      var dispHeight = alignSize(
        Math.min(dispSize.height, mapHeight),
        tileHeight
      );

      // 横線
      var vCount = Math.ceil(dispHeight / tileHeight);
      for (var i = 0; i < vCount; i++) {
        var dy = i * tileHeight;
        bitmap.fillRect(0, dy, dispWidth, lineWidth, color);
      }

      // 縦線
      var hCount = Math.ceil(dispWidth / tileWidth);
      for (var i = 0; i < hCount; i++) {
        var dx = i * tileWidth;
        bitmap.fillRect(dx, 0, lineWidth, dispHeight, color);
      }
    };

    /**
     * 移動先スプライトの作成
     */
    Window_DebugMapTile.prototype.createDestinationSprite = function () {
      this._destinationSprite = new Sprite_DebugMapDestination();
      this._destinationSprite.setMap(this._map);
      this._destinationSprite.visible = false;

      this._baseSprite.addChild(this._destinationSprite);
    };

    /**
     * タイルマップの作成
     */
    Window_DebugMapTile.prototype.createTilemap = function () {
      if (this._tilemap || !this.isMapValid()) {
        // 過剰に作成しない
        return;
      }

      //this._tilemap = new ShaderTilemap(); //MZでShaderTilemap消えてる...
      this._tilemap = new Tilemap();

      // サイズをウィンドウ内に収める
      var size = this.getMapDisplaySize();
      this._tilemap.width = size.width;
      this._tilemap.height = size.height;

      this._destinationSprite.setVisibleArea(0, 0, size.width, size.height);

      // PIXI.js が v4 なら mask が正常に動くので、はみ出た部分を除外
      if (Const.pixiVersion >= 4) {
        this._maskGraphic = new PIXI.Graphics();
        this._maskGraphic.beginFill(0x000000);
        this._maskGraphic.drawRect(0, 0, size.width, size.height);
        this._maskGraphic.endFill();

        this._baseSprite.addChild(this._maskGraphic);
        this._tilemap.mask = this._maskGraphic;
      }

      // 最下層に配置
      this._baseSprite.addChildAt(this._tilemap, 0);
    };

    /**
     * タイルマップの再構築
     */
    Window_DebugMapTile.prototype.refreshTilemap = function () {
      this.createTilemap();

      this._tilemap.tileWidth = this._map.tileWidth();
      this._tilemap.tileHeight = this._map.tileHeight();
      this._tilemap.setData(
        this._map.width(),
        this._map.height(),
        this._map.data()
      );

      // ループは無効化
      this._tilemap.horizontalWrap = false; // this._map.isLoopHorizontal();
      this._tilemap.verticalWrap = false; // this._map.isLoopVertical();

      // ウィンドウのスクロール量とタイルマップのスクロール量の比率
      this._scrollTileRatioX = this._tilemap.tileWidth / this.itemWidth();
      this._scrollTileRatioY = this._tilemap.tileHeight / this.itemHeight();

      this.refreshGridSprite();

      // ロード完了までスプライトを隠す
      this._tilemap.visible = false;
      this._destinationSprite.visible = false;
    };

    /**
     * タイルセットの再構築
     */
    Window_DebugMapTile.prototype.refreshTileset = function () {
      if (!this._map) {
        return;
      }

      this._tileset = this._map.tileset();
      if (!this._tileset) {
        return;
      }

      // この時点でタイルセット画像はロード済みでなければならない
      debuglog("Window_DebugMapTile.refreshTileset() called");
      var newTilesetFlags = this._map.tilesetFlags();
      //this._tilemap.refreshTileset();
      if (!this._tilemap.flags.equals(newTilesetFlags)) {
        this._tilemap.refresh();
      }
      this._tilemap.flags = newTilesetFlags;

      // 読み込みが完了したらスプライトを表示
      this._tilemap.visible = true;
      this._destinationSprite.visible = true;
    };

    /**
     * タイルセットの読み込み
     */
    Window_DebugMapTile.prototype.loadTileset = function () {
      if (!this._map) {
        return;
      }

      this._tileset = this._map.tileset();
      if (!this._tileset) {
        return;
      }

      var tilesetNames = this._tileset.tilesetNames;
      for (var i = 0; i < tilesetNames.length; i++) {
        this._tilemap._bitmaps[i] = ImageManager.loadTileset(tilesetNames[i]);
      }
    };

    /**
     * タイルマップ表示の更新
     */
    Window_DebugMapTile.prototype.updateTilemap = function () {
      if (!this._tilemap) {
        return;
      }

      this._tilemap.origin.x = this._scrollX * this._scrollTileRatioX;
      this._tilemap.origin.y = this._scrollY * this._scrollTileRatioY;
      this._tilemap.refresh();
    };

    /**
     * 移動先スプライトの位置を更新
     */
    Window_DebugMapTile.prototype.updateDestinationPosition = function () {
      if (!this._destinationSprite) {
        return;
      }

      var cursor = this.getCursorTile();
      this._destinationSprite.setDestination(
        cursor.x - this.leftCol(),
        cursor.y - this.topRow()
      );
    };

    Window_DebugMapTile.prototype.refresh = function () {
      Window_Selectable.prototype.refresh.call(this);

      this.updateTilemap();
      this.updateDestinationPosition();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugEventList
    //
    // イベント選択用ウィンドウ

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

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

    Window_DebugEventList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = [];
      this._map = null;
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugEventList._lastIndex = 0;

    Window_DebugEventList.prototype.maxCols = function () {
      return 1;
    };

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

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

    Window_DebugEventList.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugEventList.prototype.isEnabled = function (item) {
      return true;
    };

    Window_DebugEventList.prototype.select = function (index) {
      Window_Selectable.prototype.select.call(this, index);
      if (this._switchListWindow) {
        this._switchListWindow.setEvent(this.item());
      }
    };

    Window_DebugEventList.prototype.setMap = function (map) {
      this._map = map;
      this.refresh();
    };

    Window_DebugEventList.prototype.setSwitchListWindow = function (window) {
      this._switchListWindow = window;
      this.select(this.index());
    };

    Window_DebugEventList.prototype.makeItemList = function () {
      if (this._map == null) {
        this._data = [];
        return;
      }

      // この時点でマップデータが一時領域に読み込み済みでなければならない
      this._data = $dataKmsTemporallyMapData.events.filter(function (event) {
        return event != null;
      });
    };

    Window_DebugEventList.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugEventList._lastIndex);
      index = Math.min(index, this._data.length - 1);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugEventList.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (item == null) {
        return;
      }

      this.changePaintOpacity(this.isEnabled(item));
      this.resetTextColor();

      // イベント名描画
      var text = "%1:%2".format(item.id.padZero(4), item.name);
      var rect = _itemRectForText(this, index);
      this.drawText(text, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    };

    Window_DebugEventList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugSelfSwitchList
    //
    // セルフスイッチ選択用ウィンドウ

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

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

    Window_DebugSelfSwitchList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = ["A", "B", "C", "D"];
      this._map = null;
      this._event = null;
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugSelfSwitchList.prototype.maxCols = function () {
      return 1;
    };

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

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

    Window_DebugSelfSwitchList.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugSelfSwitchList.prototype.isEnabled = function (item) {
      return true;
    };

    Window_DebugSelfSwitchList.prototype.setMap = function (map) {
      this._map = map;
      this.refresh();
    };

    Window_DebugSelfSwitchList.prototype.setEvent = function (event) {
      this._event = event;
      this.refresh();
    };

    Window_DebugSelfSwitchList.prototype.selectLast = function () {
      this.select(0);
    };

    /**
     * セルフスイッチアクセス用のキーを取得
     */
    Window_DebugSelfSwitchList.prototype.getKey = function (type) {
      var switchType = type != null ? type : this.item();

      if (this._map != null && this._event.id != null && switchType != null) {
        return [this._map.id, this._event.id, switchType];
      } else {
        return null;
      }
    };

    Window_DebugSelfSwitchList.prototype.drawItem = function (index) {
      var item = this._data[index];
      if (item == null || this._map == null || this._event == null) {
        return;
      }

      this.changePaintOpacity(this.isEnabled(item));
      this.resetTextColor();

      var switchValue = $gameSelfSwitches.value(this.getKey(item));
      var text = "[%1] %2".format(item, switchValue ? "ON" : "OFF");
      var rect = _itemRectForText(this, index);
      this.drawText(text, rect.x, rect.y, rect.width);
      this.changePaintOpacity(1);
    };

    Window_DebugSelfSwitchList.prototype.refresh = function () {
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugSystemValue
    //
    // デバッグ用システム値変更ウィンドウ

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

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

    // 表示データの設定
    Window_DebugSystemValue.DataTypeConfig = {
      // type ... uint: 非負整数
      // get  ... 値取得関数
      // set  ... 値変更関数
      battleCount: {
        type: "uint",
        get: function () {
          return $gameSystem._battleCount;
        },
        set: function (value) {
          $gameSystem._battleCount = value;
        },
      },
      winCount: {
        type: "uint",
        get: function () {
          return $gameSystem._winCount;
        },
        set: function (value) {
          $gameSystem._winCount = value;
        },
      },
      escapeCount: {
        type: "uint",
        get: function () {
          return $gameSystem._escapeCount;
        },
        set: function (value) {
          $gameSystem._escapeCount = value;
        },
      },
      saveCount: {
        type: "uint",
        get: function () {
          return $gameSystem._saveCount;
        },
        set: function (value) {
          $gameSystem._saveCount = value;
        },
      },
    };

    Window_DebugSystemValue.prototype.initialize = function (x, y) {
      this._data = ["battleCount", "winCount", "escapeCount", "saveCount"];

      var width = this.windowWidth();
      var height = this.windowHeight();
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.createContents();
      this.refresh();
      this.select(0);
      this.hide();
    };

    Window_DebugSystemValue.prototype.windowWidth = function () {
      return 360 + _standardPadding() * 2;
    };

    Window_DebugSystemValue.prototype.windowHeight = function () {
      return this.fittingHeight(this.maxItems());
    };

    Window_DebugSystemValue.prototype.maxCols = function () {
      return 1;
    };

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

    /**
     * 選択されているシステム値を表すキー文字列を取得
     */
    Window_DebugSystemValue.prototype.getKey = function () {
      return this.getKeyByIndex(this.index());
    };

    /**
     * インデックスを指定して、システム値を表すキー文字列を取得
     */
    Window_DebugSystemValue.prototype.getKeyByIndex = function (index) {
      if (!this._data || index < 0) {
        return null;
      }

      return this._data[index];
    };

    /**
     * 選択されているシステム値を取得
     */
    Window_DebugSystemValue.prototype.item = function () {
      return this.getItemByIndex(this.index());
    };

    /**
     * インデックスを指定して、システム値を取得
     */
    Window_DebugSystemValue.prototype.getItemByIndex = function (index) {
      var key = this.getKeyByIndex(index);
      if (key == null) {
        return null;
      }

      return Window_DebugSystemValue.DataTypeConfig[key];
    };

    Window_DebugSystemValue.prototype.drawItem = function (index) {
      var key = this.getKeyByIndex(index);
      var item = this.getItemByIndex(index);
      if (key == null || item == null) {
        return;
      }

      var paramName = TextManager.DebugUtil[key];
      var paramValue = item.get();

      var nameWidth = 180;
      var rect = _itemRectForText(this, index);
      this.changeTextColor(this.systemColor());
      this.drawText(paramName, rect.x, rect.y, nameWidth);
      this.resetTextColor();
      var numWidth = rect.width - (rect.x + nameWidth);
      this.drawText(paramValue, rect.x + nameWidth, rect.y, numWidth, "right");
    };

    Window_DebugSystemValue.prototype.refresh = function () {
      this.contents.clear();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugWatch
    //
    // ウォッチ対象データの内容を表示するウィンドウ

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

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

    Window_DebugWatch.prototype.initialize = function (x, y, width, height) {
      this._isAutoPosition = false;

      Window_Base.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.opacity = 0;
      this.openness = 0;

      // Dimmer より手前に更新通知演出を出すため、先に更新通知スプライトを作成
      this.createUpdateSprites();
      this.showBackgroundDimmer();
      this.refresh();
      this.hide();
    };

    /**
     * 更新通知スプライトの作成
     */
    Window_DebugWatch.prototype.createUpdateSprites = function () {
      this._updateSprites = [];

      var lineHeight = this.lineHeight();
      var padding = _standardPadding();
      var count = Math.max(
        Math.floor(
          (Graphics.boxHeight - this.y - _standardPadding() * 2) / lineHeight
        ),
        1
      );
      for (var i = 0; i < count; i++) {
        var sprite = new Sprite_DebugWatchUpdate();
        sprite.setup(
          padding,
          padding + i * lineHeight,
          this.contentsWidth(),
          lineHeight
        );
        this._updateSprites.push(sprite);
        this.addChildToBack(sprite);
      }
    };

    Window_DebugWatch.prototype.lineHeight = function () {
      return (36 * Params.watchFontSize) / _standardFontSize();
    };

    /**
     * ウォッチ対象を取得
     */
    Window_DebugWatch.prototype.getWatchList = function () {
      return $gameTemp.getDebugWatchItemList();
    };

    Window_DebugWatch.prototype.resetFontSettings = function () {
      Window_Base.prototype.resetFontSettings.call(this);

      this.contents.fontSize = Params.watchFontSize;
    };

    /**
     * ウォッチ対象を取得
     */
    Window_DebugWatch.prototype.setAutoPositionEnabled = function (isEnabled) {
      this._isAutoPosition = !!isEnabled;
      if (this._isAutoPosition) {
        this.adjustWindowPosition();
      }
    };

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

      this.visible = this.getWatchList().length > 0;
      this.openness = this.visible ? 255 : 0;

      if ($gameTemp.isDebugWatchRefreshRequested()) {
        this.refresh();
      } else {
        // 更新された項目を再描画
        var list = this.getWatchList();
        for (var i = 0; i < list.length; i++) {
          if (list[i].checkUpdate()) {
            this.updateItem(i);
          }
        }
      }
    };

    /**
     * ウォッチ項目の更新
     */
    Window_DebugWatch.prototype.updateItem = function (index) {
      this.drawItem(index);

      var sprite = this._updateSprites[index];
      if (sprite) {
        sprite.animate();
      }
    };

    /**
     * ウィンドウサイズの調整
     */
    Window_DebugWatch.prototype.adjustWindowSize = function () {
      this.height = this.fittingHeight(Math.max(this.getWatchList().length, 1));
      this.refreshDimmerBitmap();
    };

    /**
     * ウィンドウ位置の調整
     */
    Window_DebugWatch.prototype.adjustWindowPosition = function () {
      if (!this._isAutoPosition) {
        return;
      }

      switch (Params.watchWindowPosition) {
        case Const.WatchWindowPosition.topLeft:
        default:
          this.x = 0;
          this.y = -8;
          break;

        case Const.WatchWindowPosition.topRight:
          this.x = Graphics.boxWidth - this.width;
          this.y = -8;
          break;

        case Const.WatchWindowPosition.bottomLeft:
          this.x = 0;
          this.y = Graphics.boxHeight - this.height + 8;
          break;

        case Const.WatchWindowPosition.bottomRight:
          this.x = Graphics.boxWidth - this.width;
          this.y = Graphics.boxHeight - this.height + 8;
          break;
      }
    };

    Window_DebugWatch.prototype.itemRect = function (index) {
      var rect = new Rectangle();
      rect.width = this.contentsWidth();
      rect.height = this.lineHeight();
      rect.x = 0;
      rect.y = index * rect.height;
      return rect;
    };

    Window_DebugWatch.prototype.itemRectForText = function (index) {
      // Window_Selectable の処理を流用
      return _itemRectForText(this, index);
    };

    Window_DebugWatch.prototype.clearItem = function (index) {
      // Window_Selectable の処理を流用
      Window_Selectable.prototype.clearItem.call(this, index);
    };

    Window_DebugWatch.prototype.drawItem = function (index) {
      var item = this.getWatchList()[index];
      if (!item) {
        return;
      }

      this.clearItem(index);

      var rect = _itemRectForText(this, index);
      this.changeTextColor(this.systemColor());
      this.drawText(
        "[%1:%2] %3".format(item.typeSymbol, item.id.padZero(4), item.name),
        rect.x,
        rect.y,
        rect.width
      );
      this.resetTextColor();
      this.drawText(item.getDisp(), rect.x, rect.y, rect.width, "right");
    };

    Window_DebugWatch.prototype.drawAllItems = function () {
      this.resetFontSettings();
      for (var i = 0; i < this.getWatchList().length; i++) {
        this.drawItem(i);
      }
    };

    Window_DebugWatch.prototype.refresh = function () {
      $gameTemp.clearDebugWatchRefreshRequest();

      this.adjustWindowSize();
      this.adjustWindowPosition();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugWatchItemList
    //
    // ウォッチ項目選択用ウィンドウ

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

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

    Window_DebugWatchItemList._lastIndex = 0;

    Window_DebugWatchItemList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugWatchItemList.prototype.lineHeight = function () {
      return Window_Selectable.prototype.lineHeight.call(this) * 2;
    };

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

    Window_DebugWatchItemList.prototype.selectLast = function () {
      var index = Window_DebugWatchItemList._lastIndex;
      this.select(index < this._data.length ? index : 0);
    };

    /**
     * 選択されている項目を取得
     */
    Window_DebugWatchItemList.prototype.item = function () {
      var index = this.index();
      return this._data && index >= 0 ? this._data[index] : null;
    };

    Window_DebugWatchItemList.prototype.makeItemList = function () {
      this._data = $gameTemp.getDebugWatchItemList().concat("add");
    };

    Window_DebugWatchItemList.prototype.drawItem = function (index) {
      var rect = _itemRectForText(this, index);
      rect.y -= rect.height / 4;

      var item = this._data[index];
      if (!item) {
        return;
      } else if (item === "add") {
        this.drawText(
          "( %1 )".format(TextManager.DebugUtil.addWatchItem),
          rect.x + 32,
          rect.y + rect.height / 4,
          rect.width - 32,
          rect.height / 2
        );
        return;
      }

      this.changeTextColor(this.systemColor());
      this.drawText(item.typename, rect.x, rect.y, rect.width, rect.height / 2);
      this.resetTextColor();
      this.drawText(
        "%1: %2".format(item.id.padZero(4), item.name),
        rect.x,
        rect.y + rect.height / 2,
        rect.width,
        rect.height / 2
      );
    };

    Window_DebugWatchItemList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

    //-----------------------------------------------------------------------------
    // Window_DebugWatchItemEdit
    //
    // ウォッチ項目編集用ウィンドウ

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

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

    Window_DebugWatchItemEdit.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._item = new DebugWatchItem();
      this.setMode(Const.WatchItemEditMode.add);
      this.openness = 0;
      this.deactivate();
      this.refresh();
    };

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

    /**
     * 編集している項目
     */
    Window_DebugWatchItemEdit.prototype.item = function () {
      return this._item;
    };

    /**
     * 編集する項目の設定
     */
    Window_DebugWatchItemEdit.prototype.setItem = function (item) {
      if (item instanceof DebugWatchItem) {
        this._item.copyFrom(item);
        this.setMode(Const.WatchItemEditMode.edit);
      } else {
        // DebugWatchItem でなければ追加モード (初期状態はスイッチ 1 を選択)
        this._item = new DebugWatchItem();
        this._item.setupSwitch(1);
        this.setMode(Const.WatchItemEditMode.add);
      }

      this.refresh();
      this.select(0);
    };

    /**
     * 編集モードの設定
     */
    Window_DebugWatchItemEdit.prototype.setMode = function (mode) {
      if (this._mode === mode) {
        return;
      }

      this._data = ["target", "ok"];

      this._mode = mode;
      if (mode === Const.WatchItemEditMode.edit) {
        this._data.push("remove");
      }
    };

    /**
     * 編集モードの取得
     */
    Window_DebugWatchItemEdit.prototype.getMode = function () {
      var index = this.index();
      return this._data && index >= 0 ? this._data[index] : null;
    };

    Window_DebugWatchItemEdit.prototype.itemRect = function (index) {
      var rect = Window_Selectable.prototype.itemRect.call(this, index);

      // 先頭だけ 2 行サイズにする
      if (index === 0) {
        rect.height += this.lineHeight();
      } else if (index > 0) {
        rect.y += this.lineHeight();
      }

      return rect;
    };

    Window_DebugWatchItemEdit.prototype.drawItem = function (index) {
      var rect = _itemRectForText(this, index);
      var item = this._data[index];
      switch (item) {
        case "target":
          this.drawItemType(rect.x, rect.y, rect.width);
          this.drawItemId(rect.x, rect.y + this.lineHeight(), rect.width);
          break;

        case "ok":
          this.changeTextColor(this.systemColor());
          this.drawText("OK", rect.x + 40, rect.y, rect.width);
          this.resetTextColor();
          break;

        case "remove":
          this.changeTextColor(this.systemColor());
          this.drawText(
            TextManager.DebugUtil.watchItemRemove,
            rect.x + 40,
            rect.y,
            rect.width
          );
          this.resetTextColor();
          break;

        default:
          // 何も表示しない
          break;
      }
    };

    /**
     * 項目の種類を描画
     */
    Window_DebugWatchItemEdit.prototype.drawItemType = function (x, y, width) {
      this.changeTextColor(this.systemColor());
      this.drawText(TextManager.DebugUtil.watchItemType, x, y, 120);
      this.resetTextColor();
      this.drawText(this._item.typename, x + 120, y, width - 120);
    };

    /**
     * 項目の ID を描画
     */
    Window_DebugWatchItemEdit.prototype.drawItemId = function (x, y, width) {
      this.drawText(
        "%1: %2".format(this._item.id.padZero(4), this._item.name),
        x,
        y,
        width
      );
    };

    Window_DebugWatchItemEdit.prototype.refresh = function () {
      this.height = this.fittingHeight(this.maxItems() + 1);
      this.createContents();

      if (this._item) {
        this.drawAllItems();
      }
    };

    //-----------------------------------------------------------------------------
    // Window_DebugTroopList
    //
    // 敵グループ選択用ウィンドウ

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

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

    Window_DebugTroopList.prototype.initialize = function (
      x,
      y,
      width,
      height
    ) {
      Window_Selectable.prototype.initialize.call(
        this,
        new Rectangle(x, y, width, height)
      );
      this._data = [];
      this.refresh();
      this.hide();
      this.selectLast();
    };

    Window_DebugTroopList._lastIndex = 0;

    Window_DebugTroopList.prototype.maxCols = function () {
      return 1;
    };

    Window_DebugTroopList.prototype.spacing = function () {
      return 48;
    };

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

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

    Window_DebugTroopList.prototype.includes = function (item) {
      return item != null;
    };

    Window_DebugTroopList.prototype.isEnabled = function (item) {
      if (item == null) {
        // ランダムエンカウント枠があれば有効
        return $gameMap.encounterList().length > 0;
      } else {
        // 常に有効
        return true;
      }
    };

    Window_DebugTroopList.prototype.makeItemList = function () {
      this._data = $dataTroops.filter(function (item) {
        return this.includes(item);
      }, this);

      // 先頭は現在マップからのランダム選定用 null
      this._data.unshift(null);
    };

    Window_DebugTroopList.prototype.selectLast = function () {
      var index = this._data.indexOf(Window_DebugTroopList._lastIndex);
      this.select(index >= 0 ? index : 0);
    };

    Window_DebugTroopList.prototype.drawItem = function (index) {
      var item = this._data[index];

      this.changePaintOpacity(this.isEnabled(item));
      this.resetTextColor();

      var rect = _itemRectForText(this, index);

      if (item == null) {
        // ランダム選定
        var text = "< %1 >".format(TextManager.DebugUtil.encounterRandom);
        this.drawText(text, rect.x + 80, rect.y, rect.width);
      } else {
        // データベース
        var text = "%1:%2".format(index.padZero(4), item.name);
        this.drawText(text, rect.x, rect.y, rect.width);
      }

      this.changePaintOpacity(1);
    };

    Window_DebugTroopList.prototype.refresh = function () {
      this.makeItemList();
      this.createContents();
      this.drawAllItems();
    };

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

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

      this.createDebugWatchWindow();
    };

    /**
     * ウォッチウィンドウの作成
     */
    Scene_Map.prototype.createDebugWatchWindow = function () {
      if (!$gameTemp.isPlaytest()) {
        return;
      }

      this._debugWatchWindow = new Window_DebugWatch(
        0,
        0,
        Params.watchWindowWidth,
        100
      );
      this._debugWatchWindow.setAutoPositionEnabled(true);
      this._debugWatchWindow.show();
      this.addWindow(this._debugWatchWindow);
    };

    //-----------------------------------------------------------------------------
    // Scene_Debug

    var _Scene_Debug_create = Scene_Debug.prototype.create;
    Scene_Debug.prototype.create = function () {
      _Scene_Debug_create.call(this);

      // 初期化時間短縮のため、汎用のウィンドウ以外は遅延初期化する
      this.createUpperWindowLayer();
      this.createTitleWindow();
      this.createCommandWindow();
      this.createHelpWindow();
      this.createNumberWindow();

      this.initializeWindowStates();
    };

    var _Scene_Debug_createHelpWindow = Scene_Debug.prototype.createHelpWindow;
    Scene_Debug.prototype.createHelpWindow = function () {
      _Scene_Debug_createHelpWindow.call(this);

      this._helpWindow.y = this._titleWindow.height;
    };

    var _Scene_Debug_createEditWindow = Scene_Debug.prototype.createEditWindow;
    Scene_Debug.prototype.createEditWindow = function () {
      _Scene_Debug_createEditWindow.call(this);

      // updateSwitch と updateVariable は都度置き換えて使うので一旦消す
      this._editWindow.updateSwitch = this._editWindow.updateVariable =
        function () {};
    };

    /**
     * ウィンドウの初期パラメータ調整
     */
    Scene_Debug.prototype.initializeWindowStates = function () {
      // タイトルウィンドウ分の高さ調整
      var wy = this._titleWindow.height;
      this._rangeWindow.y = wy;
      this._rangeWindow.height -= wy;
      this._editWindow.y = wy;
      this._editWindow.height = this._rangeWindow.height;
      /*
    this._debugHelpWindow.y      = wy + this._editWindow.height;
    this._debugHelpWindow.height = Graphics.boxHeight - this._debugHelpWindow.y;
    this._debugHelpWindow.resetFontSettings = function()
    {
        Window_Base.prototype.resetFontSettings.call(this);

        this.contents.fontSize *= 0.75;
    };
*/

      // 表示状態で作成されるが、初期状態では非表示にしておくウィンドウ群
      this._rangeWindow.deactivate();
      this._rangeWindow.hide();
      this._editWindow.hide();
      this._debugHelpWindow.hide();
      this._helpWindow.hide();
    };

    /**
     * 上層ウィンドウレイヤーの作成
     */
    Scene_Debug.prototype.createUpperWindowLayer = function () {
      var width = Graphics.boxWidth;
      var height = Graphics.boxHeight;
      var x = (Graphics.width - width) / 2;
      var y = (Graphics.height - height) / 2;
      this._upperWindowLayer = new WindowLayer();
      this._upperWindowLayer.x = x;
      this._upperWindowLayer.y = y;
      this._upperWindowLayer.width = width;
      this._upperWindowLayer.height = height;
      //this._upperWindowLayer.move(x, y, width, height);
      this.addChild(this._upperWindowLayer);

      if (KMS.imported["CursorAnimation"]) {
        this._animationCursor.addWindowLayer(this._upperWindowLayer);
      }
    };

    /**
     * タイトルウィンドウを作成
     */
    Scene_Debug.prototype.createTitleWindow = function () {
      this._titleWindow = new Window_DebugTitle(Graphics.boxWidth, 1);
      this._titleWindow.setText(TextManager.DebugUtil.sceneTitle);
      this.addWindow(this._titleWindow);
    };

    /**
     * コマンドウィンドウを作成
     */
    Scene_Debug.prototype.createCommandWindow = function () {
      var wx = 32;
      var wy = this._titleWindow.height + 32;
      this._commandWindow = new Window_DebugCommand(wx, wy);
      this._commandWindow.setHandler(
        "itemNumber",
        this.onSelectItem.bind(this)
      );
      this._commandWindow.setHandler(
        "actorParam",
        this.onSelectActor.bind(this)
      );
      this._commandWindow.setHandler(
        "member",
        this.onSelectPartyMember.bind(this)
      );
      this._commandWindow.setHandler("reloadMap", this.onReloadMap.bind(this));
      this._commandWindow.setHandler(
        "loadDatabase",
        this.onReloadDatabase.bind(this)
      );
      this._commandWindow.setHandler(
        "transfer",
        this.onTransferMapStart.bind(this)
      );
      this._commandWindow.setHandler(
        "switchVar",
        this.onSwitchVarStart.bind(this)
      );
      this._commandWindow.setHandler(
        "selfSwitch",
        this.onSelfSwitchMapStart.bind(this)
      );
      this._commandWindow.setHandler(
        "systemValue",
        this.onSelectSystemValue.bind(this)
      );
      this._commandWindow.setHandler(
        "watchWindow",
        this.onWatchWindow.bind(this)
      );
      this._commandWindow.setHandler(
        "encounter",
        this.onForceEncounter.bind(this)
      );
      //this._commandWindow.setHandler('dispPassage',  this.onDispPassage.bind(this));
      this._commandWindow.setHandler("cancel", this.popScene.bind(this));

      // 追加コマンド
      KMS.DebugUtil.debugCommands.forEach(function (command) {
        this._commandWindow.setHandler(command.id, command.onSelect.bind(this));
      }, this);

      this.addWindow(this._commandWindow);
    };

    /**
     * アイテムウィンドウを作成
     */
    Scene_Debug.prototype.createItemWindow = function () {
      if (this._itemWindow) {
        return;
      }

      var wy = this._helpWindow.y + this._helpWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._itemWindow = new Window_DebugItemList(0, wy, Graphics.boxWidth, wh);
      this._itemWindow.setHelpWindow(this._helpWindow);
      this._itemWindow.setHandler("ok", this.onItemOk.bind(this));
      this._itemWindow.setHandler("cancel", this.onItemCancel.bind(this));
      this.addWindow(this._itemWindow);
    };

    /**
     * アクターパラメータ編集ウィンドウを作成
     */
    Scene_Debug.prototype.createActorParamWindow = function () {
      if (this._actorParamWindow) {
        return;
      }

      var wx = 360;
      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth - wx;
      var wh = Graphics.boxHeight - wy;
      this._actorParamWindow = new Window_DebugActorParam(wx, wy, ww, wh);
      this._actorParamWindow.setHandler("ok", this.onActorParamOk.bind(this));
      this._actorParamWindow.setHandler(
        "cancel",
        this.onActorParamCancel.bind(this)
      );
      this.addWindow(this._actorParamWindow);

      if (this._actorListWindow) {
        // 先に ActorListWindow を作ったときに腐らない用
        this._actorListWindow.setStatusWindow(this._actorParamWindow);
      }
    };

    /**
     * アクター一覧ウィンドウを作成
     */
    Scene_Debug.prototype.createActorListWindow = function () {
      if (this._actorListWindow) {
        return;
      }

      var wy = this._titleWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._actorListWindow = new Window_DebugActorList(0, wy, 360, wh);
      this._actorListWindow.setHandler("ok", this.onActorOk.bind(this));
      this._actorListWindow.setHandler("cancel", this.onActorCancel.bind(this));
      this._actorListWindow.setStatusWindow(this._actorParamWindow);
      this.addWindow(this._actorListWindow);
    };

    /**
     * アクタースキル編集ウィンドウを作成
     */
    Scene_Debug.prototype.createActorSkillWindow = function () {
      if (this._actorSkillWindow) {
        return;
      }

      var wy = this._helpWindow.y + this._helpWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._actorSkillWindow = new Window_DebugActorSkill(
        0,
        wy,
        Graphics.boxWidth,
        wh
      );
      this._actorSkillWindow.setHelpWindow(this._helpWindow);
      this._actorSkillWindow.setHandler("ok", this.onActorSkillOk.bind(this));
      this._actorSkillWindow.setHandler(
        "cancel",
        this.onActorSkillCancel.bind(this)
      );
      this.addWindow(this._actorSkillWindow);
    };

    /**
     * パーティメンバー用ウィンドウを作成
     */
    Scene_Debug.prototype.createPartyWindow = function () {
      if (this._activePartyWindow) {
        return;
      }

      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth / 2;
      this._activePartyTitleWindow = new Window_DebugTitle(ww, 1);
      this._activePartyTitleWindow.y = wy;
      this._activePartyTitleWindow.setText(TextManager.DebugUtil.activeParty);
      this.addWindow(this._activePartyTitleWindow);

      this._reservePartyTitleWindow = new Window_DebugTitle(ww, 1);
      this._reservePartyTitleWindow.x = ww;
      this._reservePartyTitleWindow.y = wy;
      this._reservePartyTitleWindow.setText(TextManager.DebugUtil.reserveParty);
      this.addWindow(this._reservePartyTitleWindow);

      wy += this._activePartyTitleWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._activePartyWindow = new Window_DebugActivePartyList(0, wy, ww, wh);
      this._activePartyWindow.setHandler("ok", this.onActivePartyOk.bind(this));
      this._activePartyWindow.setHandler(
        "formation",
        this.onActivePartyFormationStart.bind(this)
      );
      this._activePartyWindow.setHandler(
        "cancel",
        this.onActivePartyCancel.bind(this)
      );
      this.addWindow(this._activePartyWindow);

      this._reservePartyWindow = new Window_DebugReservePartyList(
        ww,
        wy,
        ww,
        wh
      );
      this._reservePartyWindow.setHandler(
        "ok",
        this.onReservePartyOk.bind(this)
      );
      this._reservePartyWindow.setHandler(
        "cancel",
        this.onReservePartyCancel.bind(this)
      );
      this.addWindow(this._reservePartyWindow);
    };

    /**
     * マップ一覧ウィンドウを作成
     */
    Scene_Debug.prototype.createMapListWindow = function () {
      if (this._mapListWindow) {
        return;
      }

      // OK / キャンセルハンドラはコマンドに応じて変わるので、ここでは設定しない
      var wy = this._titleWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._mapListWindow = new Window_DebugMapList(0, wy, 360, wh);
      this.addWindow(this._mapListWindow);
    };

    /**
     * タイルウィンドウを作成
     */
    Scene_Debug.prototype.createMapTileWindow = function () {
      if (this._mapTileWindow) {
        return;
      }

      var wx = 360;
      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth - wx;
      this._mapTilePositionWindow = new Window_DebugMapTilePosition(wx, wy, ww);
      this.addWindow(this._mapTilePositionWindow);

      wy = this._mapTilePositionWindow.y + this._mapTilePositionWindow.height;
      var wh = Graphics.boxHeight - wy;
      this._mapTileWindow = new Window_DebugMapTile(wx, wy, ww, wh);
      this._mapTileWindow.setHandler("ok", this.onTransferMapTileOk.bind(this));
      this._mapTileWindow.setHandler(
        "cancel",
        this.onTransferMapTileCancel.bind(this)
      );
      this._mapTileWindow.setPositionWindow(this._mapTilePositionWindow);
      this.addWindow(this._mapTileWindow);
    };

    /**
     * イベント一覧ウィンドウを作成
     */
    Scene_Debug.prototype.createEventListWindow = function () {
      if (this._eventListWindow) {
        return;
      }

      var wx = 360;
      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth - wx;
      this._eventListWindow = new Window_DebugEventList(wx, wy, ww, 64);
      var wh = Graphics.boxHeight - wy - this._eventListWindow.fittingHeight(4);
      this._eventListWindow.height = wh;
      this._eventListWindow.setHandler(
        "ok",
        this.onSelfSwitchEventListOk.bind(this)
      );
      this._eventListWindow.setHandler(
        "cancel",
        this.onSelfSwitchEventListCancel.bind(this)
      );
      this.addWindow(this._eventListWindow);
    };

    /**
     * セルフスイッチ一覧ウィンドウを作成
     */
    Scene_Debug.prototype.createSelfSwitchListWindow = function () {
      if (this._selfSwitchListWindow) {
        return;
      }

      var wx = this._eventListWindow.x;
      var wy = this._eventListWindow.y + this._eventListWindow.height;
      var ww = this._eventListWindow.width;
      var wh = Graphics.boxHeight - wy;
      this._selfSwitchListWindow = new Window_DebugSelfSwitchList(
        wx,
        wy,
        ww,
        wh
      );
      this._selfSwitchListWindow.setHandler(
        "ok",
        this.onSelfSwitchListOk.bind(this)
      );
      this._selfSwitchListWindow.setHandler(
        "cancel",
        this.onSelfSwitchListCancel.bind(this)
      );
      this.addWindow(this._selfSwitchListWindow);

      this._eventListWindow.setSwitchListWindow(this._selfSwitchListWindow);
    };

    /**
     * システム値ウィンドウを作成
     */
    Scene_Debug.prototype.createSystemValueWindow = function () {
      if (this._systemValueWindow) {
        return;
      }

      var wy = this._titleWindow.height + 32;
      this._systemValueWindow = new Window_DebugSystemValue(0, wy);
      this._systemValueWindow.x =
        (Graphics.boxWidth - this._systemValueWindow.width) / 2;
      this._systemValueWindow.setHandler("ok", this.onSystemValueOk.bind(this));
      this._systemValueWindow.setHandler(
        "cancel",
        this.onSystemValueCancel.bind(this)
      );
      this.addWindow(this._systemValueWindow);
    };

    /**
     * ウォッチウィンドウを作成
     */
    Scene_Debug.prototype.createWatchWindow = function () {
      if (this._watchWindow) {
        return;
      }

      var wx = 0;
      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth / 2;
      var wh = Graphics.boxHeight - wy;
      this._watchWindow = new Window_DebugWatch(wx, wy, ww, wh);

      // ウォッチ項目リストウィンドウより前に入れる
      if (this._watchEditWindow) {
        var index = this._windowLayer.getChildIndex(this._watchEditWindow);
        this._windowLayer.addChildAt(this._watchWindow, index);
      } else {
        this.addWindow(this._watchWindow);
      }
    };

    /**
     * ウォッチウィンドウを破棄
     */
    Scene_Debug.prototype.destroyWatchWindow = function () {
      if (!this._watchWindow) {
        return;
      }

      this._windowLayer.removeChild(this._watchWindow);
      delete this._watchWindow;
    };

    /**
     * ウォッチ項目リストウィンドウを作成
     */
    Scene_Debug.prototype.createWatchListWindow = function () {
      if (this._watchListWindow) {
        return;
      }

      var wx = Graphics.boxWidth / 2;
      var wy = this._titleWindow.height;
      var ww = Graphics.boxWidth - wx;
      var wh = Graphics.boxHeight - wy;
      this._watchListWindow = new Window_DebugWatchItemList(wx, wy, ww, wh);
      this._watchListWindow.setHandler("ok", this.onWatchListOk.bind(this));
      this._watchListWindow.setHandler(
        "cancel",
        this.onWatchListCancel.bind(this)
      );
      this.addWindow(this._watchListWindow);
    };

    /**
     * ウォッチ項目編集ウィンドウを作成
     */
    Scene_Debug.prototype.createWatchEditWindow = function () {
      if (this._watchEditWindow) {
        return;
      }

      var ww = (Graphics.boxWidth * 3) / 5;
      var wx = (Graphics.boxWidth - ww) / 2;
      var wy = this._titleWindow.height + 32;
      var wh = Graphics.boxHeight - wy - 32;
      this._watchEditWindow = new Window_DebugWatchItemEdit(wx, wy, ww, wh);
      this._watchEditWindow.setHandler("ok", this.onWatchEditOk.bind(this));
      this._watchEditWindow.setHandler(
        "cancel",
        this.onWatchEditCancel.bind(this)
      );
      this.addWindow(this._watchEditWindow);
    };

    /**
     * 敵グループウィンドウを作成
     */
    Scene_Debug.prototype.createTroopWindow = function () {
      if (this._troopWindow) {
        return;
      }

      var wx = 32;
      var wy = this._titleWindow.height + 32;
      var ww = Graphics.boxWidth - 64;
      var wh = Graphics.boxHeight - wy - 32;
      this._troopWindow = new Window_DebugTroopList(wx, wy, ww, wh);
      this._troopWindow.setHandler("ok", this.onTroopOk.bind(this));
      this._troopWindow.setHandler("cancel", this.onTroopCancel.bind(this));
      this.addWindow(this._troopWindow);
    };

    /**
     * 数値入力ウィンドウを作成
     */
    Scene_Debug.prototype.createNumberWindow = function () {
      this._numberWindow = new Window_DebugNumberInput();
      this._upperWindowLayer.addChild(this._numberWindow);
    };

    /**
     * シーンの準備完了判定
     */
    var _Scene_Debug_isReady = Scene_Debug.prototype.isReady;
    Scene_Debug.prototype.isReady = function () {
      return (
        _Scene_Debug_isReady.call(this) &&
        DataManager.isDatabaseLoaded() &&
        DataManager.isMapLoaded() &&
        (!this._isLoadingTemporallyMap ||
          DataManager.isKmsTemporallyMapLoaded())
      );
    };

    /**
     * シーンの更新
     */
    var _Scene_Debug_update = Scene_Debug.prototype.update;
    Scene_Debug.prototype.update = function () {
      // 読み込み中は更新しない
      if (!this.isReady()) {
        return;
      }

      // ロード完了時の処理
      if (this._loadCompleteHandler) {
        this._loadCompleteHandler.call(this);
        delete this._loadCompleteHandler;
      }

      _Scene_Debug_update.call(this);

      // update 後の処理
      if (this._postUpdateProc) {
        this._postUpdateProc.call(this);
        delete this._postUpdateProc;
      }
    };

    /**
     * メインコマンドウィンドウをアクティブ化
     */
    Scene_Debug.prototype.activateCommandWindow = function () {
      this._commandWindow.show();
      this._commandWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.sceneTitle);
    };

    /**
     * アイテム選択の実行
     */
    Scene_Debug.prototype.onSelectItem = function () {
      this.createItemWindow();

      this._commandWindow.hide();
      this._helpWindow.show();
      this._itemWindow.show();
      this._itemWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.itemNumber);
    };

    /**
     * アイテムの決定
     */
    Scene_Debug.prototype.onItemOk = function () {
      this._numberWindow.setHandler(
        "cancel",
        this.onItemNumberCancel.bind(this)
      );

      var item = this._itemWindow.item();
      var number = $gameParty.numItems(item);
      var digits = $gameParty.maxItems(item).toString().length;
      this._numberWindow.setCaption(item);
      this._numberWindow.setAllowNegative(false);
      this._numberWindow.start(number, digits, this.onItemNumberOk.bind(this));
    };

    /**
     * アイテム選択のキャンセル処理
     */
    Scene_Debug.prototype.onItemCancel = function () {
      this._helpWindow.hide();
      this._itemWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * アイテム個数入力の決定
     */
    Scene_Debug.prototype.onItemNumberOk = function (number) {
      // アイテム所持数の設定 (Game_Party に対して呼ぶ)
      var setItemNumber = function (item, number) {
        var currNumber = this.numItems(item);
        var amount = number - currNumber;
        this.gainItem(item, amount, false);
      };

      setItemNumber.call($gameParty, this._itemWindow.item(), number);

      this._itemWindow.refresh();
      this.onItemNumberCancel();
    };

    /**
     * アイテム個数入力のキャンセル処理
     */
    Scene_Debug.prototype.onItemNumberCancel = function () {
      this._numberWindow.close();
      this._itemWindow.activate();
    };

    /**
     * アクター選択の実行
     */
    Scene_Debug.prototype.onSelectActor = function () {
      this.createActorParamWindow();
      this.createActorListWindow();
      this.createActorSkillWindow();

      this._commandWindow.hide();
      this._actorListWindow.show();
      this._actorParamWindow.show();
      this._actorListWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.actorParam);
    };

    /**
     * アクターの決定
     */
    Scene_Debug.prototype.onActorOk = function () {
      this._actorParamWindow.activate();
    };

    /**
     * アクター選択のキャンセル処理
     */
    Scene_Debug.prototype.onActorCancel = function () {
      this._actorListWindow.hide();
      this._actorParamWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * アクターパラメータの決定
     */
    Scene_Debug.prototype.onActorParamOk = function () {
      var actor = this._actorListWindow.item();
      var param = this._actorParamWindow.item();

      var caption;
      var number;
      var digits;
      var negative;
      switch (param) {
        case "level":
          {
            caption = TextManager.level;
            number = actor.level;
            digits = actor.maxLevel().toString().length;
            negative = false;
          }
          break;

        case "skill":
          {
            // スキル編集ウィンドウに切り替え
            this._actorListWindow.hide();
            this._actorParamWindow.hide();
            this._helpWindow.show();
            this._actorSkillWindow.setActor(actor);
            this._actorSkillWindow.selectLast();
            this._actorSkillWindow.show();
            this._actorSkillWindow.activate();
          }
          return;

        default:
          {
            var paramId = this._actorParamWindow.paramId();
            caption = TextManager.param(paramId) + "+";
            number = originalParamPlus.call(actor, paramId);
            digits = 4;
            negative = true;
          }
          break;
      }

      this._numberWindow.setCaption(caption);
      this._numberWindow.setAllowNegative(negative);
      this._numberWindow.setHandler(
        "cancel",
        this.onActorParamInputCancel.bind(this)
      );
      this._numberWindow.start(
        number,
        digits,
        this.onActorParamInputOk.bind(this)
      );
    };

    /**
     * アクターパラメータのキャンセル処理
     */
    Scene_Debug.prototype.onActorParamCancel = function () {
      this._actorListWindow.activate();
    };

    /**
     * アクターパラメータ入力の決定
     */
    Scene_Debug.prototype.onActorParamInputOk = function (number) {
      var actor = this._actorListWindow.item();
      var param = this._actorParamWindow.item();

      if (param === "level") {
        if (actor.level !== number) {
          actor.changeLevel(number, false);
        }
      } else {
        // パラメータの設定 (Game_Actor に対して呼ぶ)
        var setParameter = function (paramId, value) {
          var currValue = originalParamPlus.call(this, paramId);
          var amount = value - currValue;
          this.addParam(paramId, amount);
        };

        var paramId = this._actorParamWindow.paramId();
        setParameter.call(actor, paramId, number);
      }

      this._actorParamWindow.refresh();
      this.onActorParamInputCancel();
    };

    /**
     * アクターパラメータ入力のキャンセル処理
     */
    Scene_Debug.prototype.onActorParamInputCancel = function () {
      this._numberWindow.close();
      this._actorParamWindow.activate();
    };

    /**
     * アクタースキル編集の決定処理
     */
    Scene_Debug.prototype.onActorSkillOk = function () {
      // 選択したスキルの習得状態を切り替え
      var skill = this._actorSkillWindow.item();
      var actor = this._actorListWindow.item();
      if (actor.isLearnedSkill(skill.id)) {
        actor.forgetSkill(skill.id);
      } else {
        actor.learnSkill(skill.id);
      }

      this._actorSkillWindow.redrawItem(this._actorSkillWindow.index());
      this._actorSkillWindow.activate();
    };

    /**
     * アクタースキル編集のキャンセル処理
     */
    Scene_Debug.prototype.onActorSkillCancel = function () {
      this._helpWindow.hide();
      this._actorSkillWindow.hide();
      this._actorListWindow.show();
      this._actorParamWindow.refresh();
      this._actorParamWindow.show();
      this._actorParamWindow.activate();
    };

    /**
     * パーティ編成の実行
     */
    Scene_Debug.prototype.onSelectPartyMember = function () {
      this.createPartyWindow();

      this._commandWindow.hide();
      this._activePartyTitleWindow.show();
      this._reservePartyTitleWindow.show();
      this._activePartyWindow.show();
      this._activePartyWindow.activate();
      this._activePartyWindow.select(0);
      this._reservePartyWindow.show();
      this._reservePartyWindow.select(0);
      this._titleWindow.setText(TextManager.DebugUtil.member);
    };

    /**
     * パーティ編成: パーティ内アクター選択の決定
     */
    Scene_Debug.prototype.onActivePartyOk = function () {
      this._reservePartyWindow.activate();
    };

    /**
     * パーティ編成: パーティ内アクター選択のキャンセル
     */
    Scene_Debug.prototype.onActivePartyCancel = function () {
      this._activePartyTitleWindow.hide();
      this._reservePartyTitleWindow.hide();
      this._activePartyWindow.hide();
      this._reservePartyWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * パーティ編成: パーティ内アクター並び替えの開始
     */
    Scene_Debug.prototype.onActivePartyFormationStart = function () {
      this._activePartyWindow.setPendingIndex(this._activePartyWindow.index());
      this._activePartyWindow.setFormationChangeMode(true);
      this._activePartyWindow.refresh();
      this._activePartyWindow.setHandler(
        "ok",
        this.onActivePartyFormationOk.bind(this)
      );
      this._activePartyWindow.setHandler(
        "formation",
        this.onActivePartyFormationOk.bind(this)
      );
      this._activePartyWindow.setHandler(
        "cancel",
        this.onActivePartyFormationCancel.bind(this)
      );
    };

    /**
     * パーティ編成: パーティ内アクター並び替えの決定
     */
    Scene_Debug.prototype.onActivePartyFormationOk = function () {
      $gameParty.swapOrder(
        this._activePartyWindow.getPendingIndex(),
        this._activePartyWindow.index()
      );

      this._activePartyWindow.setFormationChangeMode(false);
      this._activePartyWindow.refresh();
      this._activePartyWindow.setHandler("ok", this.onActivePartyOk.bind(this));
      this._activePartyWindow.setHandler(
        "formation",
        this.onActivePartyFormationStart.bind(this)
      );
      this._activePartyWindow.setHandler(
        "cancel",
        this.onActivePartyCancel.bind(this)
      );
    };

    /**
     * パーティ編成: パーティ内アクター並び替えのキャンセル
     */
    Scene_Debug.prototype.onActivePartyFormationCancel = function () {
      this._activePartyWindow.setFormationChangeMode(false);
      this._activePartyWindow.refresh();
      this._activePartyWindow.setHandler("ok", this.onActivePartyOk.bind(this));
      this._activePartyWindow.setHandler(
        "formation",
        this.onActivePartyFormationStart.bind(this)
      );
      this._activePartyWindow.setHandler(
        "cancel",
        this.onActivePartyCancel.bind(this)
      );
      this._activePartyWindow.activate();
    };

    /**
     * パーティ編成: 待機メンバー選択の決定
     */
    Scene_Debug.prototype.onReservePartyOk = function () {
      // 選択したアクター同士を入れ替える
      var inActor = this._reservePartyWindow.item();
      var outActor = this._activePartyWindow.item();
      replaceActor.call($gameParty, inActor, outActor);

      this._activePartyWindow.refresh();
      this._activePartyWindow.activate();
      this._reservePartyWindow.refresh();
    };

    /**
     * パーティ編成: 待機メンバー選択のキャンセル
     */
    Scene_Debug.prototype.onReservePartyCancel = function () {
      this._activePartyWindow.activate();
    };

    /**
     * マップリロードの実行
     */
    Scene_Debug.prototype.onReloadMap = function () {
      $gameMap.setup($gameMap._mapId);
      this.popScene();

      // XXX: 入り直しせずにリロードする？
      //DataManager.loadMapData();
      //$gameMap._tilesetId = $dataMap.tilesetId;
      //$gameMap.refereshVehicles();
      //$gameMap.setupParallax();
      //$gameMap.setupBattleback();
      //$gameMap.refresh();
    };

    /**
     * データベースリロードの実行
     */
    Scene_Debug.prototype.onReloadDatabase = function () {
      // null 参照回避のため、update 完了後にリロードする
      this._postUpdateProc = function () {
        DataManager.loadDatabase();
      };

      // データベースロード完了後の処理
      this._loadCompleteHandler = function () {
        // ウォッチ項目の再構築
        $gameTemp.getDebugWatchItemList().forEach(function (item) {
          item.refresh();
        });

        function reload(window) {
          if (window) {
            window.refresh();
          }
        }

        // データベースに依存しているウィンドウを再描画
        reload(this._itemWindow);
        reload(this._actorListWindow);
        reload(this._actorParamWindow);
        reload(this._activePartyWindow);
        reload(this._reservePartyWindow);
        reload(this._mapListWindow);
        reload(this._rangeWindow);
        reload(this._editWindow);
        reload(this._watchListWindow);
        reload(this._troopWindow);

        // 追加コマンド
        KMS.DebugUtil.debugCommands.forEach(function (command) {
          command.onReloadDatabase.call(this);
        }, this);

        // 追加処理
        KMS.DebugUtil.databaseReloadHandlers.forEach(function (handler) {
          handler.call(window);
        });

        this._commandWindow.activate();
      };
    };

    /**
     * 場所移動コマンドの実行
     */
    Scene_Debug.prototype.onTransferMapStart = function () {
      this.createMapListWindow();
      this.createMapTileWindow();

      // マップ一覧のハンドラを設定
      this._mapListWindow.setHandler("ok", this.onTransferMapListOk.bind(this));
      this._mapListWindow.setHandler(
        "cancel",
        this.onTransferMapListCancel.bind(this)
      );

      this._commandWindow.hide();
      this._mapListWindow.show();
      this._mapTilePositionWindow.show();
      this._mapTileWindow.show();
      this._mapListWindow.selectLast();
      this._mapListWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.transfer);
    };

    /**
     * 場所移動: マップの決定
     */
    Scene_Debug.prototype.onTransferMapListOk = function () {
      // null 参照回避のため、update 完了後にマップを読み込む
      this._postUpdateProc = function () {
        var map = this._mapListWindow.item();
        DataManager.loadMapData(map.id);
      };

      // マップデータ読み込み完了時の処理
      this._loadCompleteHandler = function () {
        debuglog("DataManager.loadMapData finished");

        // update 完了後にタイルセットを読み込む
        this._postUpdateProc = function () {
          var map = this._mapListWindow.item();
          this._mapTileWindow.setupMap(map.id);
          this._mapTileWindow.loadTileset();

          // タイルセットの読み込み完了後に表示を反映
          this._loadCompleteHandler = function () {
            debuglog("Window_DebugMapTile.loadTileset finished");

            this._mapTileWindow.refreshTileset();
            this._mapTileWindow.activate();
          };
        };
      };
    };

    /**
     * 場所移動: マップ選択のキャンセル
     */
    Scene_Debug.prototype.onTransferMapListCancel = function () {
      this._mapListWindow.hide();
      this._mapTileWindow.hide();
      this._mapTilePositionWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * 場所移動: タイルの決定
     */
    Scene_Debug.prototype.onTransferMapTileOk = function () {
      // 移動先を設定
      var info = this._mapTileWindow.getTransferInfo();
      $gamePlayer.reserveTransfer(
        info.mapId,
        info.x,
        info.y,
        info.d,
        info.fadeType
      );

      // マップに戻る
      this.popScene();
    };

    /**
     * 場所移動: タイル選択のキャンセル
     */
    Scene_Debug.prototype.onTransferMapTileCancel = function () {
      this._mapTileWindow.setupMap(0);
      this._mapListWindow.activate();
    };

    /**
     * スイッチ・変数コマンドの実行
     */
    Scene_Debug.prototype.onSwitchVarStart = function () {
      // ハンドラの切り替え
      this._rangeWindow.setHandler("cancel", this.onSwitchVarCancel.bind(this));
      this._editWindow.setHandler("ok", this.onSwitchVarOk.bind(this));

      this._commandWindow.hide();
      this._rangeWindow.show();
      this._editWindow.show();
      this._rangeWindow.activate();
      this.refreshHelpWindow();
      this._titleWindow.setText(TextManager.DebugUtil.switchVar);
    };

    /**
     * スイッチ・変数範囲ウィンドウのキャンセル処理
     */
    Scene_Debug.prototype.onSwitchVarCancel = function () {
      this._rangeWindow.hide();
      this._editWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * スイッチ・変数編集ウィンドウの決定
     */
    Scene_Debug.prototype.onSwitchVarOk = function () {
      var id = this._editWindow.currentId();
      switch (this._editWindow.getMode()) {
        case "switch":
          {
            // スイッチを切り替える
            $gameSwitches.setValue(id, !$gameSwitches.value(id));
            this._editWindow.redrawCurrentItem();
            this._editWindow.activate();
          }
          break;

        case "variable":
          {
            // 変数の入力
            var caption = "%1:%2".format(
              id.padZero(4),
              this._editWindow.itemName(id)
            );
            var number = $gameVariables.value(id);
            var digits = Params.variableInputDigits;

            this._numberWindow.setCaption(caption);
            this._numberWindow.setAllowNegative(true);
            this._numberWindow.setHandler(
              "cancel",
              this.onSwitchVarInputCancel.bind(this)
            );
            this._numberWindow.start(
              number,
              digits,
              this.onSwitchVarInputOk.bind(this)
            );
          }
          break;

        default:
          // 来ないはずだが、とりあえず無反応にする
          this._editWindow.activate();
          break;
      }
    };

    /**
     * スイッチ・変数操作: 入力の決定
     */
    Scene_Debug.prototype.onSwitchVarInputOk = function (number) {
      $gameVariables.setValue(this._editWindow.currentId(), number);
      this._editWindow.redrawCurrentItem();

      // 入力の終了処理はキャンセルと同じ
      this.onSwitchVarInputCancel();
    };

    /**
     * スイッチ・変数操作: 入力のキャンセル処理
     */
    Scene_Debug.prototype.onSwitchVarInputCancel = function () {
      this._numberWindow.close();
      this._editWindow.activate();
    };

    /**
     * セルフスイッチコマンドの実行
     */
    Scene_Debug.prototype.onSelfSwitchMapStart = function () {
      this.createMapListWindow();
      this.createEventListWindow();
      this.createSelfSwitchListWindow();

      // マップ一覧のハンドラを設定
      this._mapListWindow.setHandler(
        "ok",
        this.onSelfSwitchMapListOk.bind(this)
      );
      this._mapListWindow.setHandler(
        "cancel",
        this.onSelfSwitchMapListCancel.bind(this)
      );

      // ウィンドウ切り替え
      this._commandWindow.hide();
      this._mapListWindow.show();
      this._eventListWindow.show();
      this._selfSwitchListWindow.show();
      this._mapListWindow.selectLast();
      this._mapListWindow.activate();
      this.refreshHelpWindow();
      this._titleWindow.setText(TextManager.DebugUtil.selfSwitch);
    };

    /**
     * セルフスイッチ: マップの決定
     */
    Scene_Debug.prototype.onSelfSwitchMapListOk = function () {
      this._isLoadingTemporallyMap = true;

      var map = this._mapListWindow.item();
      DataManager.loadKmsTemporallyMapData(map.id);

      // マップデータ読み込み完了後の処理
      this._loadCompleteHandler = function () {
        this._isLoadingTemporallyMap = false;

        var map = this._mapListWindow.item();
        this._eventListWindow.setMap(map);
        this._selfSwitchListWindow.setMap(map);
        this._eventListWindow.selectLast();
        this._eventListWindow.activate();
      };
    };

    /**
     * セルフスイッチ: マップ選択のキャンセル
     */
    Scene_Debug.prototype.onSelfSwitchMapListCancel = function () {
      this._mapListWindow.hide();
      this._eventListWindow.hide();
      this._selfSwitchListWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * セルフスイッチ: イベントの決定
     */
    Scene_Debug.prototype.onSelfSwitchEventListOk = function () {
      //var event = this._eventListWindow.item();
      //this._selfSwitchListWindow.setEvent(event);
      this._selfSwitchListWindow.activate();
    };

    /**
     * セルフスイッチ: イベント選択のキャンセル
     */
    Scene_Debug.prototype.onSelfSwitchEventListCancel = function () {
      this._eventListWindow.setMap(null);
      this._selfSwitchListWindow.setMap(null);
      this._mapListWindow.activate();

      $dataKmsTemporallyMapData = null;
    };

    /**
     * セルフスイッチの決定
     */
    Scene_Debug.prototype.onSelfSwitchListOk = function () {
      var key = this._selfSwitchListWindow.getKey();
      if (key == null) {
        return;
      }

      // ON/OFF 切り替え
      $gameSelfSwitches.setValue(key, !$gameSelfSwitches.value(key));

      this._selfSwitchListWindow.refresh();
      this._selfSwitchListWindow.activate();
    };

    /**
     * セルフスイッチ選択のキャンセル
     */
    Scene_Debug.prototype.onSelfSwitchListCancel = function () {
      this._eventListWindow.activate();
    };

    /**
     * システム値コマンドの実行
     */
    Scene_Debug.prototype.onSelectSystemValue = function () {
      this.createSystemValueWindow();

      this._commandWindow.hide();
      this._systemValueWindow.show();
      this._systemValueWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.systemValue);
    };

    /**
     * システム値: 項目の決定
     */
    Scene_Debug.prototype.onSystemValueOk = function () {
      var key = this._systemValueWindow.getKey();
      var value = this._systemValueWindow.item();
      if (key == null || value == null) {
        return;
      }

      var caption = TextManager.DebugUtil[key];
      var number = value.get();
      var digits = Params.variableInputDigits;

      this._numberWindow.setCaption(caption);
      this._numberWindow.setAllowNegative(false);
      this._numberWindow.setHandler(
        "cancel",
        this.onSystemValueInputCancel.bind(this)
      );
      this._numberWindow.start(
        number,
        digits,
        this.onSystemValueInputOk.bind(this)
      );
    };

    /**
     * システム値: 項目選択のキャンセル
     */
    Scene_Debug.prototype.onSystemValueCancel = function () {
      this._systemValueWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * システム値: 入力の決定
     */
    Scene_Debug.prototype.onSystemValueInputOk = function (number) {
      var value = this._systemValueWindow.item();
      if (value != null) {
        value.set(number);
      }

      this._systemValueWindow.refresh();
      this.onSystemValueInputCancel();
    };

    /**
     * システム値: 入力のキャンセル処理
     */
    Scene_Debug.prototype.onSystemValueInputCancel = function () {
      this._numberWindow.close();
      this._systemValueWindow.refresh();
      this._systemValueWindow.activate();
    };

    /**
     * ウォッチウィンドウコマンドの実行
     */
    Scene_Debug.prototype.onWatchWindow = function () {
      this.createWatchWindow();
      this.createWatchListWindow();
      this.createWatchEditWindow();

      // _watchWindow は自動で表示状態が変わるので何もしない
      this._commandWindow.hide();
      this._watchListWindow.show();
      this._watchListWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.watchWindow);
    };

    /**
     * ウォッチ: 項目の決定
     */
    Scene_Debug.prototype.onWatchListOk = function () {
      this._watchEditWindow.setItem(this._watchListWindow.item());
      this._watchEditWindow.open();
      this._watchEditWindow.activate();
    };

    /**
     * ウォッチ: 項目選択のキャンセル
     */
    Scene_Debug.prototype.onWatchListCancel = function () {
      // update で自動表示されてしまうので消去ついでに削除
      this.destroyWatchWindow();

      this._watchListWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * ウォッチ: 項目編集の決定
     */
    Scene_Debug.prototype.onWatchEditOk = function () {
      var selectedItem = this._watchListWindow.item();

      switch (this._watchEditWindow.getMode()) {
        case "target":
          {
            // ウォッチ対象を選択
            this.onWatchSelectSwitchVarStart();
          }
          return;

        case "ok":
          {
            var editItem = this._watchEditWindow.item();
            if (selectedItem instanceof DebugWatchItem) {
              // 編集 (選択項目を差し替える)
              $gameTemp.replaceDebugWatchItem(
                editItem,
                this._watchListWindow.index()
              );
            } else {
              // 追加
              $gameTemp.registerDebugWatchItem(editItem);
            }
            this._watchListWindow.refresh();
          }
          break;

        case "remove":
          {
            // 選択項目を削除
            //  * 末尾の「追加」コマンドは消せないので、index の修正は不要
            $gameTemp.removeDebugWatchItem(selectedItem);
            this._watchListWindow.refresh();
          }
          break;

        default:
          // 何もしない (キャンセル扱い)
          break;
      }

      this._watchEditWindow.close();
      this._watchListWindow.activate();
    };

    /**
     * ウォッチ: スイッチ・変数選択の開始
     */
    Scene_Debug.prototype.onWatchSelectSwitchVarStart = function () {
      // ハンドラの切り替え
      this._rangeWindow.setHandler(
        "cancel",
        this.onWatchSelectSwitchVarCancel.bind(this)
      );
      this._editWindow.setHandler(
        "ok",
        this.onWatchSelectSwitchVarOk.bind(this)
      );

      this.destroyWatchWindow();

      this._watchListWindow.hide();
      this._watchEditWindow.hide();
      this._rangeWindow.show();
      this._editWindow.show();
      this._rangeWindow.activate();
    };

    /**
     * ウォッチ: スイッチ・変数選択の決定
     */
    Scene_Debug.prototype.onWatchSelectSwitchVarOk = function () {
      var item = this._watchEditWindow.item();

      if (this._editWindow.getMode() === "switch") {
        // スイッチを選択
        item.setupSwitch(this._editWindow.currentId());
      } else {
        // 変数を選択
        item.setupVariable(this._editWindow.currentId());
      }

      this._watchEditWindow.refresh();

      // ウィンドウを閉じる処理はキャンセルと一緒
      this.onWatchSelectSwitchVarCancel();
    };

    /**
     * ウォッチ: スイッチ・変数選択のキャンセル処理
     */
    Scene_Debug.prototype.onWatchSelectSwitchVarCancel = function () {
      this.createWatchWindow();

      this._rangeWindow.hide();
      this._editWindow.hide();
      this._watchListWindow.show();
      this._watchEditWindow.show();
      this._watchEditWindow.activate();
    };

    /**
     * ウォッチ: 項目編集のキャンセル
     */
    Scene_Debug.prototype.onWatchEditCancel = function () {
      this._watchEditWindow.close();
      this._watchListWindow.activate();
    };

    /**
     * エンカウントコマンドの実行
     */
    Scene_Debug.prototype.onForceEncounter = function () {
      this.createTroopWindow();

      this._commandWindow.hide();
      this._troopWindow.show();
      this._troopWindow.activate();
      this._titleWindow.setText(TextManager.DebugUtil.encounter);
    };

    /**
     * 敵グループの決定
     */
    Scene_Debug.prototype.onTroopOk = function () {
      var troop = this._troopWindow.item();
      if (!troop) {
        // null の場合は現在のマップからランダム選定
        var troopId = $gamePlayer.makeEncounterTroopId();
        troop = $dataTroops[troopId];
        if (!troop) {
          // マップに敵がいなければ何もしない
          this._troopWindow.activate();
          return;
        }
      }

      // エンカウント実行 (逃走、敗北可)
      BattleManager.setup(troop.id, true, true);
      SceneManager.push(Scene_Battle);
    };

    /**
     * 敵グループ選択のキャンセル処理
     */
    Scene_Debug.prototype.onTroopCancel = function () {
      this._troopWindow.hide();
      this.activateCommandWindow();
    };

    /**
     * 通行可否表示コマンドの実行
     */
    Scene_Debug.prototype.onDispPassage = function () {
      // TODO: 実装
      this._titleWindow.setText(TextManager.DebugUtil.dispPassage);
    };
  })();
} // <-- if (Utils.isOptionValid('test'))