code:
//=============================================================================
// Battle_Command_Extend.js
//=============================================================================

/*:
 * @plugindesc パーティーコマンドの非表示やアクターコマンドを編集できます。
 * @author 村人C
 *
 * @help
 *
 * 使い方
 * プラグインコマンド：
 * Battle_Command_Extend 変更する箇所 フラグ
 *
 * 変更する箇所のパラメータ
 * Party   Attack   Skill   Guard    Item
 * Auto    Repeat   Escape
 *
 * フラグ
 * 有効： on
 * 無効： off
 *
 * 例： Battle_Command_Extend Skill on
 * スキルを非表示にします。
 *
 * プラグインパラメータ：
 * 有効： on
 * 無効： off
 *
 * コマンドの並び順
 * 先頭のものほど上に表示されます。
 * 攻撃：  attack   スキル： skill   防御： guard    アイテム： item
 * 逃げる： escape   オート： auto    リピート： repeat
 *
 * オート
 * １ターンのみ個別に自動戦闘にします。
 *
 * リピート
 * 前のターンと同じ行動を取ります。
 *
 * Command_Flag
 * コマンドウインドウを自動でサイズ調整します。
 *
 * PT_Flag
 * パーティーコマンド非表示
 * on の場合、「逃げる」をアクターコマンドに追加します。
 *
 * Attack_Flag
 * 「攻撃」を非表示
 *
 * Skill_Flag
 * 「スキル」を非表示
 *
 * Guard_Flag
 * 「防御」を非表示
 *
 * Item_Flag
 * 「アイテム」を非表示
 *
 * Auto_Flag
 * 「オート」を非表示
 *
 * Repeat_Flag
 * 「リピート」を非表示
 *
 * Escape_Flag
 * 「逃げる」を非表示
 *
 *
 * 仕様
 * プラグインコマンドの大文字、小文字を間違えると正しく動作しません。
 * 「スキル」が非表示の場合に「オート」を選ぶと「通常攻撃」が選択されます。
 * パーティーコマンド時の「オート」は全アクターに適用されます。
 * 戦闘開始時に「リピート」を選択した場合、全アクターの行動が通常攻撃になります。
 * 「リピート」の判定はターン開始時です。ターン開始後、使用不可になった場合は行動しません。
 * ターン開始時に前のターンと同じ行動がコスト不足等で実行できない場合は通常攻撃になります。
 *
 * readmeやスタッフロールの明記、使用報告は任意
 *
 *
 * @param Auto
 * @desc 「オート」
 * デフォルト: オート
 * @default オート
 *
 * @param Repeat
 * @desc 「リピート」
 * デフォルト: リピート
 * @default リピート
 *
 * @param Command
 * @desc コマンドの並び
 * デフォルト: attack skill guard item auto repeat escape
 * @default attack skill guard item auto repeat escape
 *
 * @param Command_Flag
 * @desc コマンドのサイズを自動変更
 * デフォルト: on
 * @default on
 *
 * @param PT_Flag
 * @desc パーティーコマンド非表示
 * デフォルト: on
 * @default on
 *
 * @param Attack_Flag
 * @desc 「攻撃」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Skill_Flag
 * @desc 「スキル」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Guard_Flag
 * @desc 「防御」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Item_Flag
 * @desc 「アイテム」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Auto_Flag
 * @desc 「オート」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Repeat_Flag
 * @desc 「リピート」を非表示
 * デフォルト: off
 * @default off
 *
 * @param Escape_Flag
 * @desc 「逃げる」を非表示
 * デフォルト: off
 * @default off
 *
 */

var Battle_Command_Extend = Battle_Command_Extend || {};
Battle_Command_Extend.Flag = []; // 格納用に配列の作成
Battle_Command_Extend.Parameters = PluginManager.parameters('Battle_Command_Extend');
// 初期設定
Battle_Command_Extend.Command = Battle_Command_Extend.Parameters["Command"] || "attack skill guard item escape";
Battle_Command_Extend.Flag[0] = Battle_Command_Extend.Parameters["PT_Flag"] || "on";
Battle_Command_Extend.Flag[1] = Battle_Command_Extend.Parameters["Attack_Flag"] || "off";
Battle_Command_Extend.Flag[2] = Battle_Command_Extend.Parameters["Skill_Flag"] || "off";
Battle_Command_Extend.Flag[3] = Battle_Command_Extend.Parameters["Guard_Flag"] || "off";
Battle_Command_Extend.Flag[4] = Battle_Command_Extend.Parameters["Item_Flag"] || "off";
Battle_Command_Extend.Flag[5] = Battle_Command_Extend.Parameters["Command_Flag"] || "on";
Battle_Command_Extend.Flag[6] = Battle_Command_Extend.Parameters["Auto_Flag"] || "off";
Battle_Command_Extend.Flag[7] = Battle_Command_Extend.Parameters["Repeat_Flag"] || "off";
Battle_Command_Extend.Flag[8] = Battle_Command_Extend.Parameters["Auto"] || "オート";
Battle_Command_Extend.Flag[9] = Battle_Command_Extend.Parameters["Repeat"] || "リピート";
Battle_Command_Extend.Flag[10] = Battle_Command_Extend.Parameters["Escape_Flag"] || "off";

(function () {
	// プラグインコマンド
	var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
	Game_Interpreter.prototype.pluginCommand = function (command, args) {
		_Game_Interpreter_pluginCommand.call(this, command, args);
		switch (command) {
			case 'Battle_Command_Extend':
				var id
				switch (args[0]) {
					case 'Party':
						id = 0;
						break;
					case 'Attack':
						id = 1;
						break;
					case 'Skill':
						id = 2;
						break;
					case 'Guard':
						id = 3;
						break;
					case 'Item':
						id = 4;
						break;
					case 'Auto':
						id = 6;
						break;
					case 'Repeat':
						id = 7;
						break;
					case 'Escape':
						id = 10;
						break;
				}
				$gameSystem._battle_command_flag[id] = args[1];
				break;

		}
	};
	// 「リピート」の一時保存
	var _Game_Temp_initialize_Battle_Command_Extend = Game_Temp.prototype.initialize;
	Game_Temp.prototype.initialize = function () {
		_Game_Temp_initialize_Battle_Command_Extend.call(this);
		this._repeat_action = [];
	};
	// 「リピート」の初期化
	Game_Temp.prototype.clear_repeat_action = function () {
		this._repeat_action = [];
	};
	// 設定保存用
	var _Game_System_initialize_Battle_Command_Extend = Game_System.prototype.initialize;
	Game_System.prototype.initialize = function () {
		_Game_System_initialize_Battle_Command_Extend.call(this);
		this._battle_command_flag = []; // 初期化
		this._battle_command_flag[0] = Battle_Command_Extend.Flag[0]; // PT
		this._battle_command_flag[1] = Battle_Command_Extend.Flag[1]; // 攻撃
		this._battle_command_flag[2] = Battle_Command_Extend.Flag[2]; // スキル
		this._battle_command_flag[3] = Battle_Command_Extend.Flag[3]; // 防御
		this._battle_command_flag[4] = Battle_Command_Extend.Flag[4]; // アイテム
		this._battle_command_flag[6] = Battle_Command_Extend.Flag[6]; // オート
		this._battle_command_flag[7] = Battle_Command_Extend.Flag[7]; // リピート
		this._battle_command_flag[10] = Battle_Command_Extend.Flag[10]; // 逃げる
	};
	// 戦闘開始
	var BattleManager_startBattle_Battle_Command_Extend = BattleManager.startBattle;
	BattleManager.startBattle = function () {
		$gameTemp.clear_repeat_action();
		BattleManager_startBattle_Battle_Command_Extend.call(this);
	};
	// ターン開始
	var BattleManager_startTurn_Battle_Command_Extend = BattleManager.startTurn;
	BattleManager.startTurn = function () {
		BattleManager.repeatSave();
		BattleManager_startTurn_Battle_Command_Extend.call(this);
	};
	// リピート行動の作成
	BattleManager.repeatActor = function () {
		for (var i = 0; i < $gameParty.size(); i++) {
			var actor = $gameParty.members()[i];
			var action = new Game_Action(actor);
			if (actor.canInput()) { // 行動可能な場合
				actor.makeActions(); // 現在の行動を削除と行動回数の適用
				if ($gameTemp._repeat_action[i] === undefined) { // 一時保存がなければ
					$gameTemp._repeat_action[i] = [];
					for (var n = 0; n < actor.numActions(); n++) { // 行動回数
						$gameTemp._repeat_action[i][n] = action;
						$gameTemp._repeat_action[i][n].setSkill(actor.attackSkillId()); // 通常攻撃
						$gameTemp._repeat_action[i][n].setTarget(-1); // ターゲットは初期値
					}
				}
				for (var n = 0; n < actor.numActions(); n++) { // 行動回数
					var ac = $gameTemp._repeat_action[i][n];
					actor.setAction(n, ac);
				}
			}
		}
	};
	// リピート行動の保存
	BattleManager.repeatSave = function () {
		for (var i = 0; i < $gameParty.size(); i++) {
			var actor = $gameParty.members()[i];
			if (actor.canInput()) { // 行動可能な場合
				$gameTemp._repeat_action[i] = []; // 保存準備
				for (var n = 0; n < actor.numActions(); n++) { // 行動回数
					if (actor.action(n).isValid()) { // 使用可能？
						$gameTemp._repeat_action[i][n] = actor.action(n); // 保存
					} else { // 使用不可
						actor.action(n).setSkill(actor.attackSkillId())// 通常攻撃に変更
						$gameTemp._repeat_action[i][n] = actor.action(n);
					}
				}
			}
		}
	};
	// 自動戦闘用の行動候補リストを作成
	var _Game_Actor_makeActionList_Battle_Command_Extend = Game_Actor.prototype.makeActionList;
	Game_Actor.prototype.makeActionList = function () {
		if ($gameSystem._battle_command_flag[2] === "on") { // スキルが非表示ならスキルを使用しない
			var list = [];
			var action = new Game_Action(this);
			action.setAttack(); // 通常攻撃
			list.push(action);
			return list;
		} else {
			return _Game_Actor_makeActionList_Battle_Command_Extend.call(this);
		}
	};
	// SV アクターコマンド時「逃げる」動作改善
	var _Sprite_Actor_updateTargetPosition_Battle_Command_Extend = Sprite_Actor.prototype.updateTargetPosition;
	Sprite_Actor.prototype.updateTargetPosition = function () {
		if ($gameSystem._battle_command_flag[0] === "on") {
			if (this._actor.canMove() && BattleManager.isEscaped()) {
				this.retreat();
			} else if (this._actor.isInputting() || this._actor.isActing()) {
				this.stepForward();
			} else if (!this.inHomePosition()) {
				this.stepBack();
			}
		} else {
			return _Sprite_Actor_updateTargetPosition_Battle_Command_Extend.call(this);
		}
	};
	// 表示行数の取得
	var _Window_ActorCommand_numVisibleRows_Battle_Command_Extend = Window_ActorCommand.prototype.numVisibleRows;
	Window_ActorCommand.prototype.numVisibleRows = function () {
		if (Battle_Command_Extend.Flag[5] === "on") {
			var num = this._list ? this._list.length : 4;
			return num;
		} else {
			return _Window_ActorCommand_numVisibleRows_Battle_Command_Extend.call(this);
		}
	};
	// コマンドリストのリフレッシュ
	var _Window_ActorCommand_refresh_Battle_Command_Extend = Window_ActorCommand.prototype.refresh;
	Window_ActorCommand.prototype.refresh = function () {
		if (Battle_Command_Extend.Flag[5] === "on") {
			var wh = this.fittingHeight(this.numVisibleRows());
			var wy = Math.min(Graphics.boxHeight - wh, this.fittingHeight(this.numVisibleRows()));
			this.move(this.x, Graphics.boxHeight - wh, this.windowWidth(), wh);
		}
		_Window_ActorCommand_refresh_Battle_Command_Extend.call(this);
	};
	// コマンドの削除
	Window_ActorCommand.prototype.delCommandList = function (flag) {
		if (flag === true || $gameSystem._battle_command_flag[1] === "on") { // 攻撃
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'attack';
			}.bind(this));
		}
		if (flag === true || $gameSystem._battle_command_flag[2] === "on") { // スキル
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'skill';
			}.bind(this));
		}
		if (flag === true || $gameSystem._battle_command_flag[3] === "on") { // 防御
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'guard';
			}.bind(this));
		}
		if (flag === true || $gameSystem._battle_command_flag[4] === "on") { // アイテム
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'item';
			}.bind(this));
		}
		if (flag === true || $gameSystem._battle_command_flag[10] === "on") { // 逃げる
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'escape';
			}.bind(this));
		}
	};
	// コマンドリストの作成
	var _Window_ActorCommand_makeCommandList_Battle_Command_Extend = Window_ActorCommand.prototype.makeCommandList;
	Window_ActorCommand.prototype.makeCommandList = function () {
		_Window_ActorCommand_makeCommandList_Battle_Command_Extend.call(this); // 元処理
		this.delCommandList(true); // コマンド削除
		if (this._actor) {
			var symbol = Battle_Command_Extend.Command.split(' ');
			for (var n = 0; n < symbol.length; n++) {
				switch (symbol[n]) {
					case 'attack': // 攻撃
						this.addAttackCommand();
						break;
					case 'skill': // スキル
						this.addSkillCommands();;
						break;
					case 'guard': // 防御
						this.addGuardCommand();;
						break;
					case 'item': // アイテム
						this.addItemCommand();;
						break;
					case 'escape': // 逃げる
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[10] === "off") {
							this.addCommand(TextManager.escape, 'escape', BattleManager.canEscape());
						}
						break;
					case 'auto': // オート
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[6] === "off") {
							this.addCommand(Battle_Command_Extend.Flag[8], 'auto');
						}
						break;
					case 'repeat': // リピート
						if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[7] === "off") {
							this.addCommand(Battle_Command_Extend.Flag[9], 'repeat');
						}
						break;
				}
			}
			this.delCommandList();
		}
	};
	// コマンドの削除
	Window_PartyCommand.prototype.delCommandList = function (flag) {
		if (flag === true || $gameSystem._battle_command_flag[10] === "on") { // 逃げる
			this._list = this._list.filter(function (obj) {
				return obj.symbol !== 'escape';
			}.bind(this));
		}
	};
	// コマンドリストの作成
	var _Window_PartyCommand_makeCommandList_Battle_Command_Extend = Window_PartyCommand.prototype.makeCommandList;
	Window_PartyCommand.prototype.makeCommandList = function () {
		_Window_PartyCommand_makeCommandList_Battle_Command_Extend.call(this);
		this.delCommandList(true);
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[6] === "off") {
			this.addCommand(Battle_Command_Extend.Flag[8], 'auto');
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[7] === "off") {
			this.addCommand(Battle_Command_Extend.Flag[9], 'repeat');
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[10] === "off") {
			this.addCommand(TextManager.escape, 'escape', BattleManager.canEscape());
		}
		this.delCommandList();
	};
	// パーティコマンド選択の開始
	var _Scene_Battle_changeInputWindow_Battle_Command_Extend = Scene_Battle.prototype.changeInputWindow;
	Scene_Battle.prototype.changeInputWindow = function () {
		if ($gameSystem._battle_command_flag[0] === "on") {
			if (BattleManager.isInputting()) {
				if (BattleManager.actor()) {
					this.startActorCommandSelection();
				} else {
					this._partyCommandWindow.deactivate;
					this.commandFight();
				}
			} else {
				this.endCommandSelection();
			}
		} else {
			return _Scene_Battle_changeInputWindow_Battle_Command_Extend.call(this);
		}
	};
	// パーティーコマンドウィンドウの作成
	var _Scene_Battle_createPartyCommandWindow_Battle_Command_Extend = Scene_Battle.prototype.createPartyCommandWindow;
	Scene_Battle.prototype.createPartyCommandWindow = function () {
		_Scene_Battle_createPartyCommandWindow_Battle_Command_Extend.call(this);
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[6] === "off") { // オート
			this._partyCommandWindow.setHandler('auto', this.commandAuto.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "off" && $gameSystem._battle_command_flag[7] === "off") { // リピート
			this._partyCommandWindow.setHandler('repeat', this.commandRepeat.bind(this));
		}
	};
	// アクターコマンドウィンドウの作成
	var _Scene_Battle_createActorCommandWindow_Battle_Command_Extend = Scene_Battle.prototype.createActorCommandWindow;
	Scene_Battle.prototype.createActorCommandWindow = function () {
		_Scene_Battle_createActorCommandWindow_Battle_Command_Extend.call(this);
		if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[6] === "off") { // オート
			this._actorCommandWindow.setHandler('auto', this.commandAuto.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "on" && $gameSystem._battle_command_flag[7] === "off") { // リピート
			this._actorCommandWindow.setHandler('repeat', this.commandRepeat.bind(this));
		}
		if ($gameSystem._battle_command_flag[0] === "on") { // 逃げる
			this._actorCommandWindow.setHandler('escape', this.commandEscape.bind(this));
		}
	};
	// コマンド［オート］
	Scene_Battle.prototype.commandAuto = function () {
		if ($gameSystem._battle_command_flag[0] === "on") { // アクターコマンドから
			BattleManager.actor().makeAutoBattleActions(); // オート
			this.selectNextCommand();
		} else { // パーティーコマンドから
			for (var i = 0; i < $gameParty.size(); i++) {
				var actor = $gameParty.members()[i];
				if (actor.canInput()) { // 行動可能な場合
					actor.makeAutoBattleActions(); // オート
				}
			}
			this.endCommandSelection(); // コマンド終了
			BattleManager.startTurn(); // ターン開始
		}
	}
	// コマンド［リピート］
	Scene_Battle.prototype.commandRepeat = function () {
		BattleManager.repeatActor(); // 行動の作成
		this.endCommandSelection(); // コマンド終了
		BattleManager.startTurn(); // ターン開始
	}
})();


code:
//=============================================================================
// BestFriend.js
//=============================================================================

/*:ja
 * @plugindesc ver1.01 隊員の未来に・・・笑顔を・・・
 * @author まっつＵＰ
 *
 * @param selectA
 * @desc このIDの変数を利用します。要ヘルプ参照。
 * @default 10
 *
 * @param selectB
 * @desc このIDの変数を利用します。要ヘルプ参照。
 * @default 11
 *
 * @param comtextA
 * @desc 表示するコマンド名1。
 * @default Swap
 *
 * @param comtextB
 * @desc 表示するコマンド名2。
 * @default Call
 *
 * @param comtextC
 * @desc 表示するコマンド名3。
 * @default Back
 *
 * @param comtextD
 * @desc 表示するコマンド名4。
 * @default Keep
 *
 * @help
 *
 * RPGで笑顔を・・・
 *
 * このヘルプとパラメータの説明をよくお読みになってからお使いください。
 *
 * 並び替えのためにメニューシーンに新たなウインドウおよびコマンドを加えます。
 *
 * このウインドウはメニューコマンドの「並び替え」を選択すると表示されます。
 * メニューコマンドの「並び替え」の表示条件は変更しておりません。
 *
 * このウインドウではパラメータや変数の状態によって以下のコマンドが表示・選択できます。
 * また、コマンドの名前はパラメータのcomtextA～Dで変更できます。
 *
 * Swap・・・本来メニューコマンドで選択できる隊員の並び替えです。
 * 表示・選択効果ともに基本的に常時有効。
 * Call・・・登録した隊員を呼び出します。
 * 「selectA」が0以外のときに表示、選択効果常時有効。
 * Back・・・変数の配列に従って隊員を呼び出します。
 * 「selectB」が0以外のときに表示、選択効果はこのIDの変数が0以外の時有効。
 * Keep・・・「selectA」のIDの変数に現在の隊員を登録します。
 * コマンド「Call」と同じ条件。
 *
 * パラメータ「selectA」「selectB」について
 * 「selectA」はプレイヤーが変更することのできる配列です。
 * 「selectB」はプレイヤーからは変更できない配列です。
 *
 * 「selectA」のIDの変数が0の時、このウインドウが開かれた時に
 * 仮登録としてコマンド「Keep」の処理を実行します。
 *
 * この二つのパラメータに要素数が1以下の配列が入っていると
 * 不自然な挙動を起こす可能性があるので注意してください。
 *
 * このプラグインを利用する場合は
 * readmeなどに「まっつＵＰ」の名を入れてください。
 * また、素材のみの販売はダメです。
 * 上記以外の規約等はございません。
 * もちろんツクールMVで使用する前提です。
 * 何か不具合ありましたら気軽にどうぞ。
 *
 * ver1.01 配列が書き換えられるのを阻止する処理を追加。
 *
 * 免責事項：
 * このプラグインを利用したことによるいかなる損害も制作者は一切の責任を負いません。
 *
 */

(function () {

    var parameters = PluginManager.parameters('BestFriend');
    var BFselectA = Number(parameters['selectA'] || 10);
    var BFselectB = Number(parameters['selectB'] || 11);
    var BFcomtextA = String(parameters['comtextA'] || 'Swap');
    var BFcomtextB = String(parameters['comtextB'] || 'Call');
    var BFcomtextC = String(parameters['comtextC'] || 'Back');
    var BFcomtextD = String(parameters['comtextD'] || 'Keep');

    //Scene
    var _Scene_Menu_create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function () {
        _Scene_Menu_create.call(this);
        this.createBestFriendWindow(); //新たに専用のウインドウを加える。(command)
    };

    Scene_Menu.prototype.createBestFriendWindow = function () { //新規
        var y = this._commandWindow.height; //メニューコマンドの下
        this._bestfriendWindow = new Window_BestFriend(0, y);
        this._bestfriendWindow.setHandler('formA', this.commandSwap.bind(this));
        this._bestfriendWindow.setHandler('formB', this.commandCall.bind(this));
        this._bestfriendWindow.setHandler('formC', this.commandBack.bind(this));
        this._bestfriendWindow.setHandler('formD', this.commandKeep.bind(this));
        this._bestfriendWindow.setHandler('cancel', this.onBestFriendcancel.bind(this));
        this.addWindow(this._bestfriendWindow);
    };

    Scene_Menu.prototype.commandFormation = function () { //大幅に改変
        this._commandWindow.deactivate();
        this.BestFriendfirst(); //仮登録
        this._bestfriendWindow.show();
        this._bestfriendWindow.activate();
        this._bestfriendWindow.select(0);
    };

    Scene_Menu.prototype.commandSwap = function () { //新規、commandFormationの処理
        this._statusWindow.setFormationMode(true);
        this._statusWindow.selectLast();
        this._statusWindow.activate();
        this._statusWindow.setHandler('ok', this.onFormationOk.bind(this));
        this._statusWindow.setHandler('cancel', this.onFormationCancel.bind(this));
    };

    Scene_Menu.prototype.commandCall = function () { //新規
        //console.log($gameParty._actors)
        //console.log($gameVariables.value(BFselectA))
        $gameParty._actors = $gameVariables.value(BFselectA);
        var cl = $gameParty._actors.clone();
        $gameVariables.setValue(BFselectA, cl); //動的にしないためにローカル変数を代入
        this.callandback();
    };

    Scene_Menu.prototype.commandBack = function () { //新規
        $gameParty._actors = $gameVariables.value(BFselectB);
        var cl = $gameParty._actors.clone();
        $gameVariables.setValue(BFselectB, cl); //動的にしないためにローカル変数を代入
        this.callandback();
    };

    Scene_Menu.prototype.commandKeep = function () { //新規
        //console.log($gameParty._actors)
        var cl = $gameParty._actors.clone();
        $gameVariables.setValue(BFselectA, cl); //動的にしないためにローカル変数を代入
        this._bestfriendWindow.activate();
    };

    Scene_Menu.prototype.BestFriendfirst = function () { //新規
        //初実行の際に必ず仮登録をする。
        if (BFselectA != 0 && $gameVariables.value(BFselectA) == 0) this.commandKeep();
    };

    Scene_Menu.prototype.callandback = function () { //新規
        $gamePlayer.refresh(); //隊員を変えたときの処理
        $gameMap.requestRefresh();
        this._statusWindow.refresh();
        this._bestfriendWindow.activate();
    };

    Scene_Menu.prototype.onFormationCancel = function () {
        if (this._statusWindow.pendingIndex() >= 0) {
            this._statusWindow.setPendingIndex(-1);
            this._statusWindow.activate();
        } else {
            this._statusWindow.deselect();
            this._bestfriendWindow.activate(); //追加
            //this._commandWindow.activate();
        }
    };

    Scene_Menu.prototype.onBestFriendcancel = function () { //新規
        this._bestfriendWindow.hide();
        this._bestfriendWindow.deactivate();
        this._commandWindow.activate();
    };

    //Window
    function Window_BestFriend() { //以下新規のウインドウとその処理
        this.initialize.apply(this, arguments);
    }

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

    Window_BestFriend.prototype.initialize = function (x, y) {
        Window_Command.prototype.initialize.call(this, x, y);
        this.hide();
    };

    Window_BestFriend.prototype.windowWidth = function () {
        return 240; //メニューコマンドと同様
    };

    Window_BestFriend.prototype.numVisibleRows = function () {
        return this.maxItems(); //表示しない分は列を詰める
    };

    Window_BestFriend.prototype.makeCommandList = function () {
        this.addformdefCommand();
        this.addfriendCommand();
        this.addselectfriendCommand();
        this.addbookkeepCommand();
    };

    Window_BestFriend.prototype.addformdefCommand = function () {
        var enabled = this.isformdefEnabled();
        this.addCommand(BFcomtextA, 'formA', enabled); //本来の並び替えの処理
    };

    Window_BestFriend.prototype.addfriendCommand = function () {
        if (BFselectA != 0) {
            var enabled = this.isfriendEnabled();
            this.addCommand(BFcomtextB, 'formB', enabled);
        }
    };

    Window_BestFriend.prototype.addselectfriendCommand = function () {
        if (BFselectB != 0) {
            var enabled = this.isselectfriendEnabled();
            this.addCommand(BFcomtextC, 'formC', enabled);
        }
    };

    Window_BestFriend.prototype.addbookkeepCommand = function () {
        if (BFselectA != 0) {
            var enabled = this.isfriendEnabled(); //条件はaddfriendCommandと同様
            this.addCommand(BFcomtextD, 'formD', enabled);
        }
    };

    Window_BestFriend.prototype.isformdefEnabled = function () {
        //この条件を設定しないとステータスウインドウが不自然なアクティブを起こすことがある。
        return $gameParty.size() >= 2 && $gameSystem.isFormationEnabled();
    };

    Window_BestFriend.prototype.isfriendEnabled = function () {
        return true;
    };

    Window_BestFriend.prototype.isselectfriendEnabled = function () {
        return $gameVariables.value(BFselectB) != 0;
    };

})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// CRTA_TimerManager.js
//=============================================================================

/*:
 * @plugindesc v1.1.0 タイマー関係の管理プラグイン
 * @author tokineco@cretia studio
 *
 * @param Font Size
 * @desc フォントサイズ
 * Default: 32
 * @default 32
 *
 * @param Width
 * @desc 横幅
 * Default: 96
 * @default 96
 *
 * @param Height
 * @desc 縦幅
 * Default: 48
 * @default 48
 *
 * @param Position X
 * @desc X位置
 * Default: Graphics.width - this.bitmap.width
 * @default Graphics.width - this.bitmap.width

 * @param Position Y
 * @desc Y位置
 * Default: 0
 * @default 0
 *
 * @help
 * 概要:
 * ツクール標準のカウントダウンタイマーの表示を変えたり、いろいろな操作を行うプラグインです。
 * 時間延長、減少、停止、再開が行えます。
 *
 * 詳細な使用方法は下記をご覧ください。
 * http://studio.cretia.net/blog/666
 *
 * プラグインコマンド:
 *   CRTA_TimerManager add 10       # タイマーを指定秒数増加させる
 *   CRTA_TimerManager sub 10       # タイマーを指定秒数減少させる
 *   CRTA_TimerManager pause        # タイマーを一時停止させる
 *   CRTA_TimerManager resume       # タイマーを再開させる
 *
 * ※このプラグインでは、以下を書き換えていますので、本体アップデートや競合に注意してください。
 *    Sprite_Timer.prototype.createBitmap
 *    Sprite_Timer.prototype.updatePosition
 *    Game_Timer.prototype.start
 *    Game_Timer.prototype.update
 *
 * ライセンス:
 * このプラグインは以下のライセンスのもと、使用することができます。
 *   Copyright (c) 2016 tokineco
 *   Released under the MIT license
 *   https://github.com/tokineco/RMMV_CRTAPlugins/blob/master/LICENSE
 */

(function () {

    var parameters = PluginManager.parameters('CRTA_TimerManager');
    var fontSize = Number(parameters['Font Size'] || 32);
    var width = Number(parameters['Width'] || 96);
    var height = Number(parameters['Height'] || 48);
    var posX = String(parameters['Position X']);
    var posY = String(parameters['Position Y']);

    var _timerPause = false;

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

            switch (args[0]) {
                case 'add':
                    $gameTimer.addFrames(eval(args[1]));
                    break;
                case 'sub':
                    $gameTimer.subFrames(eval(args[1]));
                    break;
                case 'pause':
                    $gameTimer.pause();
                    break;
                case 'resume':
                    $gameTimer.resume();
                    break;
            }
        }
    };

    var _Sprite_Timer_createBitmap = Sprite_Timer.prototype.createBitmap;
    Sprite_Timer.prototype.createBitmap = function () {
        _Sprite_Timer_createBitmap.call(this);

        this.bitmap.width = width;
        this.bitmap.height = height;
        this.bitmap.fontSize = fontSize;
    }

    var _Sprite_Timer_updatePosition = Sprite_Timer.prototype.updatePosition;
    Sprite_Timer.prototype.updatePosition = function () {
        _Sprite_Timer_updatePosition.call(this);

        this.x = eval(posX);
        this.y = eval(posY);
    };

    //=================================
    // Game_Timer (プラグインスクリプト用)
    //=================================
    // override
    var _Game_Timer_start = Game_Timer.prototype.start;
    Game_Timer.prototype.start = function (count) {
        _Game_Timer_start.call(this, count);
        _timerPause = false;
    };

    // override
    var _Game_Timer_update = Game_Timer.prototype.update;
    Game_Timer.prototype.update = function (sceneActive) {
        if (!_timerPause) {
            _Game_Timer_update.call(this, sceneActive);
        }
    };

    // Game_Timer に addFrames を追加
    Game_Timer.prototype.addFrames = function (second) {
        this._frames += second * 60;
    };

    // Game_Timer に subFrames を追加
    Game_Timer.prototype.subFrames = function (second) {
        this._frames -= second * 60;
        if (this._frames < 0) {
            this._frames = 0;
        }
    };

    // Game_Timer に pause を追加
    Game_Timer.prototype.pause = function () {
        _timerPause = true;
    };

    // Game_Timer に resume を追加
    Game_Timer.prototype.resume = function () {
        _timerPause = false;
    };

})();


code:
//=============================================================================
// ChangePlayerCharacter.js
//=============================================================================

/*:ja
 * @plugindesc プレイヤーキャラクターを指定したボタンで変更し、その際に指定したコモンイベントを入れます。
 * @author 村人A
 *
 * @param banSwitchId
 * @text 切り替え禁止スイッチID
 * @desc プレイヤーキャラクターの切り替えを許可・禁止するスイッチIDを指定します。
 * @default 6
 *
 * @param changeCommonId
 * @text 切り替え時コモンイベントID
 * @desc プレイヤーキャラクターの切り替えを許可・禁止するスイッチIDを指定します。
 * @default 3
 *
 */
{
	'use strict'

	const param = PluginManager.parameters('ChangePlayerCharacter');
	const banSwitchId = Number(param.banSwitchId);
	const changeCommonId = Number(param.changeCommonId);

	Game_Party.prototype.toggleSwapOrder = function () {
		let tempActorArr = [];
		for (let i = 1, n = this._actors.length; i < n; i++) {
			tempActorArr.push(this._actors[i])
		}
		tempActorArr.push(this._actors[0])
		this._actors = tempActorArr;
		$gamePlayer.refresh();
	};

	const _alias_Scene_Map_update = Scene_Map.prototype.update;
	Scene_Map.prototype.update = function () {
		_alias_Scene_Map_update.call(this)
		this.updateCheckChangePlayerCharacter();
	}

	Scene_Map.prototype.updateCheckChangePlayerCharacter = function () {
		if ($gameSwitches.value(banSwitchId) && Input.isTriggered('pageup')) {
			$gameTemp.reserveCommonEvent(changeCommonId)
			$gameParty.toggleSwapOrder();
		}
	}
}


code:
//=============================================================================
// ChangeWeaponOnBattle.js
//=============================================================================

/*:
 * @plugindesc make battle command that changes weapon.
 * @author Sasuke KANNAZUKI
 *
 * @param commandName
 * @desc command name that change equip
 * @default Equip
 *
 * @help This plugin does not provide plugin commands.
 *
 * - changable equips are only weapon(s) and shield.
 * - changing weapon doesn't consume turn.
 *
 */

/*:ja
 * @plugindesc 戦闘コマンドに装備変更を追加
 * @author 神無月サスケ
 *
 * @param commandName
 * @desc 装備変更のコマンド名です。
 * @default 装備変更
 *
 * @help このプラグインには、プラグインコマンドはありません。
 *
 * - 変更可能なのは武器と盾だけです。
 * - 装備変更はターンを消費しません。
 *
 */

(function () {

  var parameters = PluginManager.parameters('ChangeWeaponOnBattle');
  var commandName = parameters['commandName'] || 'Equip';

  //---------------------------------------------------------------------------
  // Tiny equip status
  // display only atk and def.
  //
  function Window_TinyEquipStatus() {
    this.initialize.apply(this, arguments);
  }

  Window_TinyEquipStatus.prototype =
    Object.create(Window_EquipStatus.prototype);
  Window_TinyEquipStatus.prototype.constructor = Window_TinyEquipStatus;

  Window_TinyEquipStatus.prototype.initialize = function (x, y) {
    Window_EquipStatus.prototype.initialize.call(this, x, y);
  };

  Window_TinyEquipStatus.prototype.numVisibleRows = function () {
    return 2;
  };

  Window_TinyEquipStatus.prototype.refresh = function () {
    this.contents.clear();
    if (this._actor) {
      for (var i = 0; i < 2; i++) {
        this.drawItem(0, this.lineHeight() * i, 2 + i);
      }
    }
  };

  //---------------------------------------------------------------------------
  // Tiny equip slot
  // display only a weapon, and a shield or another weapon.
  //
  function Window_TinyEquipSlot() {
    this.initialize.apply(this, arguments);
  }

  Window_TinyEquipSlot.prototype = Object.create(Window_EquipSlot.prototype);
  Window_TinyEquipSlot.prototype.constructor = Window_TinyEquipSlot;

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

  Window_TinyEquipSlot.prototype.maxItems = function () {
    return this._actor ? 2 : 0;
  };

  Window_TinyEquipSlot.prototype.show = function () {
    Window_EquipSlot.prototype.show.call(this);
    this.showHelpWindow();
  };

  Window_TinyEquipSlot.prototype.hide = function () {
    Window_EquipSlot.prototype.hide.call(this);
    this.hideHelpWindow();
  };

  //---------------------------------------------------------------------------

  //
  // add equipment windows for check active.
  //
  var _Scene_Battle_isAnyInputWindowActive =
    Scene_Battle.prototype.isAnyInputWindowActive;
  Scene_Battle.prototype.isAnyInputWindowActive = function () {
    if (_Scene_Battle_isAnyInputWindowActive.call(this)) {
      return true;
    }
    return (this._equipSlotWindow.active || this._equipItemWindow.active);
  };

  //
  // creat new windows for equip weapon(s) on battle
  //
  var _Scene_Battle_createAllWindows = Scene_Battle.prototype.createAllWindows;
  Scene_Battle.prototype.createAllWindows = function () {
    _Scene_Battle_createAllWindows.call(this);
    this.createEquipStatusWindow();
    this.createEquipSlotWindow();
    this.createEquipItemWindow();
  };

  Scene_Battle.prototype.createEquipStatusWindow = function () {
    this._equipStatusWindow =
      new Window_TinyEquipStatus(0, this._helpWindow.height);
    this._equipStatusWindow.hide();
    this.addWindow(this._equipStatusWindow);
  };

  Scene_Battle.prototype.createEquipSlotWindow = function () {
    var wx = this._equipStatusWindow.width;
    var wy = this._helpWindow.height;
    var ww = Graphics.boxWidth - this._equipStatusWindow.width;
    var wh = this._equipStatusWindow.height;
    this._equipSlotWindow = new Window_TinyEquipSlot(wx, wy, ww, wh);
    this._equipSlotWindow.setHelpWindow(this._helpWindow);
    this._equipSlotWindow.setStatusWindow(this._equipStatusWindow);
    this._equipSlotWindow.setHandler('ok', this.onEquipSlotOk.bind(this));
    this._equipSlotWindow.setHandler('cancel',
      this.onEquipSlotCancel.bind(this));
    this._equipSlotWindow.hide();
    this.addWindow(this._equipSlotWindow);
  };

  Scene_Battle.prototype.createEquipItemWindow = function () {
    var wx = 0;
    var wy = this._equipStatusWindow.y + this._equipStatusWindow.height;
    var ww = Graphics.boxWidth;
    var wh = Graphics.boxHeight - wy - this._statusWindow.height;
    this._equipItemWindow = new Window_EquipItem(wx, wy, ww, wh);
    this._equipItemWindow.setHelpWindow(this._helpWindow);
    this._equipItemWindow.setStatusWindow(this._equipStatusWindow);
    this._equipItemWindow.setHandler('ok', this.onEquipItemOk.bind(this));
    this._equipItemWindow.setHandler('cancel',
      this.onEquipItemCancel.bind(this));
    this._equipSlotWindow.setItemWindow(this._equipItemWindow);
    this._equipItemWindow.hide();
    this.addWindow(this._equipItemWindow);
  };

  //
  // add command to actor command window
  //
  var _Scene_Battle_createActorCommandWindow =
    Scene_Battle.prototype.createActorCommandWindow;
  Scene_Battle.prototype.createActorCommandWindow = function () {
    _Scene_Battle_createActorCommandWindow.call(this);
    this._actorCommandWindow.setHandler('equip', this.commandEquip.bind(this));
  };

  var _Window_ActorCommand_makeCommandList =
    Window_ActorCommand.prototype.makeCommandList;
  Window_ActorCommand.prototype.makeCommandList = function () {
    _Window_ActorCommand_makeCommandList.call(this);
    if (this._actor) {
      this.addEquipCommand();
    }
  };

  Window_ActorCommand.prototype.addEquipCommand = function () {
    this.addCommand(commandName, 'equip');
  };

  //
  // process handlers
  //
  Scene_Battle.prototype.refreshActor = function () {
    var actor = BattleManager.actor();
    this._equipStatusWindow.setActor(actor);
    this._equipSlotWindow.setActor(actor);
    this._equipItemWindow.setActor(actor);
  };

  Scene_Battle.prototype.commandEquip = function () {
    this.refreshActor();
    this._equipStatusWindow.show();
    this._equipItemWindow.refresh();
    this._equipItemWindow.show();
    this._equipSlotWindow.refresh();
    this._equipSlotWindow.show();
    this._equipSlotWindow.activate();
    this._equipSlotWindow.select(0);
  };

  Scene_Battle.prototype.onEquipSlotOk = function () {
    this._equipItemWindow.activate();
    this._equipItemWindow.select(0);
  };

  Scene_Battle.prototype.onEquipSlotCancel = function () {
    this._equipStatusWindow.hide();
    this._equipItemWindow.hide();
    this._equipSlotWindow.hide();
    this._actorCommandWindow.activate();
    this._actorCommandWindow.select(0);
  };

  Scene_Battle.prototype.onEquipItemOk = function () {
    SoundManager.playEquip();
    BattleManager.actor().changeEquip(this._equipSlotWindow.index(),
      this._equipItemWindow.item());
    this._equipSlotWindow.activate();
    this._equipSlotWindow.refresh();
    this._equipItemWindow.deselect();
    this._equipItemWindow.refresh();
    this._equipStatusWindow.refresh();
  };

  Scene_Battle.prototype.onEquipItemCancel = function () {
    this._equipSlotWindow.activate();
    this._equipItemWindow.deselect();
  };

})();


code:
//=============================================================================
// CharacterGraphicExtend.js
// ----------------------------------------------------------------------------
// (C) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.15.0 2022/10/25 いくつかの表示拡張スクリプトをプレイヤーに実行すると連動してフォロワーにも適用される機能を追加
// 1.14.0 2021/02/22 色調変更でグレースケールを扱えるよう機能を追加
// 1.13.1 2021/08/19 ParallaxLayerMap.jsと併用したとき、先方のプラグインで指定した合成方法が無効になる競合を修正
// 1.13.0 2021/07/12 敵キャラやピクチャを表示する際、色相を指定できる機能を追加
// 1.12.0 2021/05/18 プライオリティ設定に「-1」(下層タイルの背後で遠景の手前)を設定できるようにしました
// 1.11.2 2021/05/05 アイコンセットの行を変更したときに正しくトリミングできない問題を修正
// 1.11.1 2021/05/01 ヘルプの記述を修正
// 1.11.0 2020/11/22 ApngPicture.jsと組み合わせてキャラクターとして表示したピクチャ、敵キャラ画像がアニメーションする機能を追加
// 1.10.4 2020/03/22 MOG_ChronoEngine.jsとの間で発生するエラーを解消(全面的な競合対策ではありません)
//                   MOG_CharPoses.jsとの競合を解消
// 1.10.3 2020/01/25 フレーム更新時に無駄な処理が実行されることでパフォーマンスが低下していた問題を修正
// 1.10.2 2018/11/19 UltraMode7との競合を解消(by けんせい様)
//                   TMNamePop.jsとの併用時、ネームポップがイベント画像の傾き、反転に影響されないよう修正
// 1.10.1 2018/10/05 敵キャラやピクチャを表示する際、エディタで元画像にインデックス1以外を指定していると画像が表示されない問題を修正
// 1.10.0 2018/09/25 イベント画像をトリミングして表示できる機能を追加
// 1.9.2 2018/07/11 EventEffects.jsとの競合を解消
// 1.9.1 2018/06/05 メモ欄タグで変数指定＋並列処理で変数操作にて発生するいくつかの問題を修正（by 奏ねこま様）
// 1.9.0 2018/02/20 不透明度をメモ欄で設定できる機能を追加
// 1.8.0 2017/08/27 マップで使用しているタイルセット以外のタイルセットを使ったイベントを作成できる機能を追加
// 1.7.0 2017/08/24 画像を別のものに変更するスクリプトを追加
// 1.6.1 2017/08/06 ヘルプを修正
// 1.6.0 2017/08/05 アクターのバトラー画像をマップ上に表示する機能を追加
// 1.5.3 2017/06/22 プラグインを適用していないデータをロードしたときにプレイヤーが表示されない問題を修正
// 1.5.2 2017/06/11 プライオリティの設定を0にすると設定が有効にならない問題を修正
// 1.5.1 2017/06/11 GALV_CamControl.jsとの競合を解消
// 1.5.0 2017/03/28 色調変更機能を追加
// 1.4.2 2017/02/03 メモ欄に制御文字\v[n]を使った場合に、一度マップ移動しないと反映されない問題を修正しました。
// 1.4.1 2016/11/27 T_dashMotion.jsとの競合を解決
// 1.4.0 2016/11/21 複数のページに対して別々の画像を割り当てる機能を追加しました。
// 1.3.0 2016/07/16 以下の機能を追加しました。
//                  遠景をイベントグラフィックとして利用可能
//                  イベント画像の原点を変更する機能、イベント画像の画面表示位置を絶対値指定する機能
// 1.2.1 2016/05/08 HalfMove.jsとの競合を解消
// 1.2.0 2016/03/19 戦闘発生時にイベントを消去しない設定を追加しました。
// 1.1.2 2016/03/04 本体バージョン1.1.0に合わせてキャラクターの乗算とスクリーンに対応しました。
// 1.1.1 2016/01/21 競合対策（YEP_MessageCore.js）
// 1.1.0 2016/01/11 キャラクターに回転角を設定する機能を追加
//                  移動ルートの指定のスクリプトから、回転角、拡大率、位置調整ができる機能を追加
// 1.0.0 2016/01/08 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc キャラクターグラフィック表示拡張プラグイン
 * @author トリアコンタン
 *
 * @param イベント消去無効
 * @desc エンカウント発生時にイベントを一瞬消去するエフェクトを無効にします。
 * @default false
 * @type boolean
 *
 * @param フォロワー連動
 * @desc プレイヤーに対して表示拡張スクリプトを実行するとフォロワーにも適用されます。
 * @default false
 * @type boolean
 *
 * @help イベントのグラフィック表示方法を拡張して多彩な表現を可能にします。
 * イベントのメモ欄に所定の書式で記入してください。
 * 項目はカンマで区切ってください。引数には文章の表示と同じ制御文字が使用できます。
 * また、ページ数に「A」と入力すると全てのページが対象になります。
 *
 * <CGピクチャ:（ページ数）,（ファイル名）>
 * 指定したページが有効になった場合のグラフィックをピクチャ画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGピクチャ:1,Test> or <CGPicture:1,Test>
 *
 * 〇追加機能
 * 複数のページに対して別々の画像を割り当てたい場合は
 * ページごとにタグを作成してください。
 * 以下の例だと1ページ目ではaaa.pngが、2ページ目ではbbb.pngが使用されます。
 * 他のタグも同様です。
 * 例：<CGピクチャ:1,aaa><CGピクチャ:2,bbb>
 *
 * <CG敵キャラ:（ページ数）,（ファイル名）,（色相）>
 * 指定したページが有効になった場合のグラフィックを敵キャラ画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CG敵キャラ:1,Bat,90> or <CGEnemy:1,Bat,90>
 *
 * <CGアイコン:（ページ数）,（インデックス）>
 * 指定したページが有効になった場合のグラフィックをアイコン画像から取得します。
 * 歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGアイコン:1,128> or <CGIcon:1,128>
 *
 * <CGフェイス:（ページ数）,（ファイル名）,（インデックス）>
 * 指定したページが有効になった場合のグラフィックをフェイス画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGフェイス:1,Actor1,4> or <CGFace:1,Actor1,4>
 *
 * <CGアクター:（ページ数）,（ファイル名）,（インデックス）>
 * 指定したページが有効になった場合のグラフィックをバトラー画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CGアクター:1, Actor1_1, 0> or <CGActor:1, Actor1_1, 0>
 *
 * <CG遠景:（ページ数）,（ファイル名）>
 * 指定したページが有効になった場合のグラフィックを遠景画像から取得します。
 * 拡張子は不要です。歩行アニメ待機アニメは無効化されます。
 *
 * 例：<CG遠景:1,Test> or <CGParallaxes:1,Test>
 *
 * 要注意！　これらのメモ欄でファイルを指定した場合、デプロイメント時に
 * 未使用ファイルとして除外される可能性があります。
 * その場合、削除されたファイルを入れ直す等の対応が必要です。
 *
 * <CGタイル:（ページ数）,（横幅）,（高さ）>
 * 指定したページが有効になった場合のグラフィックをタイルマップ画像から取得します。
 * 横幅と高さを指定して本棚やベッドが一つのイベントで表現できます。
 * イベントの画像選択から一番左上のタイルを選択してください。
 *
 * 例：<CGタイル:1,2,2> or <CGTile:1,2,2>
 *
 * <CGタイルセット:（ページ数）,（タイルセットID）>
 * 指定したページが有効になった場合のタイルセットを指定します。
 * マップで使用しているタイルセット以外のタイルセット画像が使えます。
 *
 * 例：<CGタイルセット:1,2> or <CGTileset:1,2>
 *
 * <CGシフト:（ページ数）,（X座標）,（Y座標）>
 * 指定したページが有効になった場合のグラフィック表示位置を
 * 指定したピクセル分ずらして表示します。
 *
 * 例：<CGシフト:1,16,-16> or <CGShift:1,16,-16>
 *
 * <CGプライオリティ:（ページ数）,（プライオリティ）>
 * 指定したページが有効になった場合の表示優先度を設定します。
 * 1～9までの値を設定できます。
 *
 * 例：<CGプライオリティ:1,6> or <CGPriority:1,6>
 *
 * ※それぞれのプライオリティの値
 * 0 : 下層タイル
 * 1 : 通常キャラの下
 * 3 : 通常キャラと同じ
 * 4 : 上層タイル
 * 5 : 通常キャラの上
 * 6 : 飛行船の影
 * 7 : フキダシ
 * 8 : アニメーション
 * 9 : マップタッチの行き先（白く光るヤツ）
 *
 * <CG合成方法:（ページ数）,（合成方法）>
 * 指定したページが有効になった場合のグラフィックの合成方法を設定します。
 * 0:通常 1:加算 2:乗算 3:スクリーン
 *
 * 例：<CG合成方法:1,2> or <CGBlendType:1,2>
 *
 * <CG拡大率:（ページ数）,（X拡大率）（Y拡大率）>
 * 指定したページが有効になった場合のグラフィックの拡大率を設定します。
 * 負の値を設定すると画像が反転します。
 *
 * 例：<CG拡大率:1,100,-100> or <CGScale:1,100,-100>
 *
 * <CG回転角:（ページ数）,（回転角）>
 * 指定したページが有効になった場合のグラフィックの回転角を設定します。
 * 回転の中心は、キャラクターの足下になります。0～360の範囲内で設定してください。
 *
 * 例：<CG回転角:1,180> or <CGAngle:1,180>
 *
 * <CG原点:（ページ数）,（X原点）,（Y原点）>
 * 指定したページが有効になった場合のグラフィックの原点(0...100)を設定します。
 * デフォルトではX原点が50、Y原点が100(画像の足下が原点になる)です。
 * 原点を[0, 0]にした場合、画像左上の座標がタイルの中央と一致します。
 *
 * 例：<CG原点:1,0,0> or <CGOrigin:1,100,100>
 *
 * <CG絶対座標:（ページ数）,（X座標）,（Y座標）>
 * 指定したページが有効になった場合のグラフィック表示位置を
 * 絶対座標(ピクチャのようにマップのスクロールとは無関係に表示する)にします。
 * ただし、イベントそのものの位置は変わりません。
 *
 * 例：<CG絶対座標:1,16,-16> or <CGAbsolute:1,16,-16>
 *
 * <CG色調:（ページ数）,（R値）,（G値）,（B値）,（グレースケール）>
 * 指定したページが有効になった場合の色調(-255～255)を設定します。
 * グレースケールは省略可能で、省略すると0になります。
 *
 * 例：<CG色調:1,-255,0,255,0> or <CGTone:1,-255,0,255,0>
 *
 * <CG不透明度:（ページ数）,（合成方法）>
 * 指定したページが有効になった場合のグラフィックの不透明度を設定します。
 * 0:透明 - 255:不透明
 *
 * 例：<CG不透明度:1,64> or <CGOpacity:1,64>
 *
 * <CGトリミング:（ページ数）,（X座標）,（Y座標）,（横幅）,（縦幅）>
 * 画像を指定した矩形でトリミングして表示します。
 *
 * 例：<CGトリミング:1,0,0,24,24> or <CGトリミング:1,0,0,24,24>
 *
 * 〇スクリプト（高度な設定。移動ルートの指定からスクリプトで実行）
 *
 * ・拡大率の設定
 * this.setScale(（X座標）,（Y座標）);
 * 例：this.setScale(100, 100);
 *
 * ・回転角の設定
 * this.setAngle(（回転角）);
 * 例：this.setAngle(180);
 *
 * ・ピクセル単位位置の設定
 * this.shiftPosition(（X座標）,（Y座標）);
 * 例：this.shiftPosition(24, 24);
 *
 * ・色調の設定
 * this.setTone(（R値）,（G値）,（B値）, （グレースケール）);
 * 例：this.setTone(255, -255, -255, 0);
 *
 * ・画像の変更
 * this.changeImage(（新しいファイル名）, （インデックス）);
 * 例：this.changeImage('Package1', 3);
 *
 * ※1 画像種別(ピクチャ⇒遠景など)を変更することはできません。
 * ※2 インデックスの指定を省略した場合、変更前の値が維持されます。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * EventEffects.jsと併用する場合は、本プラグインを下に配置してください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function () {
    'use strict';
    var pluginName = 'CharacterGraphicExtend';

    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON' || (value || '').toUpperCase() === 'TRUE';
    };

    var getParamOther = function (paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name) return name;
        }
        return null;
    };

    var getArgArrayString = function (args, upperFlg) {
        var values = getArgString(args, upperFlg).split(',');
        for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
        return values;
    };

    var getArgString = function (args, upperFlg) {
        args = convertEscapeCharacters(args);
        return upperFlg ? args.toUpperCase() : args;
    };

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

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

    //=============================================================================
    // パラメータの取得とバリデーション
    //=============================================================================
    var paramEventHideInvalid = getParamBoolean(['EventHideInvalid', 'イベント消去無効']);
    var paramLinkFollower = getParamBoolean(['LinkFollower', 'フォロワー連動']);

    //=============================================================================
    // Game_CharacterBase
    //  拡張するプロパティを定義します。
    //=============================================================================
    var _DataManager_extractMetadata = DataManager.extractMetadata;
    DataManager.extractMetadata = function (data) {
        _DataManager_extractMetadata.apply(this, arguments);
        this.extractMetadataArray(data);
    };

    DataManager.extractMetadataArray = function (data) {
        var re = /<([^<>:]+)(:?)([^>]*)>/g;
        data.metaArray = {};
        var match = true;
        while (match) {
            match = re.exec(data.note);
            if (match) {
                var metaName = match[1];
                data.metaArray[metaName] = data.metaArray[metaName] || [];
                data.metaArray[metaName].push(match[2] === ':' ? match[3] : true);
            }
        }
    };

    //=============================================================================
    // Game_System
    //  ロード時にプレイヤーの初期化が必要な場合は初期化します。
    //=============================================================================
    var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
    Game_System.prototype.onAfterLoad = function () {
        _Game_System_onAfterLoad.apply(this, arguments);
        if (!$gamePlayer.hasOwnProperty('_customResource')) {
            $gamePlayer.clearCgInfo();
        }
    };

    //=============================================================================
    // Game_CharacterBase
    //  拡張するプロパティを定義します。
    //=============================================================================
    var _Game_CharacterBase_initMembers = Game_CharacterBase.prototype.initMembers;
    Game_CharacterBase.prototype.initMembers = function () {
        _Game_CharacterBase_initMembers.apply(this, arguments);
        this.clearCgInfo();
    };

    Game_CharacterBase.prototype.clearCgInfo = function () {
        this._customResource = null;
        this._graphicColumns = 1;
        this._graphicRows = 1;
        this._additionalX = 0;
        this._additionalY = 0;
        this._customPriority = null;
        this._scaleX = 100;
        this._scaleY = 100;
        this._tileBlockWidth = 1;
        this._tileBlockHeight = 1;
        this._angle = 0;
        this._originX = null;
        this._originY = null;
        this._absoluteX = null;
        this._absoluteY = null;
        this._customTilesetId = 0;
        this._graphicHue = 0;
        // for ParallaxLayerMap.js
        if (this.initBlendMode) {
            return;
        }
        this.setBlendMode(0);
    };

    Game_CharacterBase.prototype.customResource = function () {
        return this._customResource;
    };

    Game_CharacterBase.prototype.customResourceHue = function () {
        return this._graphicHue;
    };

    Game_CharacterBase.prototype.customTilesetId = function () {
        return this._customTilesetId;
    };

    Game_CharacterBase.prototype.graphicColumns = function () {
        return this._graphicColumns;
    };

    Game_CharacterBase.prototype.graphicRows = function () {
        return this._graphicRows;
    };

    Game_CharacterBase.prototype.scaleX = function () {
        return this._scaleX;
    };

    Game_CharacterBase.prototype.scaleY = function () {
        return this._scaleY;
    };

    Game_CharacterBase.prototype.setScale = function (x, y) {
        this._scaleX = x;
        this._scaleY = y;
    };

    var _Game_Player_setScale = Game_Player.prototype.setScale
    Game_Player.prototype.setScale = function (x, y) {
        _Game_Player_setScale.apply(this, arguments);
        if (paramLinkFollower) {
            this.followers().forEach(function (follower) {
                follower.setScale(x, y);
            });
        }
    };

    Game_CharacterBase.prototype.originX = function () {
        return this._originX;
    };

    Game_CharacterBase.prototype.originY = function () {
        return this._originY;
    };

    Game_CharacterBase.prototype.setOrigin = function (x, y) {
        this._originX = x / 100;
        this._originY = y / 100;
    };

    Game_CharacterBase.prototype.absoluteX = function () {
        return this._absoluteX;
    };

    Game_CharacterBase.prototype.absoluteY = function () {
        return this._absoluteY;
    };

    Game_CharacterBase.prototype.setAbsolute = function (x, y) {
        this._absoluteX = x;
        this._absoluteY = y;
    };

    Game_CharacterBase.prototype.tone = function () {
        return this._tone;
    };

    Game_CharacterBase.prototype.setTone = function (r, g, b, gray) {
        this._tone = [r, g, b, gray || 0];
    };

    var _Game_Player_setTone = Game_Player.prototype.setTone;
    Game_Player.prototype.setTone = function (r, g, b, gray) {
        _Game_Player_setTone.apply(this, arguments);
        if (paramLinkFollower) {
            this.followers().forEach(function (follower) {
                follower.setTone(r, g, b, gray);
            });
        }
    };

    Game_CharacterBase.prototype.angle = function () {
        return this._angle;
    };

    Game_CharacterBase.prototype.setAngle = function (angle) {
        this._angle = angle;
    };

    var _Game_Player_setAngle = Game_Player.prototype.setAngle;
    Game_Player.prototype.setAngle = function (angle) {
        _Game_Player_setAngle.apply(this, arguments);
        if (paramLinkFollower) {
            this.followers().forEach(function (follower) {
                follower.setAngle(angle);
            });
        }
    };

    Game_CharacterBase.prototype.shiftPosition = function (x, y) {
        this._additionalX = x;
        this._additionalY = y;
    };

    var _Game_Player_shiftPosition = Game_Player.prototype.shiftPosition;
    Game_Player.prototype.shiftPosition = function (x, y) {
        _Game_Player_shiftPosition.apply(this, arguments);
        if (paramLinkFollower) {
            this.followers().forEach(function (follower) {
                follower.shiftPosition(x, y);
            });
        }
    };

    Game_CharacterBase.prototype.tileBlockWidth = function () {
        return this._tileBlockWidth;
    };

    Game_CharacterBase.prototype.tileBlockHeight = function () {
        return this._tileBlockHeight;
    };

    Game_CharacterBase.prototype.getTrimRect = function () {
        return this._trimRect || null;
    };

    var _Game_CharacterBase_pos = Game_CharacterBase.prototype.pos;
    Game_CharacterBase.prototype.pos = function (x, y) {
        if (this.tileBlockWidth() >= 2) {
            return (this._x - this.tileBlockWidth() / 2 <= x && this._x + this.tileBlockWidth() / 2 >= x) && this._y === y;
        } else {
            return _Game_CharacterBase_pos.apply(this, arguments);
        }
    };

    var _Game_CharacterBase_screenX = Game_CharacterBase.prototype.screenX;
    Game_CharacterBase.prototype.screenX = function () {
        return this._absoluteX > 0 ? this.absoluteX() : _Game_CharacterBase_screenX.apply(this, arguments) + this._additionalX;
    };

    var _Game_CharacterBase_screenY = Game_CharacterBase.prototype.screenY;
    Game_CharacterBase.prototype.screenY = function () {
        return this._absoluteY > 0 ? this.absoluteY() : _Game_CharacterBase_screenY.apply(this, arguments) + this._additionalY;
    };

    var _Game_CharacterBase_screenZ = Game_CharacterBase.prototype.screenZ;
    Game_CharacterBase.prototype.screenZ = function () {
        return this._customPriority !== null ? this._customPriority : _Game_CharacterBase_screenZ.apply(this, arguments);
    };

    Game_CharacterBase.prototype.changeImage = function (fileName, fileIndex) {
        if (arguments.length < 2) {
            fileIndex = this._characterIndex;
        }
        Game_CharacterBase.prototype.setImage.call(this, fileName, fileIndex);
    };

    //=============================================================================
    // Game_Event
    //  拡張するプロパティを定義します。
    //=============================================================================
    Game_Event.blendModeParams = {
        '1': 1, '加算': 1,
        '2': 2, '乗算': 2,
        '3': 3, 'スクリーン': 3
    };

    Game_Event.prototype.getMetaCg = function (names) {
        if (!this.event().metaArray) {
            return null;
        }
        if (!Array.isArray(names)) names = [names];
        var metaParams = this.getMetaParameter(names);
        if (!metaParams) return null;
        var result = null;
        metaParams.some(function (metaParam) {
            var params = getArgArrayString(metaParam);
            if (this.isValidCgeParam(params)) {
                result = params;
                if (metaParam.match(/\\v/gi)) {
                    this._graphicDynamic = true;
                }
            }
            return result;
        }.bind(this));
        return result;
    };

    Game_Event.prototype.getMetaParameter = function (names) {
        var metaParams = null;
        names.some(function (name) {
            if (!metaParams || metaParams[0] === '') {
                metaParams = this.event().metaArray['CG' + name];
            }
            return metaParams;
        }.bind(this));
        return metaParams;
    };

    Game_Event.prototype.isValidCgeParam = function (params) {
        var pageIndex = getArgNumber(params[0]);
        return params.length > 1 && (pageIndex === this._pageIndex + 1 || params[0].toUpperCase() === 'A');
    };

    var _Game_Event_refresh = Game_Event.prototype.refresh;
    Game_Event.prototype.refresh = function () {
        // added by nekoma start
        var moveRoute = this._moveRoute;
        var moveRouteIndex = this._moveRouteIndex;
        var moveRouteForcing = this._moveRouteForcing;
        var starting = this._starting;
        // added by nekoma end
        if (this._graphicDynamic) {
            this._pageIndex = -1;
        }
        _Game_Event_refresh.apply(this, arguments);
        // added by nekoma start
        if (this._graphicDynamic) {
            this._moveRoute = moveRoute;
            this._moveRouteIndex = moveRouteIndex;
            this._moveRouteForcing = moveRouteForcing;
            this._starting = starting;
        }
        // added by nekoma end
    };

    var _Game_Event_setupPageSettings = Game_Event.prototype.setupPageSettings;
    Game_Event.prototype.setupPageSettings = function () {
        this.clearCgInfo();
        _Game_Event_setupPageSettings.apply(this, arguments);
        var cgParams = this.getMetaCg(['シフト', 'Shift']);
        if (cgParams) {
            this.shiftPosition(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
        }
        cgParams = this.getMetaCg(['プライオリティ', 'Priority']);
        if (cgParams) {
            this._customPriority = getArgNumber(cgParams[1]);
        }
        cgParams = this.getMetaCg(['合成方法', 'BlendType']);
        if (cgParams) {
            var blendMode = Game_Event.blendModeParams[cgParams[1]] || 0;
            this.setBlendMode(blendMode);
        }
        cgParams = this.getMetaCg(['拡大率', 'Scale']);
        if (cgParams) {
            this._scaleX = getArgNumber(cgParams[1]);
            this._scaleY = getArgNumber(cgParams[2]);
        }
        cgParams = this.getMetaCg(['回転角', 'Angle']);
        if (cgParams) {
            this.setAngle(getArgNumber(cgParams[1], 0, 360));
        }
        cgParams = this.getMetaCg(['原点', 'Origin']);
        if (cgParams) {
            this.setOrigin(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
        }
        cgParams = this.getMetaCg(['絶対座標', 'Absolute']);
        if (cgParams) {
            this.setAbsolute(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]));
        }
        cgParams = this.getMetaCg(['色調', 'Tone']);
        if (cgParams) {
            this.setTone(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]),
                getArgNumber(cgParams[3]), getArgNumber(cgParams[4]));
        }
        cgParams = this.getMetaCg(['不透明度', 'Opacity']);
        if (cgParams) {
            this.setOpacity(getArgNumber(cgParams[1]));
        }
        cgParams = this.getMetaCg(['トリミング', 'Trimming']);
        if (cgParams) {
            this._trimRect = new Rectangle(getArgNumber(cgParams[1]), getArgNumber(cgParams[2]), getArgNumber(cgParams[3]), getArgNumber(cgParams[4]));
        }
    };

    var _Game_Event_setTileImage = Game_Event.prototype.setTileImage;
    Game_Event.prototype.setTileImage = function (tileId) {
        _Game_Event_setTileImage.apply(this, arguments);
        var cgParams = this.getMetaCg(['タイル', 'Tile']);
        if (cgParams) {
            this._tileBlockWidth = getArgNumber(cgParams[1]);
            this._tileBlockHeight = getArgNumber(cgParams[2]);
        }
        cgParams = this.getMetaCg(['タイルセット', 'Tileset']);
        if (cgParams) {
            this._customTilesetId = getArgNumber(cgParams[1]);
        }
    };

    var _Game_Event_setImage = Game_Event.prototype.setImage;
    Game_Event.prototype.setImage = function (characterName, characterIndex) {
        this._graphicHue = 0;
        var cgParams = this.getMetaCg(['ピクチャ', 'Picture']);
        if (cgParams) {
            this._customResource = 'Picture';
            this._graphicColumns = 1;
            this._graphicRows = 1;
            this._graphicHue = getArgNumber(cgParams[2]);
            arguments[0] = cgParams[1];
            arguments[1] = 0;
        }
        cgParams = this.getMetaCg(['敵キャラ', 'Enemy']);
        if (cgParams) {
            this._customResource = $gameSystem.isSideView() ? 'SvEnemy' : 'Enemy';
            this._graphicColumns = 1;
            this._graphicRows = 1;
            this._graphicHue = getArgNumber(cgParams[2]);
            arguments[0] = cgParams[1];
            arguments[1] = 0;
        }
        cgParams = this.getMetaCg(['アイコン', 'Icon']);
        if (cgParams) {
            const bitmap = ImageManager.loadSystem('IconSet');
            this._customResource = 'System';
            this._graphicColumns = 16;
            this._graphicRows = (bitmap.height / Window_Base._iconHeight) || 20;
            arguments[0] = 'IconSet';
            arguments[1] = getArgNumber(cgParams[1], 0, this._graphicColumns * this._graphicRows - 1);
        }
        cgParams = this.getMetaCg(['フェイス', 'Face']);
        if (cgParams) {
            this._customResource = 'Face';
            this._graphicColumns = 4;
            this._graphicRows = 2;
            this._graphicHue = getArgNumber(cgParams[3]);
            arguments[0] = cgParams[1];
            arguments[1] = getArgNumber(cgParams[2], 0, this._graphicColumns * this._graphicRows - 1);
        }
        cgParams = this.getMetaCg(['遠景', 'Parallax']);
        if (cgParams) {
            this._customResource = 'Parallax';
            this._graphicColumns = 1;
            this._graphicRows = 1;
            this._graphicHue = getArgNumber(cgParams[2]);
            arguments[0] = cgParams[1];
            arguments[1] = 0;
        }
        cgParams = this.getMetaCg(['アクター', 'Actor']);
        if (cgParams) {
            this._customResource = 'SvActor';
            this._graphicColumns = 9;
            this._graphicRows = 6;
            this._graphicHue = getArgNumber(cgParams[3]);
            arguments[0] = cgParams[1];
            arguments[1] = getArgNumber(cgParams[2], 0, this._graphicColumns * this._graphicRows - 1);
        }
        _Game_Event_setImage.apply(this, arguments);
    };

    //=============================================================================
    // Spriteset_Map
    //  イベントを消去するエフェクトを無効にします。
    //=============================================================================
    var _Spriteset_Map_hideCharacters = Spriteset_Map.prototype.hideCharacters;
    Spriteset_Map.prototype.hideCharacters = function () {
        if (!paramEventHideInvalid) _Spriteset_Map_hideCharacters.apply(this, arguments);
    };

    //=============================================================================
    // Sprite_Character
    //  拡張したプロパティに基づいてエフェクトを反映させます。
    //=============================================================================
    var _Sprite_Character_initMembers = Sprite_Character.prototype.initMembers;
    Sprite_Character.prototype.initMembers = function () {
        _Sprite_Character_initMembers.apply(this, arguments);
        this._customTilesetId = 0;
    };

    var _Sprite_Character_tilesetBitmap = Sprite_Character.prototype.tilesetBitmap;
    Sprite_Character.prototype.tilesetBitmap = function (tileId) {
        var customTilesetId = this._character.customTilesetId();
        this._customTilesetId = customTilesetId;
        if (customTilesetId) {
            var tileset = $dataTilesets[customTilesetId];
            var setNumber = 5 + Math.floor(tileId / 256);
            return ImageManager.loadTileset(tileset.tilesetNames[setNumber]);
        } else {
            return _Sprite_Character_tilesetBitmap.apply(this, arguments);
        }
    };

    var _Sprite_Character_updateBitmap = Sprite_Character.prototype.updateBitmap;
    Sprite_Character.prototype.updateBitmap = function () {
        if (this.isImageChanged()) this._customResource = this._character.customResource();
        _Sprite_Character_updateBitmap.apply(this, arguments);
        this.updateExtend();
    };

    // Resolve conflict for MOG_CharPoses.js
    var _Sprite_Character_setBitmapCache = Sprite_Character.prototype.setBitmapCache;
    Sprite_Character.prototype.setBitmapCache = function () {
        if (this._customResource) {
            return;
        }
        _Sprite_Character_setBitmapCache.apply(this, arguments);
    };

    var _Sprite_Character_update = Sprite_Character.prototype.update;
    Sprite_Character.prototype.update = function () {
        _Sprite_Character_update.apply(this, arguments);
        // for T_dashMotion.js
        if (this.updateDashMotion) {
            this.resolveConflictForDashMotion();
        }

        // for UltraMode7.jp PRTN added ----
        if ($gameMap.useUltraMode7) {
            this.resolveConflictForUltraMode7();
        }
    };

    // PRTN added ---------
    Sprite_Character.prototype.resolveConflictForUltraMode7 = function () {
        if (this._character.scaleY() !== 100) {
            this.scale.x = this._character.scaleX() / 100 * this.scale.x;
            this.scale.y = this._character.scaleY() / 100 * this.scale.y;
        }
        if (this._character.angle() !== 0) {
            var angle = this._character.angle() * Math.PI / 180;
            if (this.rotation !== angle) this.rotation = angle;
        }
    };
    // --------------------

    Sprite_Character.prototype.resolveConflictForDashMotion = function () {
        if (this._character.scaleY() !== 100) {
            this.scale.y = this._character.scaleY() / 100 * this.scale.y;
        }
        if (this._character.angle() !== 0) {
            var angle = this._character.angle() * Math.PI / 180;
            if (this.rotation !== angle) this.rotation = angle;
        }
    };

    Sprite_Character.prototype.updateExtend = function () {
        var scaleX = this._character.scaleX() / 100;
        var scaleY = this._character.scaleY() / 100;
        this.scale.x = scaleX;
        this.scale.y = scaleY;
        // for TMNamePop.js
        if (this._namePop && this._namePopSprite) {
            this._namePopSprite.scale.x = scaleX;
            this._namePopSprite.scale.y = scaleY;
        }
        var originX = this._character.originX();
        if (originX != null) this.anchor.x = originX;
        var originY = this._character.originY();
        if (originY != null) this.anchor.y = originY;
        var angle = this._character.angle() * Math.PI / 180;
        if (this.rotation !== angle) this.rotation = angle;
        var tone = this._character.tone();
        if (tone) this.setColorTone(tone);
    };

    // Resolve conflict by EventEffects.js
    var _Sprite_Character_updateAngle = Sprite_Character.prototype.updateAngle;
    Sprite_Character.prototype.updateAngle = function () {
        if (this._character.originY() != null) {
            return;
        }
        _Sprite_Character_updateAngle.apply(this, arguments);
    };

    var _Sprite_Character_setFrame = Sprite_Character.prototype.setFrame;
    Sprite_Character.prototype.setFrame = function (sx, sy, pw, ph) {
        var rect = this._character.getTrimRect();
        if (rect) {
            _Sprite_Character_setFrame.call(this, sx + rect.x, sy + rect.y, rect.width, rect.height);
        } else {
            _Sprite_Character_setFrame.call(this, sx, sy,
                pw * this._character.tileBlockWidth(), ph * this._character.tileBlockHeight());
        }
    };

    var _Sprite_Character_isImageChanged = Sprite_Character.prototype.isImageChanged;
    Sprite_Character.prototype.isImageChanged = function () {
        return _Sprite_Character_isImageChanged.apply(this, arguments) || this.isCustomImageChanged();
    };

    Sprite_Character.prototype.isCustomImageChanged = function () {
        return this._customResource !== this._character.customResource() ||
            this._customTilesetId !== this._character.customTilesetId();
    };

    var _Sprite_Character_setCharacterBitmap = Sprite_Character.prototype.setCharacterBitmap;
    Sprite_Character.prototype.setCharacterBitmap = function () {
        if (this._customResource) {
            const hue = this._character.customResourceHue() || 0;
            this.bitmap = ImageManager['load' + this._customResource](this._characterName, hue);
        } else {
            _Sprite_Character_setCharacterBitmap.apply(this, arguments);
        }
    };

    var _Sprite_Character_characterBlockX = Sprite_Character.prototype.characterBlockX;
    Sprite_Character.prototype.characterBlockX = function () {
        if (this._customResource) {
            return this._characterIndex % this._character.graphicColumns();
        } else {
            return _Sprite_Character_characterBlockX.apply(this, arguments);
        }
    };

    var _Sprite_Character_characterBlockY = Sprite_Character.prototype.characterBlockY;
    Sprite_Character.prototype.characterBlockY = function () {
        if (this._customResource) {
            return Math.floor(this._characterIndex / this._character.graphicColumns());
        } else {
            return _Sprite_Character_characterBlockY.apply(this, arguments);
        }
    };

    var _Sprite_Character_patternWidth = Sprite_Character.prototype.patternWidth;
    Sprite_Character.prototype.patternWidth = function () {
        if (this._customResource) {
            return this.bitmap.width / this._character.graphicColumns();
        } else {
            return _Sprite_Character_patternWidth.apply(this, arguments);
        }
    };

    var _Sprite_Character_patternHeight = Sprite_Character.prototype.patternHeight;
    Sprite_Character.prototype.patternHeight = function () {
        if (this._customResource) {
            return this.bitmap.height / this._character.graphicRows();
        } else {
            return _Sprite_Character_patternHeight.apply(this, arguments);
        }
    };

    var _Sprite_Character_characterPatternX = Sprite_Character.prototype.characterPatternX;
    Sprite_Character.prototype.characterPatternX = function () {
        if (this._customResource) {
            return 0;
        } else {
            return _Sprite_Character_characterPatternX.apply(this, arguments);
        }
    };

    var _Sprite_Character_characterPatternY = Sprite_Character.prototype.characterPatternY;
    Sprite_Character.prototype.characterPatternY = function () {
        if (this._customResource) {
            return 0;
        } else {
            return _Sprite_Character_characterPatternY.apply(this, arguments);
        }
    };

    // for ApngPicture.js
    var _Sprite_Character_setCharacterBitmap2 = Sprite_Character.prototype.setCharacterBitmap;
    Sprite_Character.prototype.setCharacterBitmap = function () {
        _Sprite_Character_setCharacterBitmap2.apply(this, arguments);
        if (this.addApngChild) {
            this.addApngChild(this._characterName);
        }
    };

    Sprite_Character.prototype.loadApngSprite = function (name) {
        switch (this._customResource) {
            case 'Picture':
                return SceneManager.tryLoadApngPicture(name);
            case 'SvEnemy':
                return SceneManager.tryLoadApngSideEnemy(name);
            case 'Enemy':
                return SceneManager.tryLoadApngEnemy(name);
            default:
                return null;
        }
    };

    var _Scene_Base_terminate = Scene_Base.prototype.terminate;
    Scene_Base.prototype.terminate = function () {
        _Scene_Base_terminate.apply(this, arguments);
        if (this._spriteset && this._spriteset.destroyApngCharacter) {
            this._spriteset.destroyApngCharacter();
        }
    };

    Spriteset_Map.prototype.destroyApngCharacter = function () {
        this._characterSprites.forEach(function (sprite) {
            if (sprite.destroyApngIfNeed) {
                sprite.destroyApngIfNeed();
            }
        })
    };
})();


code:
//=============================================================================
// CharacterPopupDamage.js
// ----------------------------------------------------------------------------
// (C) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.6.0 2018/11/11 プラグインの型指定機能に対応
//                  ポップアップ効果音を消音できるスイッチを追加
// 1.5.1 2017/11/10 コピペミスによる誤記を修正
// 1.5.0 2017/04/23 ポップアップ時にキャラクターをフラッシュさせる機能を追加
// 1.4.0 2017/03/03 ピクチャより前面にポップアップできる設定を追加
//                  回転がない場合でも拡大率を自由に変更できるよう修正
// 1.3.0 2017/01/23 スリップダメージのポップアップに対応
//                  対応するフォロワーのポップアップを表示する機能を追加
// 1.2.0 2016/12/31 ポップアップの色調設定機能を追加
//                  ポップアップの表示方法を詳細指定できる機能を追加
// 1.1.1 2016/09/15 最新の修正で自動ポップアップの設定が手動に影響していた問題を修正
// 1.1.0 2016/09/14 MPダメージ用に専用効果音を指定できる機能を追加
//                  HP、MP、TP、増加、減少の条件で個別に出力可否を設定できる機能を追加
// 1.0.3 2016/09/10 VE_BasicModule.jsとの競合を解消
// 1.0.2 2016/04/17 ポップアップ無効化のプラグインコマンドが機能していなかった問題を修正
// 1.0.1 2016/04/10 HPの増減との連動で増やすと減らすが逆に解釈されていたのを修正
// 1.0.0 2016/04/09 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc キャラクターのダメージポッププラグイン
 * @author トリアコンタン
 *
 * @param 効果音演奏
 * @desc 状況に応じたシステム効果音を自動演奏します。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param 消音スイッチID
 * @desc 指定したIDのスイッチがONになっているとき、システム効果音が自動演奏されなくなります。
 * @default 0
 * @type switch
 *
 * @param X座標補正
 * @desc ポップアップ位置のX座標を補正します。
 * @default 0
 *
 * @param Y座標補正
 * @desc ポップアップ位置のY座標を補正します。
 * @default 0
 *
 * @param HP自動ポップアップ
 * @desc HPの増減を自動ポップアップの対象にします。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param MP自動ポップアップ
 * @desc MPの増減を自動ポップアップの対象にします。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param TP自動ポップアップ
 * @desc TPの増減を自動ポップアップの対象にします。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param 増加自動ポップアップ
 * @desc パラメータの増加を自動ポップアップの対象にします。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param 減少自動ポップアップ
 * @desc パラメータの減少を自動ポップアップの対象にします。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param MPダメージ音
 * @desc MPダメージ時の効果音ファイル名を別途指定(audio/se)します。何も指定しないとHPと同じになります。
 * @default
 *
 * @param 回転
 * @desc 数字の回転運動を有効にします。
 * @default true
 * @type boolean
 *
 * @param X方向半径
 * @desc 数字を回転させる場合のX方向の半径です。
 * @default 40
 *
 * @param Y方向半径
 * @desc 数字を回転させる場合のY方向の半径です。
 * @default 40
 *
 * @param 回転速度
 * @desc 数字を回転させる場合の速度です。
 * @default 60
 *
 * @param 拡大率
 * @desc 初期状態の拡大率です。
 * @default 100
 *
 * @param 拡大率変化値
 * @desc 1フレームごとの拡大率の変化値です。
 * @default -10
 *
 * @param 最前面表示
 * @desc ポップアップをピクチャより前面に表示します。
 * @default false
 * @type boolean
 *
 * @help マップ画面でイベントやプレイヤーに数字をポップアップさせる機能を提供します。
 * マップ上でのダメージや回復の演出に利用できます。演出は戦闘時のものと同一です。
 * 指定する値をマイナスにすると回復扱いとなり色が変わります。
 * また、クリティカルにすると数字の色が一瞬、赤くなります。
 *
 * また「HPの増減」等のイベント実行時に自動で変化量をポップアップする機能や、
 * ダメージ床を通過した際に自動でポップアップする機能も用意されています。
 * パラメータにより、HPのみや増加のみといった条件指定もできます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * ・CPD_DAMAGE or ポップアップダメージ [キャラクターID] [ダメージ値] [反転]
 * キャラクターを指定してダメージをポップアップします。
 * キャラクターの指定は以下の通りです。
 * -1   : プレイヤー
 *  0   : 実行中のイベント
 *  1.. : 指定したIDのイベント
 *
 * 反転を有効にすると、ポップアップの回転方向が逆になります。
 * （パラメータの「回転」を有効にしている場合）
 *
 * CPD_DAMAGE 5 -300 ON
 * ポップアップダメージ 0 \v[1] OFF
 *
 * ・CPD_CRITICAL or ポップアップクリティカル
 * キャラクターを指定してダメージをクリティカル扱いでポップアップします。
 *
 * CPD_CRITICAL -1 100 ON
 * ポップアップクリティカル 3 \v[1] OFF
 *
 * ・CPD_MP_DAMAGE or ポップアップMPダメージ
 * キャラクターを指定してMPダメージをポップアップします。
 *
 * CPD_MP_DAMAGE 5 -300 ON
 * ポップアップMPダメージ 0 \v[1] OFF
 *
 * ・CPD_MP_CRITICAL or ポップアップMPクリティカル
 * キャラクターを指定してMPダメージをクリティカル扱いでポップアップします。
 *
 * CPD_MP_CRITICAL -1 100 ON
 * ポップアップMPクリティカル 3 \v[1] OFF
 *
 * ・CPD_MISS or ポップアップミス
 * キャラクターを指定してmissをポップアップします。
 *
 * CPD_MISS -1 ON
 * ポップアップミス 3 OFF
 *
 * ・CPD_INVALID or ポップアップ無効化
 * 自動ポップアップを無効にします。
 * 有効になっているとイベントコマンド「HPの増減」「MPの増減」「TPの増減」
 * およびダメージ床によるダメージが自動でポップアップします。
 * 初期状態では有効です。
 *
 * ・CPD_VALID or ポップアップ有効化
 * 自動ポップアップを再度有効にします。
 *
 * ・CPD_SETTING_TONE or ポップアップ設定_色調 [赤] [緑] [青] [グレー]
 * ポップアップ画像の色調を変更できます。色調の設定値を順番に指定してください。
 *
 * CPD_SETTING_TONE 255 0 0 255
 * ポップアップ設定_色調 -255 -255 -255 0
 *
 * ・CPD_SETTING_FLASH or ポップアップ設定_フラッシュ [赤] [緑] [青] [強さ]
 * ポップアップ時にキャラクターをフラッシュします。
 * フラッシュするのはダメージを受けた場合のみです。
 *
 * CPD_SETTING_FLASH 255 0 0 255
 * ポップアップ設定_フラッシュ 255 0 0 255
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var pluginName = 'CharacterPopupDamage';
    var settings = {
        /* MPダメージ専用効果音(ファイル名はパラメータで指定) */
        mpDamageSe: {
            volume: 90,
            pitch: 100,
            pan: 0
        }
    };

    var getCommandName = function (command) {
        return (command || '').toUpperCase();
    };

    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON' || (value || '').toUpperCase() === 'TRUE';
    };

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

    var getParamString = function (paramNames) {
        var value = getParamOther(paramNames);
        return value === null ? '' : value;
    };

    var getParamOther = function (paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name) return name;
        }
        return null;
    };

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

    var getArgBoolean = function (arg) {
        return (arg || '').toUpperCase() === 'ON';
    };

    var convertEscapeCharactersAndEval = function (text, evalFlg) {
        if (text === null || text === undefined) text = '';
        var window = SceneManager._scene._windowLayer.children[0];
        if (window) {
            var result = window.convertEscapeCharacters(text);
            return evalFlg ? eval(result) : result;
        } else {
            return text;
        }
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramPlaySe = getParamBoolean(['PlaySe', '効果音演奏']);
    var paramSuppressSwitchId = getParamNumber(['SuppressSwitchId', '消音スイッチID'], 0);
    var paramOffsetX = getParamNumber(['OffsetX', 'X座標補正']);
    var paramOffsetY = getParamNumber(['OffsetY', 'Y座標補正']);
    var paramTpAutoPop = getParamBoolean(['TPAutoPop', 'TP自動ポップアップ']);
    var paramMpAutoPop = getParamBoolean(['MPAutoPop', 'MP自動ポップアップ']);
    var paramHpAutoPop = getParamBoolean(['HPAutoPop', 'HP自動ポップアップ']);
    var paramIncreaseAutoPop = getParamBoolean(['IncreaseAutoPop', '増加自動ポップアップ']);
    var paramDecreaseAutoPop = getParamBoolean(['DecreaseAutoPop', '減少自動ポップアップ']);
    var paramMpDamageSe = getParamString(['MPDamageSe', 'MPダメージ音']);
    var paramRotation = getParamBoolean(['Rotation', '回転']);
    var paramRadiusX = getParamNumber(['RadiusX', 'X方向半径']);
    var paramRadiusY = getParamNumber(['RadiusY', 'Y方向半径']);
    var paramRotateSpeed = getParamNumber(['RotateSpeed', '回転速度']);
    var paramScale = getParamNumber(['Scale', '拡大率']);
    var paramScaleDelta = getParamNumber(['ScaleDelta', '拡大率変化値']);
    var paramOnTop = getParamBoolean(['OnTop', '最前面表示']);

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        this.pluginCommandCharacterPopupDamage(command, args);
    };

    Game_Interpreter.prototype.pluginCommandCharacterPopupDamage = function (command, args) {
        var popupArgs = [];
        switch (getCommandName(command)) {
            case 'CPD_DAMAGE':
            case 'ポップアップダメージ':
                popupArgs = [getArgNumber(args[1]), false, getArgBoolean(args[2])];
                this.callCharacterPopup(args, 'popupDamage', popupArgs);
                break;
            case 'CPD_CRITICAL':
            case 'ポップアップクリティカル':
                popupArgs = [getArgNumber(args[1]), true, getArgBoolean(args[2])];
                this.callCharacterPopup(args, 'popupDamage', popupArgs);
                break;
            case 'CPD_MP_DAMAGE':
            case 'ポップアップMPダメージ':
                popupArgs = [getArgNumber(args[1]), false, getArgBoolean(args[2])];
                this.callCharacterPopup(args, 'popupMpDamage', popupArgs);
                break;
            case 'CPD_MP_CRITICAL':
            case 'ポップアップMPクリティカル':
                popupArgs = [getArgNumber(args[1]), true, getArgBoolean(args[2])];
                this.callCharacterPopup(args, 'popupMpDamage', popupArgs);
                break;
            case 'CPD_MISS':
            case 'ポップアップミス':
                popupArgs = [getArgBoolean(args[1])];
                this.callCharacterPopup(args, 'popupMiss', popupArgs);
                break;
            case 'CPD_VALID':
            case 'ポップアップ有効化':
                $gameSystem.setSuppressAutoPopup(false);
                break;
            case 'CPD_INVALID':
            case 'ポップアップ無効化':
                $gameSystem.setSuppressAutoPopup(true);
                break;
            case 'CPD_SETTING_TONE':
            case 'ポップアップ設定_色調':
                var red = getArgNumber(args[0]);
                var green = getArgNumber(args[1]);
                var blue = getArgNumber(args[2]);
                var gray = getArgNumber(args[3]);
                $gameSystem.setPopupDamageTone([red, green, blue, gray]);
                break;
            case 'CPD_SETTING_FLASH':
            case 'ポップアップ設定_フラッシュ':
                var flashRed = getArgNumber(args[0], 0);
                var flashGreen = getArgNumber(args[1], 0);
                var flashBlue = getArgNumber(args[2], 0);
                var alpha = getArgNumber(args[3], 0) || 255;
                $gameSystem.setPopupDamageFlash([flashRed, flashGreen, flashBlue, alpha]);
                break;
        }
    };

    var _Game_Interpreter_command311 = Game_Interpreter.prototype.command311;
    Game_Interpreter.prototype.command311 = function () {
        var value = -this.operateValue(this._params[2], this._params[3], this._params[4]);
        this.iterateActorEx(this._params[0], this._params[1], function (actor) {
            actor.popupDamage(value);
        }.bind(this));
        return _Game_Interpreter_command311.apply(this, arguments);
    };

    var _Game_Interpreter_command312 = Game_Interpreter.prototype.command312;
    Game_Interpreter.prototype.command312 = function () {
        var value = -this.operateValue(this._params[2], this._params[3], this._params[4]);
        this.iterateActorEx(this._params[0], this._params[1], function (actor) {
            actor.popupMpDamage(value);
        }.bind(this));
        return _Game_Interpreter_command312.apply(this, arguments);
    };

    var _Game_Interpreter_command326 = Game_Interpreter.prototype.command326;
    Game_Interpreter.prototype.command326 = function () {
        var value = -this.operateValue(this._params[2], this._params[3], this._params[4]);
        this.iterateActorEx(this._params[0], this._params[1], function (actor) {
            actor.popupTpDamage(value);
        }.bind(this));
        return _Game_Interpreter_command326.apply(this, arguments);
    };

    Game_Interpreter.prototype.callCharacterPopup = function (args, methodName, extend) {
        var character = this.character(getArgNumber(args[0], -1));
        if (character) character[methodName].apply(character, extend);
    };

    //=============================================================================
    // Game_Actor
    //  ダメージ床によるポップアップを処理します。
    //=============================================================================
    var _Game_Actor_executeFloorDamage = Game_Actor.prototype.executeFloorDamage;
    Game_Actor.prototype.executeFloorDamage = function () {
        this.popupMapDamage(_Game_Actor_executeFloorDamage);
    };

    var _Game_Actor_turnEndOnMap = Game_Actor.prototype.turnEndOnMap;
    Game_Actor.prototype.turnEndOnMap = function () {
        this.popupMapDamage(_Game_Actor_turnEndOnMap);
    };

    Game_Actor.prototype.popupMapDamage = function (callBackFunc) {
        var prevHp = this.hp;
        var prevMp = this.mp;
        var prevTp = this.tp;
        callBackFunc.apply(this);
        var character = this.getCharacterObject();
        if (!character) return;
        var hpDamage = prevHp - this.hp;
        if (hpDamage !== 0 && $gameSystem.isNeedAutoHpPopup(hpDamage)) character.popupDamage(hpDamage, false);
        var mpDamage = prevMp - this.mp;
        if (mpDamage !== 0 && $gameSystem.isNeedAutoMpPopup(mpDamage)) character.popupMpDamage(mpDamage, false);
        var tpDamage = prevTp - this.tp;
        if (tpDamage !== 0 && $gameSystem.isNeedAutoTpPopup(tpDamage)) character.popupDamage(tpDamage, false);
    };

    Game_Actor.prototype.popupDamage = function (value) {
        var character = this.getCharacterObject();
        if (!character) return;
        if (value !== 0 && $gameSystem.isNeedAutoHpPopup(value)) {
            character.popupDamage(value, false);
        }
    };

    Game_Actor.prototype.popupMpDamage = function (value) {
        var character = this.getCharacterObject();
        if (!character) return;
        if (value !== 0 && $gameSystem.isNeedAutoMpPopup(value)) {
            character.popupMpDamage(value, false);
        }
    };

    Game_Actor.prototype.popupTpDamage = function (value) {
        var character = this.getCharacterObject();
        if (!character) return;
        if (value !== 0 && $gameSystem.isNeedAutoTpPopup(value)) {
            character.popupDamage(value, false);
        }
    };

    Game_Actor.prototype.getCharacterObject = function () {
        var index = $gameParty.battleMembers().indexOf(this);
        var result;
        switch (index) {
            case -1:
                result = null;
                break;
            case 0:
                result = $gamePlayer;
                break;
            default:
                var followers = $gamePlayer.followers();
                result = followers.isVisible() ? followers.follower(index - 1) : null;
        }
        return result;
    };

    //=============================================================================
    // Game_System
    //  オートポップアップの有効フラグを追加定義します。
    //=============================================================================
    var _Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        _Game_System_initialize.apply(this, arguments);
        this._suppressAutoPopup = false;
        this._popupDamageTone = null;
        this._popupDamageFlash = null;
    };

    Game_System.prototype.setSuppressAutoPopup = function (value) {
        this._suppressAutoPopup = !!value;
    };

    Game_System.prototype.isSuppressAutoPopup = function () {
        return this._suppressAutoPopup;
    };

    Game_System.prototype.isNeedAutoHpPopup = function (value) {
        return paramHpAutoPop && this.isNeedAutoPopup(value);
    };

    Game_System.prototype.isNeedAutoMpPopup = function (value) {
        return paramMpAutoPop && this.isNeedAutoPopup(value);
    };

    Game_System.prototype.isNeedAutoTpPopup = function (value) {
        return paramTpAutoPop && this.isNeedAutoPopup(value);
    };

    Game_System.prototype.isNeedAutoPopup = function (value) {
        return !$gameSystem.isSuppressAutoPopup() &&
            ((paramIncreaseAutoPop && value < 0) || (paramDecreaseAutoPop && value > 0));
    };

    Game_System.prototype.getPopupDamageTone = function () {
        return this._popupDamageTone;
    };

    Game_System.prototype.setPopupDamageTone = function (value) {
        this._popupDamageTone = value;
    };

    Game_System.prototype.getPopupDamageFlash = function () {
        return this._popupDamageFlash;
    };

    Game_System.prototype.setPopupDamageFlash = function (value) {
        this._popupDamageFlash = value;
    };

    //=============================================================================
    // Game_CharacterBase
    //  ダメージ情報を保持します。
    //=============================================================================
    Game_CharacterBase.prototype.popupDamage = function (value, critical, mirror) {
        this.startDamagePopup(value, critical, false, mirror);
    };

    Game_CharacterBase.prototype.popupMpDamage = function (value, critical, mirror) {
        this.startDamagePopup(value, critical, true, mirror);
    };

    Game_CharacterBase.prototype.popupMiss = function (mirror) {
        this.startDamagePopup(null, false, mirror);
    };

    Game_CharacterBase.prototype.isDamagePopupRequested = function () {
        return this._damagePopup;
    };

    Game_CharacterBase.prototype.clearDamagePopup = function () {
        if (!this._damageInfo || this._damageInfo.length === 0) {
            this._damagePopup = false;
        }
    };

    Game_CharacterBase.prototype.startDamagePopup = function (value, critical, mpFlg, mirror) {
        this._damagePopup = true;
        if (!this._damageInfo) this._damageInfo = [];
        var damageInfo = { value: value, critical: critical, mpFlg: mpFlg, mirror: mirror };
        if (this.isPlayPopupSe()) {
            this.playPopupSe(damageInfo);
        }
        this._damageInfo.push(damageInfo);
    };

    Game_CharacterBase.prototype.playPopupSe = function (damageInfo) {
        if (damageInfo.value === null) {
            SoundManager.playMiss();
        } else if (damageInfo.value < 0) {
            SoundManager.playRecovery();
        } else if (damageInfo.mpFlg && paramMpDamageSe) {
            settings.mpDamageSe.name = paramMpDamageSe;
            AudioManager.playStaticSe(settings.mpDamageSe);
        } else if (this === $gamePlayer) {
            SoundManager.playActorDamage();
        } else {
            SoundManager.playEnemyDamage();
        }
    };

    Game_CharacterBase.prototype.shiftDamageInfo = function () {
        return this._damageInfo ? this._damageInfo.shift() : null;
    };

    Game_CharacterBase.prototype.isPlayPopupSe = function () {
        return paramPlaySe && !$gameSwitches.value(paramSuppressSwitchId)
    };

    //=============================================================================
    // Sprite_Character
    //  ダメージをポップアップします。
    //=============================================================================
    var _Sprite_Character_update = Sprite_Character.prototype.update;
    Sprite_Character.prototype.update = function () {
        _Sprite_Character_update.apply(this, arguments);
        this.updateDamagePopup();
    };

    Sprite_Character.prototype.updateDamagePopup = function () {
        this.setupDamagePopup();
        if (this._damages && this._damages.length > 0) {
            for (var i = 0; i < this._damages.length; i++) {
                this._damages[i].update();
            }
            if (!this._damages[0].isPlaying()) {
                this.getPopupParent().removeChild(this._damages[0]);
                this._damages.shift();
            }
        }
        if (this._popupFlash) {
            this.updateDamagePopupFlash();
        }
    };

    Sprite_Character.prototype.updateDamagePopupFlash = function () {
        this.setBlendColor(this._popupFlash);
        this._popupFlash[3] -= this._popupFlashSpeed;
        if (this._popupFlash[3] <= 0) {
            this._popupFlash = null;
            this._popupFlashSpeed = 0;
        }
    };

    Sprite_Character.prototype.setupDamagePopup = function () {
        if (!this._character.isDamagePopupRequested()) return;
        var sprite = new Sprite_CharacterDamage();
        sprite.x = this.x + this.damageOffsetX();
        sprite.y = this.y + this.damageOffsetY();
        if (!sprite.z) sprite.z = 9;
        sprite.setupCharacter(this._character);
        if (!this._damages) this._damages = [];
        this._damages.push(sprite);
        this.getPopupParent().addChild(sprite);
        this._character.clearDamagePopup();
        if (!sprite.isMiss() && !sprite.isRecover()) {
            this.setupDamagePopupFlash();
        }
    };

    Sprite_Character.prototype.setupDamagePopupFlash = function () {
        var flashColor = $gameSystem.getPopupDamageFlash();
        if (!flashColor) return;
        this._popupFlash = flashColor.clone();
        this._popupFlashSpeed = Math.floor(this._popupFlash[3] / 30);
        this.updateDamagePopupFlash();
    };

    Sprite_Character.prototype.damageOffsetX = function () {
        return paramOffsetX;
    };

    Sprite_Character.prototype.damageOffsetY = function () {
        return paramOffsetY;
    };

    Sprite_Character.prototype.getPopupParent = function () {
        return paramOnTop ? this.parent.parent.parent : this.parent;
    };

    //=============================================================================
    // Sprite_CharacterDamage
    //  ダメージ情報を受け取ってセットアップします。
    //=============================================================================
    function Sprite_CharacterDamage() {
        this.initialize.apply(this, arguments);
    }

    Sprite_CharacterDamage.prototype = Object.create(Sprite_Damage.prototype);
    Sprite_CharacterDamage.prototype.constructor = Sprite_CharacterDamage;

    Sprite_CharacterDamage.prototype.setupCharacter = function (character) {
        var damageInfo = character.shiftDamageInfo();
        this._toneColor = $gameSystem.getPopupDamageTone();
        this._mirror = damageInfo.mirror;
        this._damageInfo = damageInfo;
        this._digit = 0;
        if (this.isMiss()) {
            this.createMissForCharacter();
        } else {
            this.createDigits(damageInfo.mpFlg ? 2 : 0, damageInfo.value);
        }
        if (damageInfo.critical) {
            this.setupCriticalEffect();
        }
    };

    Sprite_CharacterDamage.prototype.isMiss = function () {
        return this._damageInfo.value === null || this._damageInfo.value === 0;
    };

    Sprite_CharacterDamage.prototype.isRecover = function () {
        return this._damageInfo.value < 0;
    };

    Sprite_CharacterDamage.prototype.createMissForCharacter = function () {
        var w = this.digitWidth();
        var h = this.digitHeight();
        var sprite = this.createChildSprite();
        sprite.setFrame(0, 4 * h, 4 * w, h);
        sprite.dy = 0;
        sprite.x = w / 2;
        sprite.digit++;
        this._digit++;
    };

    Sprite_CharacterDamage.prototype.createChildSprite = function () {
        var sprite = Sprite_Damage.prototype.createChildSprite.apply(this, arguments);
        sprite.frame = 0;
        sprite.digit = this._digit++;
        if (this._toneColor) sprite.setColorTone(this._toneColor);
        return sprite;
    };

    Sprite_CharacterDamage.prototype.updateChild = function (sprite) {
        if (paramRotation) {
            this.updateChildRotation(sprite);
            sprite.setBlendColor(this._flashColor);
        } else {
            Sprite_Damage.prototype.updateChild.apply(this, arguments);
            sprite.x = 0;
        }
        if (paramScale) {
            this.updateChildScale(sprite);
        }
        sprite.frame++;
    };

    Sprite_CharacterDamage.prototype.updateChildRotation = function (sprite) {
        var frame = sprite.frame;
        var speed = frame / 3600 * paramRotateSpeed;
        sprite.rx = paramRadiusX * (Math.cos(speed) - 1);
        sprite.ry = -paramRadiusY * Math.sin(speed);
        if (this._mirror) {
            sprite.rx *= -1;
        }
        sprite.x = Math.round(sprite.rx);
        sprite.y = Math.round(sprite.ry);
    };

    Sprite_CharacterDamage.prototype.updateChildScale = function (sprite) {
        var frame = sprite.frame;
        var scale = (paramScale + frame * paramScaleDelta / 10) / 100;
        sprite.scale.x = scale;
        sprite.scale.y = scale;
        sprite.x += (sprite.digit - (this._digit - 1) / 2) * (this.digitWidth() * scale);
    };
})();


code:
//=============================================================================
// ChoiceListWithTimeLimit.js
// ----------------------------------------------------------------------------
// <利用規約>
//  利用はRPGツクールMV/RPGMakerMVの正規ユーザーに限られます。
//  商用、非商用、ゲームの内容を問わず利用可能です。
//  ゲームへの利用の際、報告や出典元の記載等は必須ではありません。
//  二次配布や転載は禁止します。
//  ソースコードURL、ダウンロードURLへの直接リンクも禁止します。
//  不具合対応以外のサポートやリクエストは受け付けておりません。
//  スクリプト利用により生じたいかなる問題においても、一切責任を負いかねます。
// ----------------------------------------------------------------------------
//  Ver1.00  2016/01/09  初版
//=============================================================================

/*:
 * @plugindesc 選択肢に、時間制限を設定します。
 * @author こま
 *
 * @help
 * 時間制限を設定したい選択肢の「一番最後の選択文」に、以下のように記述します。
 *
 *  <limit:3>
 *
 * 上記例の場合、制限時間を3秒に設定します。
 * 選択肢が2つの例を挙げると、以下のようになります。
 *
 *  #1:  選択肢1
 *  #2:  選択肢2
 *  #3:  <limit:3>
 *
 * 上記例の場合、プレイヤーが3秒以内に選択肢を選択しなかった場合、
 * #3が選択されたことになります。
 *
 * *このプラグインには、プラグインコマンドはありません。
 */

(function () {
    var _Window_ChoiceList_start = Window_ChoiceList.prototype.start;
    Window_ChoiceList.prototype.start = function () {
        this._time_limit = { time: 0, limit: 0, index: 0 };
        if (/<limit:(.*)>/.test($gameMessage._choices[$gameMessage._choices.length - 1])) {
            this._time_limit.limit = RegExp.$1 * 60;
            this._time_limit.index = $gameMessage._choices.length - 1;
            $gameMessage._choices.pop();
        }
        _Window_ChoiceList_start.call(this);
    };

    var _Window_ChoiceList_update = Window_ChoiceList.prototype.update;
    Window_ChoiceList.prototype.update = function () {
        if (this._time_limit && this._time_limit.limit > 0) {
            this._time_limit.time++;
            if (this._time_limit.time > this._time_limit.limit) {
                this._index = this._time_limit.index;
                delete this._time_limit;
                this.playBuzzerSound();
                this.updateInputData();
                this.deactivate();
                this.callOkHandler();
                return;
            }
        }
        _Window_ChoiceList_update.call(this);
    };

    var _Window_ChoiceList_close = Window_ChoiceList.prototype.close;
    Window_ChoiceList.prototype.close = function () {
        if (this._time_limit) {
            delete this._time_limit;
        }
        _Window_ChoiceList_close.call(this);
    };
}());