code:
//=============================================================================
// イベント引っ張りプラグイン
// PullableEvent.js
// Copyright (c) 2020- 村人Ａ
//=============================================================================

/*:ja
 * @plugindesc イベントメモ欄に<canPull:SE名>の記載があるイベントは引っ張れるようになります。
 * @author 村人A
 *
 * @help
 *
 * ＊このプラグインは冬空橙様専用に製作されたプラグインです。
 * ＊著作者に無断での使用を禁止します。
 *
 * _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
 *
 * バージョン情報
 *
 * 20/05/22 バージョン1.1 リリース
 *          イベントが正常に起動しない不具合を修正しました。
 *          いずれかのセルフスイッチがONの際に引っ張る・押す動作を中断するようにしました。
 *          イベントを押せるようにしました。
 * 20/05/20 バージョン1.0 リリース
 *
 * _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
 *
 * イベントのメモ欄に
 *
 * <canPull:SE名>
 *
 * の記述のあるイベントはイベント前で決定ボタンを押して反対へ移動すると引っ張るこ
 * とが出来るようになります。
 * ＳＥ名の箇所には引っ張った際に再生するＳＥを入れてください。
 * 例えばEarth4を引っ張った際に再生する場合は
 *
 * <canPull:Earth4>
 *
 * と記述してください。
 * 隊列歩行をしている場合は隊列がプレイヤーに重なり、１つとなって移動します。
 * 引っ張る際の移動速度はプラグインパラメータにて設定可能です。
 *
 * @param 引っ張る際の移動速度
 * @desc イベントを引っ張る際のプレイヤーとイベントの移動速度を指定します。数値はイベントの速度と同等です。
 * @default 3
 * @type Number
 * @min 1
 * @max 7
 *
 * @param 引っ張り機能をONにするスイッチ
 * @type switch
 * @default 1
 *
 */

{
	'use strict';

	const parameters = PluginManager.parameters('PullableEvent');
	const pullingSpeed = Number(parameters['引っ張る際の移動速度']);
	const pullOnSwitchId = Number(parameters['引っ張り機能をONにするスイッチ']);

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

	const _alias_Game_Player_executeMove = Game_Player.prototype.executeMove;
	Game_Player.prototype.executeMove = function (direction) {
		if ($gameSwitches.value(pullOnSwitchId) && this.isPulling) {
			if (this.areFollowersGathering()) { return };
			let canPass = false
			if (!this.pullingEvent) { throw new Error("引っ張るイベントが不正です。村人Ａまでご報告ください。") }
			const ev = this.pullingEvent
			if (direction == this.reverseDir(this.direction())) { canPass = this.canPass(this.x, this.y, direction) }
			if (direction == this.direction()) { canPass = ev.canPass(ev.x, ev.y, direction) }
			if (!canPass) { return }
			ev.moveStraight(direction)
			this._followers.forEach(follower => follower.moveStraight(direction));
			AudioManager.playSe({ "name": this.pullingSe, "volume": 100, "pitch": 100, "pan": 0 })
		}
		_alias_Game_Player_executeMove.call(this, direction);
	};

	const _alias_Game_Player_updateDashing = Game_Player.prototype.updateDashing;
	Game_Player.prototype.updateDashing = function () {
		if (this.isPulling) { return }
		_alias_Game_Player_updateDashing.call(this);
	}

	Game_Player.prototype.setEventPulling = function (event) {
		this.isPulling = true;
		this._dashing = false
		this.pullingEvent = event;
		this.setDirectionFix(true);
		this.setMoveSpeed(pullingSpeed);
		this._followers.forEach(follower => {
			follower.setDirection(this.direction());
			follower.setDirectionFix(true);
		});
	}

	Game_Player.prototype.finishEventPulling = function (preSpeed) {
		this.setDirectionFix(false);
		this._followers.forEach(follower => follower.setDirectionFix(false));
		this.isPulling = false;
		this.pullingEvent = null;
		this.setMoveSpeed(preSpeed);
	}

	//-----------------------------------------------------------------------------
	// Game_Follower
	//

	const _alias_Game_Follower_chaseCharacter = Game_Follower.prototype.chaseCharacter;
	Game_Follower.prototype.chaseCharacter = function (character) {
		if ($gamePlayer.isPulling) { return }
		_alias_Game_Follower_chaseCharacter.call(this, character)
	}

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

	const _alias_Game_Event_canPass = Game_Event.prototype.canPass;
	Game_Event.prototype.canPass = function (x, y, d) {
		if (this.isPulling && d != $gamePlayer.direction()) { return true }
		return _alias_Game_Event_canPass.call(this, x, y, d)
	}

	const _alias_Game_Event_initMembers = Game_Event.prototype.initMembers;
	Game_Event.prototype.initMembers = function () {
		_alias_Game_Event_initMembers.call(this);
		this.isPulling = false;
		this.pullingGather = false;
	}

	const _alias_Game_Event_start = Game_Event.prototype.start
	Game_Event.prototype.start = function () {
		const anySelfSwidth = ["A", "B", "C", "D"].some(c => $gameSelfSwitches.value([this._mapId, this._eventId, c]))
		if ($gameSwitches.value(pullOnSwitchId) && !anySelfSwidth && this.event() && this.event().meta &&
			(this.event().meta.canPull || this.event().meta.canPull == "")) {
			$gamePlayer.gatherFollowers();
			this.isPulling = true;
			this.pullingGather = true
			const seName = this.event().meta.canPull.toString();
			const setSeName = seName == "true" ? "" : seName;
			$gamePlayer.pullingSe = setSeName;
			return;
		}
		_alias_Game_Event_start.call(this);
	}

	const _alias_Game_Event_update = Game_Event.prototype.update;
	Game_Event.prototype.update = function () {
		if (this.isPulling) {
			if ($gamePlayer.areFollowersGathering()) { return };
			if (this.pullingGather) {
				this.prePullingMoveSpeed = [this.moveSpeed(), $gamePlayer.moveSpeed()];
				this.setMoveSpeed(pullingSpeed);
				$gamePlayer.setEventPulling(this);
				this.pullingGather = false
			}
			Game_Character.prototype.update.call(this);
			this.updatePulling();
		} else {
			_alias_Game_Event_update.call(this);
		}
	}

	Game_Event.prototype.updatePulling = function () {
		const anySelfSwidth = ["A", "B", "C", "D"].some(c => $gameSelfSwitches.value([this._mapId, this._eventId, c]))
		if (anySelfSwidth || (!this.isMoving() && !Input.isPressed('ok') && !TouchInput.isPressed())) {
			$gamePlayer.finishEventPulling(this.prePullingMoveSpeed[1]);
			this.isPulling = false;
			this.setMoveSpeed(this.prePullingMoveSpeed[0]);
		}
	}

}


code:
//=============================================================================
// RTK1_Composite.js  ver1.09 2016/07/02
//=============================================================================

/*:
 * @plugindesc Fusion items/wepons/armors.
 * @author Toshio Yamashita (yamachan)
 *
 * @param meta tag
 * @desc Meta tag name for Composition text in Note area
 * @default composite
 *
 * @param plugin command
 * @desc Base name of this plugin command
 * @default RTK1_Composite
 *
 * @param in menu
 * @desc Add Composite in menu (0:OFF 1:ON)
 * @default 0
 *
 * @help
 * This plugin requires RTK1_Core plugin previously.
 *
 * NoteTags:
 *   <composite:0.95, i1, 3, w2, 1, a3, 1, i4>
 *	0.95 means the success rate is 95%
 *	i1,3 means it require three item #1 (key material)
 *	w2,1 means it require one weapon #2
 *	a3,1 means it require one armor #3
 *	... (you can use more)
 *	i4   means If you fail, you will get item #4
 *
 * Plugin Command:
 *   RTK1_Composite menu [on off]
 *   RTK1_Composite learn item/weapon/armor #no [,#no]
 *   RTK1_Composite learn #uid[,#uid]
 *   RTK1_Composite forget item/weapon/armor #no [,#no]
 *   RTK1_Composite forget #uid [,#uid]
 *   RTK1_Composite open
 *
 *   RTK1_Composite add item/weapon/armor #no [,#no]
 *   RTK1_Composite add #uid [,#uid]
 *   RTK1_Composite remove item/weapon/armor #no [,#no]
 *   RTK1_Composite remove #uid [,#uid]
 *   RTK1_Composite fill [all/item/weapon/armor]
 *   RTK1_Composite complete [all/item/weapon/armor]
 *   RTK1_Composite clear [all/item/weapon/armor]
 *   RTK1_Composite shop [all/item/weapon/armor] [,en name] [,ja name]
 *
 */

function Scene_CompositeMenu() { this.initialize.apply(this, arguments); }
function Window_CompositeIndex() { this.initialize.apply(this, arguments); }
function Window_CompositeStatus() { this.initialize.apply(this, arguments); }
function Window_RTK_SingleCommand() { this.initialize.apply(this, arguments); }

(function (_global) {
	if (!_global["RTK"]) {
		throw new Error('This plugin requires RTK1_Core plugin previously.');
	}
	if (RTK.VERSION_NO < 1.09) {
		throw new Error('This plugin requires version 1.08 or later of RTK1_Core plugin. the current version looks ' + RTK.VERSION_NO + ".");
	}

	var N = "RTK1_Composite";
	var NK = "RTK_CP";
	var M = RTK["CP"] = RTK._modules[N] = {};

	var param = PluginManager.parameters(N);
	M._tag = String(param['meta tag'] || "composite");
	M._command = String(param['plugin command'] || "RTK1_Composite");
	M._menu = Number(param['in menu'] || "0");

	M._list = M._list || [];
	M._learn = M._learn || [];
	RTK.onReady(function () {
		RTK.text("Composite", "合成");
		RTK.text("Material", "材料");
		RTK.text("Charge", "費用");
		RTK.text("Success", "成功率");
		RTK.text("Execute", "実行");
		RTK.text("Quantity", "所持数");
		RTK.text("Composite Shop", "合成の店");
		RTK.text("Item Composite Shop", "アイテム合成の店");
		RTK.text("Weapon Composite Shop", "武器合成の店");
		RTK.text("Armor Composite Shop", "防具合成の店");
		RTK.text("Custom Composite Shop", "特別な合成の店");
		RTK.text("Get", "入手");
		RTK.log(N + " ready (__menu:" + M._menu + ")");
	});
	RTK.onLoad(function () {
		M._learn = RTK.load(NK + "_learn") || [];
		RTK.log(N + " load (_learn)", M._learn);
	});
	RTK.onSave(function () {
		RTK.save(NK + "_learn", M._learn);
		RTK.log(N + " save (_learn)", M._learn);
	});

	function filter_meta(o) { return o && o.meta && o.meta[M._tag]; };
	function _learn(_t, args, _f) {
		if (args.length == 2) {
			var a = args[1].split(",");
			for (var l = 0; l < a.length; l++) {
				var o = _f ? RTK.id2object(a[l]) : a[l];
				if (o && !_t.contains(o)) {
					_t.push(o);
				}
			}
		} else if (args.length == 3) {
			var t = args[1] == "item" ? "i" : args[1] == "weapon" ? "w" : args[1] == "armor" ? "a" : "";
			var a = args[2].split(",");
			for (var l = 0; l < a.length; l++) {
				var o = _f ? RTK.id2object(t + a[l]) : t + a[l];
				if (o && !_t.contains(o)) {
					_t.push(o);
				}
			}
		}
	};
	function _forget(_t, args, _f) {
		if (args.length == 2) {
			var a = args[1].split(",");
			for (var l = 0; l < a.length; l++) {
				if (_t.contains(a[l])) {
					_t.splice(M._learn.indexOf(a[l]), 1);
				}
			}
		} else if (args.length == 3) {
			var t = args[1] == "item" ? "i" : args[1] == "weapon" ? "w" : args[1] == "armor" ? "a" : "";
			var a = args[2].split(",");
			for (var l = 0; l < a.length; l++) {
				if (_t.contains(t + a[l])) {
					_t.splice(M._learn.indexOf(t + a[l]), 1);
				}
			}
		}
	};
	M.command = function (args) {
		if (args[0] == "learn") {
			_learn(M._learn, args);
		} else if (args[0] == "forget") {
			_forget(M._learn, args);
		} else if (args[0] == "fill") {
			var t = args[1] == "all" || !args[1] ? "item,weapon,armor" : args[1];
			var a = M._learn.filter(function (o) {
				return (t.contains("item") && o.startsWith("i")) || (t.contains("weapon") && o.startsWith("w")) || (t.contains("armor") && o.startsWith("a"));
			});
			M._list = RTK.ids2objects(a).filter(filter_meta);
		} else if (args[0] == "add") {
			_learn(M._list, args, true);
		} else if (args[0] == "remove") {
			_forget(M._list, args, true);
		} else if (args[0] == "complete") {
			M._list = [];
			var t = args[1] == "all" || !args[1] ? "item,weapon,armor" : args[1];
			if (t.contains("item")) { M._list = M._list.concat($dataItems.filter(filter_meta)); }
			if (t.contains("weapon")) { M._list = M._list.concat($dataWeapons.filter(filter_meta)); }
			if (t.contains("armor")) { M._list = M._list.concat($dataArmors.filter(filter_meta)); }
		} else if (args[0] == "clear") {
			var t = args[1] == "all" || !args[1] ? "item,weapon,armor" : args[1];
			M._list = M._list.filter(function (o) {
				return !(t.contains("item") && DataManager.isItem(o)) && !(t.contains("weapon") && DataManager.isWeapon(o)) && !(t.contains("armor") && DataManager.isArmor(o));
			});
		} else if (args[0] == "shop") {
			if (args[1] != "custom") {
				M.command(["complete", args[1]]);
			}
			if (args[2]) {
				M._Title = args[3] ? (RTK.jp() ? args[3] : args[2]) : args[2];
			} else {
				M._Title = RTK.text((args[1] == "all" || !args[1] ? "" : RTK.ucfirst(args[1], " ")) + "Composite Shop");
			}
			SceneManager.push(Scene_CompositeMenu);
		} else if (args[0] == "open") {
			M.command(["clear"]);
			M.command(["fill"]);
			if (args[1]) {
				M._Title = args[2] ? (RTK.jp() ? args[2] : args[1]) : args[1];
			} else {
				M._Title = RTK.text("Composite");
			}
			SceneManager.push(Scene_CompositeMenu);
		} else if (args[0] == "menu") {
			M._menu = args[1] == "on" ? 1 : args[1] == "off" ? 0 : M._menu;
		}
		RTK.log(N + " call (" + args.join(" ") + ")", M._learn);
	};
	RTK.onCall(M._command, M.command.bind(this));

	// ----- Menu control -----

	var _Window_MenuCommand_addOriginalCommands = Window_MenuCommand.prototype.addOriginalCommands;
	Window_MenuCommand.prototype.addOriginalCommands = function () {
		_Window_MenuCommand_addOriginalCommands.call(this)
		if (M._menu) {
			this.addCommand(RTK.text("Composite"), 'RTK_CompositeCommand', true);
		};
	};
	var _Scene_Menu_createCommandWindow = Scene_Menu.prototype.createCommandWindow;
	Scene_Menu.prototype.createCommandWindow = function () {
		_Scene_Menu_createCommandWindow.call(this);
		this._commandWindow.setHandler('RTK_CompositeCommand', this.RTK_CompositeMenu.bind(this));
	};
	Scene_Menu.prototype.RTK_CompositeMenu = function () {
		M.command(["open"]);
	};

	// ----- Scene_CompositeMenu -----

	function _composite(_i) {
		var nk = _i[NK];
		$gameParty.gainGold(- nk.charge);
		for (var l = 1; l < 6; l++) {
			var v = nk["v" + l];
			if (v) {
				$gameParty.gainItem(RTK.id2object(v[0]), - v[1]);
			}
		}
		if (Math.random() < nk.rate) {
			SoundManager.playShop();
		} else {
			SoundManager.playMiss();
			if (nk.fail == "0") {
				return null;
			} else {
				_i = RTK.id2object(nk.fail);
			}
		}
		$gameParty.gainItem(_i, 1);
		return _i;
	}

	Scene_CompositeMenu.prototype = Object.create(Scene_MenuBase.prototype);
	Scene_CompositeMenu.prototype.constructor = Scene_CompositeMenu;
	Scene_CompositeMenu.prototype.initialize = function () { Scene_MenuBase.prototype.initialize.call(this); };

	Scene_CompositeMenu.prototype.create = function () {
		Scene_MenuBase.prototype.create.call(this);

		this._goldWindow = new Window_Gold();
		this._goldWindow.move(Graphics.boxWidth - this._goldWindow.width, 0, this._goldWindow.width, this._goldWindow.height);
		this.addWindow(this._goldWindow);

		this._helpWindow = new Window_Help(1);
		this._helpWindow.move(0, 0, Graphics.boxWidth - this._goldWindow.width, this._helpWindow.height);
		this._helpWindow.setText(M._Title || RTK.text("Composite"));
		this.addWindow(this._helpWindow);

		this._indexWindow = new Window_CompositeIndex(0, this._helpWindow.height);
		this._indexWindow.setHandler('ok', function () {
			if (this._exeWindow.getState()) {
				Window_CompositeIndex.lastTopRow = this._indexWindow.topRow();
				Window_CompositeIndex.lastIndex = this._indexWindow.index();
				Window_CompositeIndex.maxItems = this._indexWindow.maxItems();
				this._indexWindow.deselect();
				this._indexWindow.deactivate();
				this._exeWindow.activate();
				this._exeWindow.select(0);
			} else {
				this._indexWindow.activate();
			}
		}.bind(this));
		this._indexWindow.setHandler('cancel', this.popScene.bind(this));

		var wy = this._helpWindow.height + this._indexWindow.height;
		var ww = Graphics.boxWidth;
		var wh = Graphics.boxHeight - wy;
		this._statusWindow = new Window_CompositeStatus(0, wy, ww, wh);

		this._exeWindow = new Window_RTK_SingleCommand(0, 0, 1, [RTK.text("Execute")]);
		this._exeWindow.move(Graphics.boxWidth - 145 - this._exeWindow.textPadding(), Graphics.boxHeight - this._exeWindow.height - this._exeWindow.textPadding(), 145, this._exeWindow.height);
		this._exeWindow._funcOkSound = function () { };
		this._exeWindow.setHandler('cancel', function () {
			this._exeWindow.deselect();
			this._exeWindow.deactivate();
			this._indexWindow.activate();
		}.bind(this));
		this._exeWindow.setHandler('ok', function () {
			this._exeWindow.deselect();
			this._exeWindow.deactivate();
			var i = _composite(this._statusWindow._item);
			var it = i ? ("  \\I[" + i.iconIndex + "]" + i.name) : "";
			this._resultWindow._items = ["\\C[16]" + RTK.text("Get") + ":", "", it, ""];
			this._resultWindow.show();
			this._resultWindow.activate();
			this._resultWindow.select(1);
			this._resultWindow.setState(true);
		}.bind(this));
		this._statusWindow._exeWindow = this._exeWindow;

		this.addWindow(this._indexWindow);
		this.addWindow(this._statusWindow);
		this.addWindow(this._exeWindow);
		this._indexWindow.setStatusWindow(this._statusWindow);

		this._resultWindow = new Window_RTK_SingleCommand(0, 0, 4, ["", "", "DONE", ""]);
		this._resultWindow.move(Graphics.boxWidth / 4, Graphics.boxHeight * 0.42, Graphics.boxWidth / 2, this._resultWindow.height);
		this._resultWindow.hide();
		this._resultWindow._hideCursor = true;
		this._resultWindow.setHandler('ok', function () {
			SceneManager.goto(Scene_CompositeMenu);
		});
		this._resultWindow.setHandler('cancel', function () {
			SceneManager.goto(Scene_CompositeMenu);
		});
		this.addWindow(this._resultWindow);
	};

	// ----- Window_CompositeIndex -----

	Window_CompositeIndex.prototype = Object.create(Window_Selectable.prototype);
	Window_CompositeIndex.prototype.constructor = Window_CompositeIndex;
	Window_CompositeIndex.lastTopRow = 0;
	Window_CompositeIndex.lastIndex = 0;
	Window_CompositeIndex.maxItems = 0;

	Window_CompositeIndex.prototype.initialize = function (x, y, cols, rows) {
		Window_Selectable.prototype.initialize.call(this, x || 0, y || 0, Graphics.boxWidth, this.fittingHeight(rows || 6));
		this._maxCols = cols || 3;
		this.refresh();
		if (Window_CompositeIndex.maxItems == this.maxItems()) {
			this.setTopRow(Window_CompositeIndex.lastTopRow);
			this.select(Window_CompositeIndex.lastIndex);
		} else {
			this.setTopRow(0);
			this.select(0);
		}
		this.activate();
	};
	Window_CompositeIndex.prototype.maxCols = function () {
		return this._maxCols || 3;
	};
	Window_CompositeIndex.prototype.maxItems = function () {
		return M._list ? M._list.length : 0;
	};
	Window_CompositeIndex.prototype.setStatusWindow = function (statusWindow) {
		this._statusWindow = statusWindow;
		this.updateStatus();
	};
	Window_CompositeIndex.prototype.update = function () {
		Window_Selectable.prototype.update.call(this);
		this.updateStatus();
	};
	Window_CompositeIndex.prototype.updateStatus = function () {
		var item = M._list[this.index()];
		this._currentEnabled = filter_meta(item) && item[NK] && item[NK].f;
		if (this._statusWindow) {
			this._statusWindow.setItem(item);
		}
	};
	Window_CompositeIndex.prototype.refresh = function () {
		this.createContents();
		this.drawAllItems();
	};
	Window_CompositeIndex.prototype.drawItem = function (index) {
		var item = M._list[index];
		var rect = this.itemRect(index);
		var width = rect.width - this.textPadding();

		item[NK] = null;
		var f = filter_meta(item);
		if (f) {
			var a = item.meta[M._tag].split(",");
			if (a.length > 4) {
				var b = item[NK] = {};
				b["rate"] = Number(a[0]);
				for (var l = 2; l < a.length - 2; l += 2) {
					var n = Number(a[l]);
					var k = "v" + String(l / 2);
					b[k] = [a[l - 1], n, RTK.hasId(a[l - 1], n)];
					f = f && b[k][2] >= b[k][1];
				}
				b["fail"] = a[a.length - 2] || "0";
				b["charge"] = Number(a[a.length - 1] || "0");
				f = f && $gameParty.gold() >= b["charge"];
				b["f"] = f;
			} else {
				f = false;
			}
		}
		if (f) {
			this.drawItemName(item, rect.x, rect.y, width);
		} else {
			this.changePaintOpacity(false);
			this.drawItemName(item, rect.x, rect.y, width);
			this.changePaintOpacity(true);
		}
	};
	Window_CompositeIndex.prototype.processCancel = function () {
		Window_Selectable.prototype.processCancel.call(this);
		Window_CompositeIndex.lastTopRow = this.topRow();
		Window_CompositeIndex.lastIndex = this.index();
		Window_CompositeIndex.maxItems = this.maxItems();
	};
	Window_CompositeIndex.prototype.isCurrentItemEnabled = function () {
		return this._currentEnabled;
	};

	// ----- Window_CompositeStatus -----

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

	Window_CompositeStatus.prototype.initialize = function (x, y, width, height) {
		Window_Base.prototype.initialize.call(this, x, y, width, height);
	};
	Window_CompositeStatus.prototype.setItem = function (item) {
		if (item && this._item !== item) {
			this._item = item;
			this.refresh();
		}
	};
	Window_CompositeStatus.prototype.refresh = function () {
		var item = this._item;
		var x = this.textPadding() + Graphics.boxWidth / 3;
		var y = this.textPadding();
		var lineHeight = this.lineHeight();
		this.contents.clear();

		if (!item[NK].f) { this.changePaintOpacity(false); }
		this.drawItemName(item, 0, y);
		this.changePaintOpacity(true);

		if (item[NK]) {
			this.changeTextColor(this.systemColor());
			this.drawText(RTK.text("Material") + ":", x * 0.9, y, 120);
			this.resetTextColor();
			y += lineHeight;

			if (item[NK].v1[2] < item[NK].v1[1]) { this.changePaintOpacity(false); }
			this.drawItemName(RTK.id2object(item[NK].v1[0]), x, y);
			this.drawText((item[NK].v1[2] ? item[NK].v1[2] : RTK.hasId(item[NK].v1[0])) + "/" + item[NK].v1[1], x * 2, y, 60, 'right');
			y += lineHeight;
			this.changePaintOpacity(true);

			var price = item[NK].charge > 0 ? item[NK].charge : '-';
			if (price != "-" && $gameParty.gold() < price) { this.changePaintOpacity(false); }
			this.changeTextColor(this.systemColor());
			this.drawText(RTK.text("Charge") + ":", this.textPadding(), y, 120);
			this.resetTextColor();
			this.drawText(price, this.textPadding() + 50, y, 120, 'right');
			this.changePaintOpacity(true);

			if (item[NK].v2) {
				if (item[NK].v2[2] < item[NK].v2[1]) { this.changePaintOpacity(false); }
				this.drawItemName(RTK.id2object(item[NK].v2[0]), x, y);
				this.drawText((item[NK].v2[2] ? item[NK].v2[2] : RTK.hasId(item[NK].v2[0])) + "/" + item[NK].v2[1], x * 2, y, 60, 'right');
				this.changePaintOpacity(true);
			}
			y += lineHeight;

			this.changeTextColor(this.systemColor());
			this.drawText(RTK.text("Success") + ":", this.textPadding(), y, 120);
			this.resetTextColor();
			this.drawText(Math.floor(item[NK].rate * 100) + "%", this.textPadding() + 50, y, 120, 'right');

			if (item[NK].v3) {
				if (item[NK].v3[2] < item[NK].v3[1]) { this.changePaintOpacity(false); }
				this.drawItemName(RTK.id2object(item[NK].v3[0]), x, y);
				this.drawText((item[NK].v3[2] ? item[NK].v3[2] : RTK.hasId(item[NK].v3[0])) + "/" + item[NK].v3[1], x * 2, y, 60, 'right');
				this.changePaintOpacity(true);
			}
			y += lineHeight;

			this.changeTextColor(this.systemColor());
			this.drawText(RTK.text("Quantity") + ":", this.textPadding(), y, 120);
			this.resetTextColor();
			this.drawText(RTK.hasId(RTK.object2id(item)), this.textPadding() + 50, y, 120, 'right');

			if (item[NK].v4) {
				if (item[NK].v4[2] < item[NK].v4[1]) { this.changePaintOpacity(false); }
				this.drawItemName(RTK.id2object(item[NK].v4[0]), x, y);
				this.drawText((item[NK].v4[2] ? item[NK].v4[2] : RTK.hasId(item[NK].v4[0])) + "/" + item[NK].v4[1], x * 2, y, 60, 'right');
				this.changePaintOpacity(true);
			}
			y += lineHeight;

			if (item[NK].v5) {
				if (item[NK].v5[2] < item[NK].v5[1]) { this.changePaintOpacity(false); }
				this.drawItemName(RTK.id2object(item[NK].v5[0]), x, y);
				this.drawText((item[NK].v5[2] ? item[NK].v5[2] : RTK.hasId(item[NK].v5[0])) + "/" + item[NK].v5[1], x * 2, y, 60, 'right');
				this.changePaintOpacity(true);
			}

			y = this.textPadding() * 2 + lineHeight * 6;
			if (!item[NK].f) { this.changePaintOpacity(false); }
			this.drawTextEx(item.description, 0, y);
			this.changePaintOpacity(true);
		}
		this._exeWindow.setState(item[NK] && item[NK].f);
	};

	// ----- Window_RTK_SingleCommand -----

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

	Window_RTK_SingleCommand.prototype.initialize = function (x, y, line, items) {
		this._line = line || 1;
		this._items = items || ["OK"];
		Window_Selectable.prototype.initialize.call(this, x || 0, y || 0, Graphics.boxWidth, this.fittingHeight(line));
		this.refresh();
		this.setTopRow(0);
		this.select(0);
		this.deselect();
		this.deactivate();
	};
	Window_RTK_SingleCommand.prototype.maxCols = function () { return 1; };
	Window_RTK_SingleCommand.prototype.maxItems = function () { return this._line; };
	Window_RTK_SingleCommand.prototype.refresh = function () {
		this.createContents();
		this.drawAllItems();
	};
	Window_RTK_SingleCommand.prototype.drawItem = function (index) {
		var rect = this.itemRect(index);
		var width = rect.width - this.textPadding();
		if (this._displayState) {
			this.drawTextEx(this._items[index], rect.x, rect.y, width);
		} else {
			this.changePaintOpacity(false);
			this.drawTextEx(this._items[index], rect.x, rect.y, width);
			this.changePaintOpacity(true);
		}
	};
	Window_RTK_SingleCommand.prototype.setState = function (_f) {
		this._displayState = _f;
		this.refresh();
	};
	Window_RTK_SingleCommand.prototype.getState = function () {
		return this._displayState;
	};
	Window_RTK_SingleCommand.prototype.updateCursor = function () {
		if (this._hideCursor) {
			this.setCursorRect(0, 0, 0, 0);
		} else {
			Window_Selectable.prototype.updateCursor.call(this);
		}
	};
	Window_RTK_SingleCommand.prototype.playOkSound = function () {
		if (this._funcOkSound) {
			this._funcOkSound();
		} else {
			Window_Selectable.prototype.playOkSound.call(this);
		}
	};

})(this);

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// RTK_EnemySight.js  ver1.00 2016/07/02
//=============================================================================

/*:
 * @plugindesc Set switch when map event see the player
 * @author Toshio Yamashita (yamachan)
 *
 * @param tag name
 * @desc Tag name used in Event's note.
 * @default sight
 *
 * @help This plugin does not provide plugin commands.
 *
 * Event Note:
 *   <sight:n,s>	# Switch s is ON when event see player within n
 *			# n : eyeshot max (# of Tiles)
 *			# s : A-D (self switch), 1-999 (switch)
 */

/*:ja
 * @plugindesc マップでイベントがプレイヤーを見かけるとスイッチをON
 * @author Toshio Yamashita (yamachan)
 *
 * @param tag name
 * @desc イベントのメモ欄で使用するタグ名
 * @default sight
 *
 * @help このプラグインにはプラグインコマンドはありません。
 *
 * イベントのメモ:
 *   <sight:n,s>	# 距離n以内にプレイヤーを発見するとsスイッチがON
 *			# n : 距離 (タイル単位)
 *			# s : A-D (セルフスイッチ), 1-999 (スイッチ)
 */

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

(function (_global) {
	var N = 'RTK_Test';

	var param = PluginManager.parameters(N);
	var tag_name = param['tag name'] || "sight";

	var _Game_Event_updateSelfMovement = Game_Event.prototype.updateSelfMovement;
	Game_Event.prototype.updateSelfMovement = function () {
		_Game_Event_updateSelfMovement.call(this);

		function _f(_d) {
			switch (this._directionFix ? this._originalDirection : this._direction) {
				case 2: // down
					if (this.x == $gamePlayer.x && this.y < $gamePlayer.y && $gamePlayer.y - this.y <= _d) {
						return true;
					}
					break;
				case 4: // left
					if (this.y == $gamePlayer.y && $gamePlayer.x < this.x && this.x - $gamePlayer.x <= _d) {
						return true;
					}
					break;
				case 6: // right
					if (this.y == $gamePlayer.y && this.x < $gamePlayer.x && $gamePlayer.x - this.x <= _d) {
						return true;
					}
					break;
				case 8: // up
					if (this.x == $gamePlayer.x && this.y > $gamePlayer.y && this.y - $gamePlayer.y <= _d) {
						return true;
					}
					break;
			};
			return false;
		};

		var m = this.event().meta[tag_name];
		if (m) {
			var r = m.match(/\s*(\d+),\s*([A-D])\s*/);
			if (r) {
				var k = [this._mapId, this._eventId, r[2]];
				if (!$gameSelfSwitches._data[k]) {
					r = _f.call(this, Number(r[1]));
					if (r) {
						$gameSelfSwitches.setValue(k, r);
					}
				}
				return;
			}
			r = m.match(/\s*(\d+),\s*(\d+)\s*/);
			if (r) {
				var k = Number(r[2]);
				if (!$gameSwitches.value(k)) {
					r = _f.call(this, Number(r[1]));
					if (r) {
						$gameSwitches.setValue(k, r);
					}
				}
			}
		}
	};

})(this);


code:
//=============================================================================
// Plugin_Name : RX_T_Change_BattleBackEX(MV/MZ)
// File_Name   : RX_T_Change_BattleBackEX.js
// Version     : 1.00
// Copylight   : 2015,2020 TYPE74RX-T
//=============================================================================

//=============================================================================
/*:
 * @target MV MZ
 * @plugindesc The event command "Change Battle Back" will be available during battle.
 * @author TYPE74RX-T
 * @url https://w.atwiki.jp/type74rx-t/pages/221.html
 *
 * @command RememberBattleBack
 * @text Battle Back Memory and Restoration
 * @desc You can remember or restore the current battle background state.
 * @arg Mode
 * @text Battle Back Processing
 * @desc Choose whether you want the current battle background state to be remembered or restored.
 * @default remember
 * @type select
 * @option 1.Remember
 * @value remember
 * @option 2.Recovery
 * @value recovery
 *
 * @help Change Battle Back EX（MV/MZ）
 *
 * This plugin is compatible with RPG Maker MV and RPG Maker MZ.
 *
 * ◆Summary
 * The event command "Change Battle Back" will be available during battle.
 * It is possible to also memorize the currently set battle background or
 * restore a memorized battle background.
 *
 * ◆How to use "Battle Back Memory and Restoration"
 * The settings are different between the MV and MZ versions.
 *
 * ★Usage in the MZ version
 * Plugin file: RX_T_Change_BattleBackEX
 *
 * 【Battle Back Processing】
 * It is possible to choose to have it remember or restore.
 *
 * ★Usage in the MV version
 * Use the plugin command to configure it as follows.
 *
 * battleback 0
 *
 * Here's what process you'll find below in which settings.
 * For example, if it is marked "Remember:0, remember"
 *
 * motion 0
 * motion remember
 *
 * All of these commands will have the same meaning, so enter the one
 * you feel comfortable typing.
 *
 * 【List of Plug-in Commands for MV】
 * Remember:0, remember
 * Recovery:1, recovery
 *
 * ◆License
 * This plugin is released under MIT license.
 * http://opensource.org/licenses/mit-license.php
*/
/*:ja
 * @target MV MZ
 * @plugindesc イベントコマンド「戦闘背景の変更」を戦闘中でも行えるようになります。
 * @author TYPE74RX-T
 * @url https://mdc-light.jpn.org/TYPE74RX-T/
 *
 * @command RememberBattleBack
 * @text 戦闘背景の記憶と復帰
 * @desc 現在の戦闘背景の状態を
 * 記憶させたり復帰させたりできます。
 * @arg Mode
 * @text 戦闘背景の処理
 * @desc 現在の戦闘背景の状態を
 * 記憶させるか復帰させるかを選択してください。
 * @default remember
 * @type select
 * @option 1.記憶させる
 * @value remember
 * @option 2.復帰させる
 * @value recovery
 *
 * @help 戦闘背景の変更EX（MV/MZ）
 *
 * このプラグインはRPGツクールMV、RPGツクールMZに対応しています。
 *
 * ◆概要
 * イベントコマンド「戦闘背景の変更」を戦闘中でも行えるようになります。
 * また、設定されている戦闘背景を記憶させたり、記憶させていた戦闘背景を
 * 復帰させることもできます。
 *
 * ◆使い方
 * MV版とMZ版で設定方法が異なります。
 *
 * ★MZ版
 * プラグインファイル：RX_T_Change_BattleBackEX
 *
 * 【戦闘背景の処理】
 * 記憶させるか復帰させるか選択してください。
 *
 * ★MV版
 * プラグインコマンドで以下の要領で設定します。
 *
 * battleback 0
 *
 * どの設定でどんな処理をするのかを下記に紹介します。
 * 例えば「記憶：0, remember, 記憶」と表記されている場合
 *
 * motion 0
 * motion remember
 * motion 記憶
 *
 * これらはどれも同じ意味のコマンドになるので、入力しやすいと思ったものを
 * 入力してください。
 *
 * 【MV版プラグインコマンド一覧】
 * 記憶：0, remember, 記憶
 * 復帰：1, recovery, 復帰
 *
 * ◆ライセンス
 * このプラグインはMITライセンスで公開されています。
 * http://opensource.org/licenses/mit-license.php
*/
(() => {
	'use strict';

	//Game_Temp

	const rx_t_gtp151026_initialize = Game_Temp.prototype.initialize;
	Game_Temp.prototype.initialize = function () {
		rx_t_gtp151026_initialize.call(this);
		this._rx_changeBatBack_in_battle = false;
	};

	//Game_Map

	const rx_t_gmpp151026_changeBattleback = Game_Map.prototype.changeBattleback;
	Game_Map.prototype.changeBattleback = function (battleback1Name, battleback2Name) {
		rx_t_gmpp151026_changeBattleback.call(this, battleback1Name, battleback2Name);
		if (BattleManager.isBattleTest()) {
			$dataSystem.battleback1Name = battleback1Name;
			$dataSystem.battleback2Name = battleback2Name;
		}
		if ($gameParty.inBattle() && !$gameTemp._rx_changeBatBack_in_battle) {
			$gameTemp._rx_changeBatBack_in_battle = true;
		}
	};

	//Spriteset_battle

	const rx_t_spbp151026_updateBattleback = Spriteset_Battle.prototype.updateBattleback;
	Spriteset_Battle.prototype.updateBattleback = function () {
		rx_t_spbp151026_updateBattleback.call(this);
		if ($gameParty.inBattle() && $gameTemp._rx_changeBatBack_in_battle) {
			$gameTemp._rx_changeBatBack_in_battle = false;
			this._back1Sprite.bitmap = this.battleback1Bitmap();
			this._back2Sprite.bitmap = this.battleback2Bitmap();
		}
	};

	//for MZ
	if (PluginManager._commands !== undefined) {
		//PluginManager
		PluginManager.registerCommand("RX_T_Change_BattleBackEX", "RememberBattleBack", args => {
			const rx_recBatBakCmd = args.Mode === "remember" ? 0 : 1;
			if (rx_recBatBakCmd === 0) {
				$gamePlayer._rx_remBattleBack1Name = $gameMap.battleback1Name();
				$gamePlayer._rx_remBattleBack2Name = $gameMap.battleback2Name();
				if (BattleManager.isBattleTest()) {
					$gamePlayer._rx_remBattleBack1Name = $dataSystem.battleback1Name;
					$gamePlayer._rx_remBattleBack2Name = $dataSystem.battleback2Name;
				}
			}
			if (rx_recBatBakCmd === 1) {
				$gameMap._battleback1Name = $gamePlayer._rx_remBattleBack1Name;
				$gameMap._battleback2Name = $gamePlayer._rx_remBattleBack2Name;
				if (BattleManager.isBattleTest()) {
					$dataSystem.battleback1Name = $gamePlayer._rx_remBattleBack1Name;
					$dataSystem.battleback2Name = $gamePlayer._rx_remBattleBack2Name;
				}
				if ($gameParty.inBattle() && !$gameTemp._rx_changeBatBack_in_battle) {
					$gameTemp._rx_changeBatBack_in_battle = true;
				}
			}
		});

		//Speiteset_Battle
		Spriteset_Battle.prototype.battleback1Bitmap = function () {
			return this._back1Sprite.battleback1Bitmap();
		};

		Spriteset_Battle.prototype.battleback2Bitmap = function () {
			return this._back1Sprite.battleback2Bitmap();
		};
	} else {
		//Game_Interpreter
		const rx_t_gipc200911_pluginCommand = Game_Interpreter.prototype.pluginCommand;
		Game_Interpreter.prototype.pluginCommand = function (command, args) {
			rx_t_gipc200911_pluginCommand.call(this, command, args);
			if (command === 'battleback') {
				switch (args[0]) {
					case '0': case 'remember': case '記憶':
						$gamePlayer._rx_remBattleBack1Name = $gameMap.battleback1Name();
						$gamePlayer._rx_remBattleBack2Name = $gameMap.battleback2Name();
						if (BattleManager.isBattleTest()) {
							$gamePlayer._rx_remBattleBack1Name = $dataSystem.battleback1Name;
							$gamePlayer._rx_remBattleBack2Name = $dataSystem.battleback2Name;
						}
						break;
					case '1': case 'recovery': case '復帰':
						$gameMap._battleback1Name = $gamePlayer._rx_remBattleBack1Name;
						$gameMap._battleback2Name = $gamePlayer._rx_remBattleBack2Name;
						if (BattleManager.isBattleTest()) {
							$dataSystem.battleback1Name = $gamePlayer._rx_remBattleBack1Name;
							$dataSystem.battleback2Name = $gamePlayer._rx_remBattleBack2Name;
						}
						if ($gameParty.inBattle() && !$gameTemp._rx_changeBatBack_in_battle) {
							$gameTemp._rx_changeBatBack_in_battle = true;
						}
						break;
				}
			}
		};
	}
})();


code:
//
//  イベントランダム配置 ver1.03
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported['RandomEventSet'] = 1.03;

/*:
 * @plugindesc ver1.03/場所移動時等にイベントの位置をランダムに移動します。
 * @author Yana
 *
 * @param RandomSetSwitchID
 * @desc このIDのスイッチをONにして、場所移動を行うことで、
 * ランダム配置のイベントをランダムな位置に移動します。
 * @default 21
 * @type switch
 *
 * @param RegionSetSwitchID
 * @desc このIDのスイッチをONにして、場所移動を行うことで、
 * ランダムリージョンのイベントをランダムな位置に移動します。
 * @default 22
 * @type switch
 *
 * @param Init Transfer
 * @desc このIDのスイッチをONにして、場所移動を行うことで、
 * ランダム場所記録用のキャッシュを初期化します。
 * @default 23
 * @type switch
 *
 * @param RandomSetKey
 * @desc ランダム移動に使用するキーワードです。
 * このキーワードがメモに含まれるイベントがランダム移動の対象になります。
 * @default <ランダム移動>
 *
 * @param RegionSetKey
 * @desc ランダムリージョン移動に使用するキーワードです。
 * このキーワードがメモに含まれるイベントがリージョン移動の対象になります。
 * @default <ランダムリージョン:(\d+)>
 *
 * @help------------------------------------------------------
 *  プラグインコマンド
 * ------------------------------------------------------
 * ※スペースは必ず半角で入力してください。
 *
 * ・ランダム移動に設定されたイベントをランダムな位置に移動します。
 * RandomSet
 *
 * ・ランダムリージョンに設定されたイベントをランダムな位置に移動します。
 * RegionSet
 *
 * ------------------------------------------------------
 * 設定方法
 * ------------------------------------------------------
 * イベントのメモ欄に
 * <ランダム配置>
 * または、
 * <ランダムリージョン:x>
 * と記述します。
 *
 * 以上の記述が設定されたイベントはランダム移動を行うプラグインコマンドか、
 * 対象のスイッチをONにした状態で場所移動を行うと、ランダムな位置に移動します。
 * ランダムリージョンの場合は、xで指定したリージョンIDのタイルのいずれかに移動します。
 *
 * ***キャッシュの初期化について***
 * このプラグインは、イベントの位置を再現するため、セーブデータにイベントの位置を記録しています。
 * これをキャッシュと呼び、複数の場所でこのプラグインを使ってランダム移動を行うことで、
 * このキャッシュが大きくなってしまいます。
 * そのため、セーブデータの肥大化などを防ぐため、
 * 特定のタイミングでInitTransferで設定されているスイッチをONにして、キャッシュを初期化してください。
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.03:180917
 * キャッシュに関する説明を追加。
 * ver1.021:180410
 * プラグインパラメータの仕様を1.5.0に更新。
 * ver1.02:
 * エラーが発生することのあるバグを修正。
 * ver1.01:
 * キャッシュを初期化する機能が正常に動作していなかったバグを修正
 * ver1.00:
 * 公開
 */

(function () {

    var parameters = PluginManager.parameters('RandomEventSet');
    var randomSetSwitchId = Number(parameters['RandomSetSwitchID'] || 21);
    var regionSetSwitchId = Number(parameters['RegionSetSwitchID'] || 22);
    var initTransfer = Number(parameters['InitTransfer'] || 23);

    var randomSetKey = RegExp(parameters['RandomSetKey'] || '<ランダム配置>');
    var regionSetKey = RegExp(parameters['RegionSetKey'] || '<ランダムリージョン:(\\d+)>');

    var _rSet_GInterpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _rSet_GInterpreter_pluginCommand.call(this, command, args);
        if (command === 'RandomSet') {
            this.randomSettingAtAll();
        } else if (command === 'RegionSet') {
            this.randomSettingAtRegion();
        }
    };

    function RandomSetManager() {
        throw new Error('This is a static class');
    };

    RandomSetManager.randomSettingAtAll = function () {
        var events = $gameMap.events();
        for (var i = 0; i < events.length; i++) {
            var e = events[i];
            if (e.event().note.match(randomSetKey)) {
                var x = Math.randomInt($gameMap.width());
                var y = Math.randomInt($gameMap.height());
                while ($gameMap.eventsXy(x, y).length > 0 || !$gameMap.isPassable(x, y, 2)) {
                    x = Math.randomInt($gameMap.width());
                    y = Math.randomInt($gameMap.height());
                }
                this.initCheckRegionArray();
                $gameSystem._regionArray[$gameMap.mapId()][e.eventId()] = [e.eventId(), 0, x, y, 0];
                e.locate(x, y);
            }
        }
    };

    RandomSetManager.randomSettingAtRegion = function () {
        this.clearRegionArray();
        var events = $gameMap.events();
        for (var i = 0; i < events.length; i++) {
            var e = events[i];
            if (e.event().note.match(regionSetKey)) { e.locate(-1, -1) }
        }

        for (var i = 0; i < events.length; i++) {
            var e = events[i];
            if (e.event().note.match(regionSetKey)) {
                var region = Number(RegExp.$1);
                if (this.isCheckExistRegion(region)) {
                    if (!this._regionArray[region]) {
                        this._regionArray[region] = this.makeRegionArray(region);
                    }
                    var l = this._regionArray[region].length;
                    var rn = Math.randomInt(l);
                    var r = this._regionArray[region].splice(rn, 1)[0];
                    while (!r || $gameMap.eventsXy(r[0], r[1]).length > 0) {
                        r = this._regionArray[region].splice(Math.randomInt(l), 1)[0];
                    }
                    this.initCheckRegionArray();
                    $gameSystem._regionArray[$gameMap.mapId()][e.eventId()] = [e.eventId(), 0, r[0], r[1], 0];
                    e.locate(r[0], r[1]);
                }
            }

        }
    };

    RandomSetManager.clearRegionArray = function () {
        this._regionArray = {};
    };

    RandomSetManager.isCheckExistRegion = function (regionId) {
        if (this._existRegion === undefined) { this._existRegion = [] }
        if (this._existRegion.contains(regionId)) { return true }
        for (var iy = 0; iy < $gameMap.height(); iy++) {
            for (var jx = 0; jx < $gameMap.width(); jx++) {
                if ($gameMap.regionId(jx, iy) === regionId) {
                    this._existRegion.push(regionId);
                    return true;
                }
            }
        }
        return false;
    };

    RandomSetManager.makeRegionArray = function (regionId) {
        var result = new Array();
        for (var iy = 0; iy < $gameMap.height(); iy++) {
            for (var jx = 0; jx < $gameMap.width(); jx++) {
                if ($gameMap.regionId(jx, iy) === regionId) { result.push([jx, iy]) }
            }
        }
        return result;
    };

    RandomSetManager.initCheckRegionArray = function () {
        if ($gameSystem._regionArray === undefined) { $gameSystem._regionArray = {} }
        if ($gameSystem._regionArray[$gameMap.mapId()] === undefined) {
            $gameSystem._regionArray[$gameMap.mapId()] = {};
        }
    };

    Game_Interpreter.prototype.randomSettingAtAll = function () {
        RandomSetManager.randomSettingAtAll();
    };

    Game_Interpreter.prototype.randomSettingAtRegion = function () {
        RandomSetManager.randomSettingAtRegion();
    };

    var _RSE_GPlayer_performTransfer = Game_Player.prototype.performTransfer;
    Game_Player.prototype.performTransfer = function () {
        if ($gameSwitches.value(initTransfer)) { $gameSystem.clearRegionArray() }
        if ($gameMap.mapId() === this._newMapId && this.isTransferring()) {
            if ($gameSwitches.value(randomSetSwitchId)) { RandomSetManager.randomSettingAtAll() }
            if ($gameSwitches.value(regionSetSwitchId)) { RandomSetManager.randomSettingAtRegion() }
            $gameSwitches.setValue(randomSetSwitchId, false);
            $gameSwitches.setValue(regionSetSwitchId, false);
        }
        _RSE_GPlayer_performTransfer.call(this);
    };

    Game_System.prototype.clearRegionArray = function () {
        this._regionArray = undefined;
    };

    Game_System.prototype.initRegionArray = function () {
        if (this._regionArray === undefined) { this._regionArray = {} }
    }

    Game_System.prototype.setInitRegionArray = function (mapId) {
        if (this._regionArray === undefined) { this.initRegionArray() }
        if (this._regionArray[mapId] === undefined) { this._regionArray[mapId] = {} }
    };

    var _RSE_GMap_setupEvents = Game_Map.prototype.setupEvents;
    Game_Map.prototype.setupEvents = function () {
        _RSE_GMap_setupEvents.call(this);

        $gameSystem.setInitRegionArray(this.mapId());
        if ($gameSwitches.value(randomSetSwitchId)) { RandomSetManager.randomSettingAtAll() }
        if ($gameSwitches.value(regionSetSwitchId)) { RandomSetManager.randomSettingAtRegion() }
        var events = this.events();
        for (key in $gameSystem._regionArray[this.mapId()]) {
            var value = $gameSystem._regionArray[this.mapId()][key];
            if (!value) { continue }
            for (var i = 0; i < events.length; i++) {
                if (events[i].eventId() == key) {
                    events[i].locate(value[2], value[3]);
                }
            }
        }
        $gameSwitches.setValue(randomSetSwitchId, false);
        $gameSwitches.setValue(regionSetSwitchId, false);
    };
}());


code:
//=============================================================================
// 【常駐ウィンドウ】　Version: 1.21
//
// ※ 当ブログの常駐所持金ウィンドウ（ResidentGoldWindow.js）はこのスクリプトに統合されました。
// 　 既に使用されている方はそのプラグインを消去した上で本プラグインを導入して下さい。
//
// ここからリスポーン: http://respawnfromhere.blog.fc2.com/
// Twitter: https://twitter.com/ibakip
//
//=============================================================================

//=============================================================================
/*:
* @plugindesc マップに常駐するステータス＋所持金ウィンドウを生成します。
* @author ResidentWindow
*
* //---↓全体管理-------------------------------------------
*
* @param StartWithHideWindow
* @desc ニューゲーム時、常駐ウィンドウが非表示状態で開始されます。
* true を入力すると有効になります。
* @default false
*
* @param FaceWindow_ON
* @desc 顔グラウィンドウを使用する場合は true を指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* @param StatusWindow_ON
* @desc ステータスウィンドウを使用する場合は true を指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* @param GoldWindow_ON
* @desc 所持金ウィンドウを使用する場合は true を指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* //-----------------------------------------------------
*
* //---↓顔グラウィンドウ-------------------------------------
*
* @param FaceWindow_x
* @desc 顔グラを表示するx座標です。
* @default 10
*
* @param FaceWindow_y
* @desc 顔グラを表示するy座標です。
* @default 10
*
* @param FaceWindow_type
* @desc 顔グラウィンドウのタイプを選択します。
* 0：通常 1：黒背景 2:透明
* @default 2
*
* @param FaceFrame_ON
* @desc 顔グラをフレーム画像で装飾する場合はtrueを指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* //--------------------------------------------------------
*
* //---↓ステータスウィンドウ-------------------------------------
*
* @param StatusWindow_x
* @desc ステータスを表示するx座標です。
* @default 196
*
* @param StatusWindow_y
* @desc ステータスを表示するy座標です。
* @default 20
*
* @param StatusWindow_type
* @desc ステータスウィンドウのタイプを選択します。
* 0：通常 1：黒背景 2:透明
* @default 2
*
* @param GaugeFrame_ON
* @desc HP等のゲージにフレーム画像を使う場合はtrueを指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* @param StatusWindow_PaddingHeight
* @desc 各ステータスゲージの間隔を指定します。
* 値を大きくするほどゲージが離れます。
* @default 10
*
* @param TP_Gauge_ON
* @desc TPゲージを描画する場合は true を指定して下さい。
* （※使用しない場合は false か空文字を指定）
* @default true
*
* //--------------------------------------------------------
*
* //---↓所持金ウィンドウ-------------------------------------
*
* @param GoldWindow_x
* @desc 所持金ウィンドウを表示するx座標です。
* @default 576
*
* @param GoldWindow_y
* @desc 所持金ウィンドウを表示するy座標です。
* @default 550
*
* @param GoldWindow_type
* @desc 所持金ウィンドウのタイプを選択します。
* 0：通常 1：黒背景 2:透明 3:画像
* @default 3
*
* @param GoldWindow_width
* @desc 所持金ウィンドウの横幅です。
* Gold_Window_typeで 3 を指定した場合は無視されます。
* @default 240
*
* @param GoldWindow_height
* @desc 所持金ウィンドウの縦幅です。
* Gold_Window_typeで 3 を指定した場合は無視されます。
* @default 60
*
* @param GoldWindow_IconNumber
* @desc 所持金ウィンドウに描画するアイコンを選択します。
* 0 を指定するとアイコンは使わず単位を描画します。
* @default 314
*
* @param GoldWindow_PaddingWidth
* @desc 所持金ウィンドウ内の横方向の余白を調整します。
* 値を大きくするほど描画内容が内側に寄ります。
* @default 10
*
* //--------------------------------------------------------
*
* @help
*
* //=============================================================================
* // 【常駐ウィンドウ】　Version: 1.21
* //
* // ※ 当ブログの常駐所持金ウィンドウ（ResidentGoldWindow.js）は
* //   このスクリプトに統合されました。
* //   既に使用されている方はそのプラグインを消去した上で
* //   本プラグインを導入して下さい。
* //
* // ここからリスポーン: http://respawnfromhere.blog.fc2.com/
* // Twitter: https://twitter.com/ibakip
* //
* //=============================================================================
*
* このプラグインはマップに常駐する顔グラウィンドウ、ステータスウィンドウ、
* 所持金ウィンドウの３つを生成します。
*
* 【プラグインコマンド】
*  ResidentWindow Show : 常駐ウィンドウを表示します。
*  ResidentWindow Hide : 常駐ウィンドウを非表示にします。
*
* 【パラメータ】
*
* ニューゲーム時の常駐ウィンドウ表示／非表示の選択
*  ・ StartWithHideWindow
*     true を指定すると非表示状態でゲーム開始、
*     false か空文字を指定すると表示状態でゲーム開始。
*
* 各ウィンドウの使用
*  ・ FaceWindow_ON
*  ・ StatusWindow_ON
*  ・ GoldWindow_ON
*     それぞれ true を指定すると使用、 false か空文字を指定すると未使用。
*
* 各ウィンドウのウィンドウタイプ変更
*  ・ FaceWindow_type
*  ・ StatusWindow_type
*  ・ GoldWindow_type
*     0：通常  1：黒背景  2:透明  3:画像(所持金ウィンドウのみ)
*     3 を選択する場合、使用する画像をimg/picturesフォルダに入れて下さい。
*
* 顔グラウィンドウ表示位置の変更
*  ・ FaceWindow_x
*  ・ FaceWindow_y
*
* ステータスウィンドウ表示位置の変更
*  ・ StatusWindow_x
*  ・ StatusWindow_y
*
* 所持金ウィンドウ表示位置の変更
*  ・ GoldWindow_x
*  ・ GoldWindow_y
*
* 顔グラをフレーム画像で装飾するかを指定
*  ・ FaceFrame_ON
*     true を指定すると使用、 false か空文字を指定すると未使用。
*     規格は同梱されている物に従って下さい。
*     ※ trueにすると、FaceWindow_type の指定は無視されます。
*
* ステータスウィンドウのゲージ間隔の変更
*  ・ StatusWindow_PaddingHeight
*
* HPゲージ等にフレーム画像を適用するかを指定
*  ・ GaugeFrame_ON
*     true を指定すると使用、 false か空文字を指定すると未使用。
*     規格は同梱されている物に従って下さい。
*
* ステータスウィンドウにTPゲージを描画するかを指定
*  ・ TP_Gauge_ON
*     true を指定すると使用、 false か空文字を指定すると未使用。
*
* 所持金ウィンドウの幅の変更
*  ・ GoldWindow_width
*  ・ GoldWindow_height
*     GoldWindow_typeで 3 を指定した場合、この値は無視されます。
*     （画像サイズに合わせて自動でウィンドウ幅が決定されます。）
*
* 所持金ウィンドウに描画するアイコン画像の変更
*  ・ GoldWindow_IconNumber
*     0 を指定するとアイコンは使わずお金の単位を描画します。
*
* 所持金ウィンドウ内の横方向の余白調整
*  ・ GoldWindw_PaddingWidth
*     値が大きいほど描画内容が内側に寄ります。
*
*
*/
//=============================================================================

var Imported = Imported || {};
Imported.ResidentWindow = {};

(function () {

    var inVal = Imported.ResidentWindow;
    inVal.WinON = true;
    inVal.last_WinState = true;

    // ---プラグインパラメータの取得-----------------------------------------------------
    var Parameters = PluginManager.parameters('ResidentWindow');
    var RW_HideStart = !Parameters['StartWithHideWindow'].match(/^\s*(false)?\s*$/i);
    var RFW_ON = !Parameters['FaceWindow_ON'].match(/^\s*(false)?\s*$/i);
    var RSW_ON = !Parameters['StatusWindow_ON'].match(/^\s*(false)?\s*$/i);
    var RGW_ON = !Parameters['GoldWindow_ON'].match(/^\s*(false)\s*$/i);
    var RFW_x = Math.floor(Number(Parameters['FaceWindow_x'])) || 0;
    var RFW_y = Math.floor(Number(Parameters['FaceWindow_y'])) || 0;
    var RSW_x = Math.floor(Number(Parameters['StatusWindow_x'])) || 0;
    var RSW_y = Math.floor(Number(Parameters['StatusWindow_y'])) || 0;
    var RSW_paddingHeight = Math.floor(Number(Parameters['StatusWindow_PaddingHeight'])) || 0;
    var RSW_TPGaugeON = !Parameters['TP_Gauge_ON'].match(/^\s*(false)\s*$/i);
    var RSW_GaugeFrameON = !Parameters['GaugeFrame_ON'].match(/^\s*(false)\s*$/i);
    var RFW_FrameON = !Parameters['FaceFrame_ON'].match(/^\s*(false)\s*$/i);
    var RGW_x = Math.floor(Number(Parameters['GoldWindow_x'])) || 0;
    var RGW_y = Math.floor(Number(Parameters['GoldWindow_y'])) || 0;
    var RFW_type = Math.floor(Number(Parameters['FaceWindow_type'])) || 0;
    var RSW_type = Math.floor(Number(Parameters['StatusWindow_type'])) || 0;
    var RGW_type = Math.floor(Number(Parameters['GoldWindow_type'])) || 0;
    var RGW_width = Math.floor(Number(Parameters['GoldWindow_width'])) || 0;
    var RGW_height = Math.floor(Number(Parameters['GoldWindow_height'])) || 0;
    var RGW_icon = Math.floor(Number(Parameters['GoldWindow_IconNumber'])) || 0;
    var RGW_paddingWidth = Math.floor(Number(Parameters['GoldWindow_PaddingWidth'])) || 0;
    //----------------------------------------------------------------------------

    // ---プラグインコマンド-------------------------------------------------------------
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'ResidentWindow') {
            switch (args[0]) {
                case 'Show':
                    inVal.WinON = true;
                    break;
                case 'Hide':
                    inVal.WinON = false;
                    break;
                default: // トラブル調査用にスペルミスの場合はログに書き出し
                    console.log('Unknown ResidentWindow argument: "' + args[0] + '"');
                    break;
            }
        }
    };
    //----------------------------------------------------------------------------

    /* ローカルスコープ変数の準備 */
    if (RGW_type == 3) {
        var RGW_bitmap = ImageManager.loadPicture('GoldWindowPictue', 0);
    }

    //-----------------------------------------------------------------------------
    // DataManager
    //-----------------------------------------------------------------------------
    /* フェイスチャットの情報をセーブ＆ロードできるように上書き */
    var RW_DataManager_makeSaveContents = DataManager.makeSaveContents;
    DataManager.makeSaveContents = function () {
        var contents = RW_DataManager_makeSaveContents();
        contents.WinON = inVal.WinON;
        return contents;
    };
    var RW_DataManager_extractSaveContents = DataManager.extractSaveContents;
    DataManager.extractSaveContents = function (contents) {
        RW_DataManager_extractSaveContents(contents);
        inVal.WinON = contents.WinON;
    };

    //-----------------------------------------------------------------------------
    // Scene_Title
    //-----------------------------------------------------------------------------
    /* ニューゲーム時のウィンドウ可視状態の初期化 */
    var SFC_scene_title_commandNewGame = Scene_Title.prototype.commandNewGame;
    Scene_Title.prototype.commandNewGame = function () {
        if (RW_HideStart) {
            inVal.WinON = false;
        }
        SFC_scene_title_commandNewGame.call(this);
    };

    //-----------------------------------------------------------------------------
    // Window_ResidentFace
    //-----------------------------------------------------------------------------
    /* マップ画面に常駐する顔グラウィンドウを扱うクラスです */

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

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

    Window_ResidentFace.prototype.initialize = function (x, y, width, height) {
        Window_Base.prototype.initialize.call(this, 0, 0, 176, 176);
        this.refresh();
    };

    /* 描画内容の更新 */
    Window_ResidentFace.prototype.refresh = function () {
        this.party_leader = $gameParty.leader();
        this.last_WinON = inVal.WinON;
        this.contents.clear();
        var leader_name = this.party_leader.faceName();
        var leader_id = this.party_leader.faceIndex();
        var face_width = Window_Base._faceWidth;
        var face_height = Window_Base._faceHeight;
        if (RFW_FrameON === true) {
            this.drawPicture('FaceLayer1', 0, 0);
        }
        this.drawFace(leader_name, leader_id, 16, 16, face_width, face_height);
        if (RFW_FrameON === true) {
            this.drawPicture('FaceLayer2', 0, 0);
        }
    };

    /* フレーム毎の更新処理 （更新条件も記述）*/
    Window_ResidentFace.prototype.update = function () {
        Window_Base.prototype.update.call(this);
        if (this.party_leader != $gameParty.leader()) {
            this.refresh();
        }
        if (this.last_WinON != inVal.WinON) {
            this.refresh();
        }
    };

    /* ウィンドウを開く処理 */
    Window_ResidentFace.prototype.open = function () {
        this.refresh();
        Window_Base.prototype.open.call(this);
    };

    /* ウィンドウを閉じる時に一瞬で消えるように仕様を変更 */
    Window_ResidentFace.prototype.updateClose = function () {
        if (this._closing) {
            this.openness -= 255;
            if (this.isClosed()) {
                this._closing = false;
            }
        }
    };

    /* コンテンツの横幅取得 */
    Window_ResidentFace.prototype.contentsWidth = function () {
        return 176;
    };

    /* コンテンツの縦幅取得 */
    Window_ResidentFace.prototype.contentsHeight = function () {
        return 176;
    };

    /* フレーム描画用 */
    Window_ResidentFace.prototype.drawPicture = function (filename, x, y) {
        var bitmap = ImageManager.loadPicture(filename, 0);
        var pw = bitmap.width;
        var ph = bitmap.height;
        this.contents.blt(bitmap, 0, 0, pw, ph, x, y);
    };

    /* 他のプラグインからもアクセスできるようにエクスポート */
    window.Window_ResidentFace = Window_ResidentFace;

    //-----------------------------------------------------------------------------
    // Window_ResidentStatus
    //-----------------------------------------------------------------------------
    /* マップ画面に常駐するステータスウィンドウを扱うクラスです */

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

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

    Window_ResidentStatus.prototype.initialize = function (x, y, width, height) {
        var yy = this.contentsHeight();
        Window_Base.prototype.initialize.call(this, 0, 0, 410, yy);
        this.refresh();
    };

    /* 描画内容の更新 */
    Window_ResidentStatus.prototype.refresh = function () {
        this.last_hp = $gameParty.members()[0].hp;
        this.last_mp = $gameParty.members()[0].mp;
        this.last_tp = $gameParty.members()[0].tp;
        this.party_leader = $gameParty.leader();
        this.leaderLevel = this.party_leader.level;
        this.last_WinON = inVal.WinON;
        this.contents.clear();
        var leader_name = this.party_leader.faceName();
        var leader_id = this.party_leader.faceIndex();
        var plusPos = 16;
        if (RSW_type == 2) {
            plusPos = 0;
        }
        if (RSW_GaugeFrameON === true) {
            this.drawActorHp(this.party_leader, 5 + plusPos, 5 + plusPos, 400);
            this.drawPicture('GaugeFrame', plusPos, plusPos);
            this.drawActorMp(this.party_leader, 5 + plusPos, 28 + RSW_paddingHeight + 5 + plusPos, 400);
            this.drawPicture('GaugeFrame', plusPos, 28 + RSW_paddingHeight + plusPos);
            if (RSW_TPGaugeON) {
                this.drawActorTp(this.party_leader, 5 + plusPos, (28 + RSW_paddingHeight) * 2 + 5 + plusPos, 400);
                this.drawPicture('GaugeFrame', plusPos, (28 + RSW_paddingHeight) * 2 + plusPos);
            }
        }
        else {
            this.drawActorHp(this.party_leader, plusPos, plusPos, 186);
            this.drawActorMp(this.party_leader, plusPos, 28 + RSW_paddingHeight + plusPos, 186);
            if (RSW_TPGaugeON) {
                this.drawActorTp(this.party_leader, plusPos, (28 + RSW_paddingHeight) * 2 + plusPos, 186);
            }
        }
    };

    /* フレーム毎の更新処理 （更新条件も記述）*/
    Window_ResidentStatus.prototype.update = function () {
        Window_Base.prototype.update.call(this);
        if (this.last_hp != $gameParty.members()[0].hp) {
            this.refresh();
        }
        if (this.last_mp != $gameParty.members()[0].mp) {
            this.refresh();
        }
        if (this.last_tp != $gameParty.members()[0].tp) {
            this.refresh();
        }
        if (this.party_leader != $gameParty.leader()) {
            this.refresh();
        }
        if (this.leaderLevel != $gameParty.leader().level) {
            this.refresh();
        }
        if (this.last_WinON != inVal.WinON) {
            this.refresh();
        }
    };

    /* ウィンドウを開く処理 */
    Window_ResidentStatus.prototype.open = function () {
        this.refresh();
        Window_Base.prototype.open.call(this);
    };

    /* ウィンドウを閉じる時に一瞬で消えるように仕様を変更 */
    Window_ResidentStatus.prototype.updateClose = function () {
        if (this._closing) {
            this.openness -= 255;
            if (this.isClosed()) {
                this._closing = false;
            }
        }
    };

    /* コンテンツの横幅取得 */
    Window_ResidentStatus.prototype.contentsWidth = function () {
        if (RSW_GaugeFrameON) {
            return 410 + 32;
        }
        else {
            return 186 + 32;
        }
    };

    /* コンテンツの縦幅取得 */
    Window_ResidentStatus.prototype.contentsHeight = function () {
        var plusPos = 32;
        if (RSW_type == 2) {
            plusPos = 0;
        }
        if (RSW_GaugeFrameON) {
            if (RSW_TPGaugeON) {
                return (28 * 3 + RSW_paddingHeight * 2 + plusPos);
            }
            else {
                return (28 * 2 + RSW_paddingHeight + plusPos);
            }
        }
        else {
            if (RSW_TPGaugeON) {
                return (6 * 3 + 30 * 3 + RSW_paddingHeight * 2 + plusPos);
            }
            else {
                return (6 * 2 + 30 * 2 + RSW_paddingHeight + plusPos);
            }
        }
    };

    /* フレームと背景描画用 */
    Window_ResidentStatus.prototype.drawPicture = function (filename, x, y) {
        var bitmap = ImageManager.loadPicture(filename, 0);
        var pw = 0;
        var ph = 0;
        if (RSW_GaugeFrameON) {
            pw = bitmap.width;
            ph = bitmap.height;
        }
        this.contents.blt(bitmap, 0, 0, pw, ph, x, y);
    };

    /*　HPゲージの描画 */
    Window_ResidentStatus.prototype.drawActorHp = function (actor, x, y, width) {
        var padding = 0;
        if (RSW_GaugeFrameON !== true) {
            width = 186;
            padding = 30;
        }
        var color1 = this.hpGaugeColor1();
        var color2 = this.hpGaugeColor2();
        this.drawGauge(x, y + padding, width, actor.hpRate(), color1, color2);
        if (RSW_GaugeFrameON !== true) {
            this.changeTextColor(this.systemColor());
            this.drawCurrentAndMax(actor.hp, actor.mhp, x, y, width,
                this.hpColor(actor), this.normalColor());
        }
    };

    /* MPゲージの描画 */
    Window_ResidentStatus.prototype.drawActorMp = function (actor, x, y, width) {
        var padding = 0;
        if (RSW_GaugeFrameON !== true) {
            width = 186;
            padding = 30;
        }
        var color1 = this.mpGaugeColor1();
        var color2 = this.mpGaugeColor2();
        this.drawGauge(x, y + padding, width, actor.mpRate(), color1, color2);
        if (RSW_GaugeFrameON !== true) {
            this.changeTextColor(this.systemColor());
            this.drawCurrentAndMax(actor.mp, actor.mmp, x, y, width,
                this.mpColor(actor), this.normalColor());
        }
    };

    /* TPゲージの描画 */
    Window_ResidentStatus.prototype.drawActorTp = function (actor, x, y, width) {
        var padding = 0;
        if (RSW_GaugeFrameON !== true) {
            width = 186;
            padding = 30;
        }
        var color1 = this.tpGaugeColor1();
        var color2 = this.tpGaugeColor2();
        this.drawGauge(x, y + padding, width, actor.tpRate(), color1, color2);
        if (RSW_GaugeFrameON !== true) {
            this.changeTextColor(this.tpColor(actor));
            this.drawText(actor.tp, x + width - 64, y, 64, 'right');
        }
    };

    /* ゲージの描画処理 */
    Window_ResidentStatus.prototype.drawGauge = function (x, y, width, rate, color1, color2) {
        var fillW = Math.floor(width * rate);
        if (RSW_GaugeFrameON) {
            gaugeHeight = 18;
        }
        else {
            gaugeHeight = 6;
        }
        this.contents.fillRect(x, y, width, gaugeHeight, this.gaugeBackColor());
        this.contents.gradientFillRect(x, y, fillW, gaugeHeight, color1, color2);
    };

    /* 他のプラグインからもアクセスできるようにエクスポート */
    window.Window_ResidentStatus = Window_ResidentStatus;

    //-----------------------------------------------------------------------------
    // Window_ResidentGold
    //-----------------------------------------------------------------------------
    /* マップ画面に常駐する所持金ウィンドウを扱うクラスです */

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

    Window_ResidentGold.prototype = Object.create(Window_Gold.prototype);
    Window_ResidentGold.prototype.constructor = Window_ResidentGold;

    Window_ResidentGold.prototype.initialize = function (x, y) {
        Window_Gold.prototype.initialize.call(this, x, y);
        this.refresh();
    };

    /* 描画内容の更新 */
    Window_ResidentGold.prototype.refresh = function () {
        this.last_gold = $gameParty.gold();
        this.last_WinON = inVal.WinON;
        var x = this.textPadding() + RGW_paddingWidth;
        var y = (this.contentsHeight() - Window_Base.prototype.lineHeight()) / 2;
        var icon_y = (this.contentsHeight() - Window_Base._iconWidth) / 2;
        var width = this.contentsWidth();
        this.contents.clear();
        if (RGW_type == 3) {
            this.drawBackground.call(this);
        }
        if (RGW_icon === 0) {
            this.drawCurrencyValue(this.value(), TextManager.currencyUnit, -x, y, width);
        } else {
            this.drawText(this.value(), -x, y, this.contentsWidth(), 'right');
            this.drawIcon(RGW_icon, x, icon_y);
        }
    };

    /* フレーム毎の更新処理 （更新条件も記述）*/
    Window_ResidentGold.prototype.update = function () {
        Window_Base.prototype.update.call(this);
        if (this.last_gold != $gameParty.gold()) {
            this.refresh();
        }
        if (this.last_WinON != inVal.WinON) {
            this.refresh();
        }
    };

    /* ウィンドウを開く処理 */
    Window_ResidentGold.prototype.open = function () {
        this.refresh();
        Window_Gold.prototype.open.call(this);
    };

    /* ウィンドウを閉じる時に一瞬で消えるように仕様を変更 */
    Window_ResidentGold.prototype.updateClose = function () {
        if (this._closing) {
            this.openness -= 255;
            if (this.isClosed()) {
                this._closing = false;
            }
        }
    };

    /* コンテンツの横幅取得 */
    Window_ResidentGold.prototype.contentsWidth = function () {
        if (RGW_type == 3) {
            return RGW_bitmap.width;
        } else {
            return RGW_width;
        }
    };

    /* コンテンツの縦幅取得 */
    Window_ResidentGold.prototype.contentsHeight = function () {
        if (RGW_type == 3) {
            return RGW_bitmap.height;
        } else {
            return RGW_height;
        }
    };

    /* ウィンドウの背景画像を描画 */
    Window_ResidentGold.prototype.drawBackground = function () {
        this.contents.blt(RGW_bitmap, 0, 0, RGW_bitmap.width, RGW_bitmap.height, 0, 0);
    };

    /* 他のプラグインからもアクセスできるようにエクスポート */
    window.Window_ResidentGold = Window_ResidentGold;

    //-----------------------------------------------------------------------------
    // Scene_Map
    //-----------------------------------------------------------------------------
    /* シーンを扱うクラス（rpg_scenes.jpに元々あるクラス） */

    /* マップ画面開始時の処理（当スクリプトで追加したウィンドウを開く処理を追加） */
    var scene_map_start = Scene_Map.prototype.start;
    Scene_Map.prototype.start = function () {
        scene_map_start.call(this);
        if (inVal.WinON) {
            if (RFW_ON) {
                this.face_window.open();
            }
            if (RSW_ON) {
                this.status_window.open();
            }
            if (RGW_ON) {
                this.gold_window.open();
            }
        }
    };

    /* 顔グラウィンドウを生成する処理 */
    Scene_Map.prototype.createResidentFaceWindow = function () {
        this.face_window = new Window_ResidentFace(this);
        this.face_window.width = 176;
        this.face_window.height = 176;
        this.face_window.x = RFW_x;
        this.face_window.y = RFW_y;
        this.face_window.padding = 0;
        this.face_window.openness = 0;
        if (RFW_FrameON) {
            this.face_window.setBackgroundType(2);
        }
        else {
            this.face_window.setBackgroundType(RFW_type);
        }
        this.addWindow(this.face_window);
    };

    /* ステータスウィンドウを生成する処理 */
    Scene_Map.prototype.createResidentStatusWindow = function () {
        this.status_window = new Window_ResidentStatus(this);
        var plusPos = 32;
        if (RSW_type == 2) {
            plusPos = 0;
        }
        if (RSW_GaugeFrameON) {
            this.status_window.width = 410 + plusPos;
            if (RSW_TPGaugeON) {
                this.status_window.height = (28 * 3 + RSW_paddingHeight * 2) + plusPos;
            }
            else {
                this.status_window.height = (28 * 2 + RSW_paddingHeight) + plusPos;
            }
        }
        else {
            this.status_window.width = 186 + plusPos;
            if (RSW_TPGaugeON) {
                this.status_window.height = (6 * 3 + 30 * 3 + RSW_paddingHeight * 2 + plusPos);
            }
            else {
                this.status_window.height = (6 * 2 + 30 * 2 + RSW_paddingHeight + plusPos);
            }
        }
        this.status_window.x = RSW_x;
        this.status_window.y = RSW_y;
        this.status_window.padding = 0;
        this.status_window.openness = 0;
        this.status_window.setBackgroundType(RSW_type);
        this.addWindow(this.status_window);
    };

    /* 所持金ウィンドウを生成する処理 */
    Scene_Map.prototype.createResidentGoldWindow = function () {
        this.gold_window = new Window_ResidentGold(this);
        this.gold_window.x = RGW_x;
        this.gold_window.y = RGW_y;
        if (RGW_type == 3) {
            this.gold_window.width = RGW_bitmap.width;
            this.gold_window.height = RGW_bitmap.height;
            this.gold_window.setBackgroundType(2);
        }
        else {
            this.gold_window.width = RGW_width;
            this.gold_window.height = RGW_height;
            this.gold_window.setBackgroundType(RGW_type);
        }
        this.gold_window.padding = 0;
        this.gold_window.openness = 0;
        this.addWindow(this.gold_window);
    };

    /* 全ウィンドウを生成する処理 */
    var scene_map_createAllWindows = Scene_Map.prototype.createAllWindows;
    Scene_Map.prototype.createAllWindows = function () {
        scene_map_createAllWindows.call(this);
        this.createResidentFaceWindow(this);
        this.createResidentStatusWindow(this);
        this.createResidentGoldWindow(this);
    };

    var scene_map_update = Scene_Map.prototype.update;
    Scene_Map.prototype.update = function () {
        scene_map_update.call(this);
        if (inVal.last_WinState != inVal.WinON) {
            if (inVal.WinON === false) {
                this.face_window.close();
                this.status_window.close();
                this.gold_window.close();
                inVal.last_WinState = false;
            }
            else if (inVal.WinON === true) {
                if (RFW_ON) {
                    this.face_window.open();
                }
                if (RSW_ON) {
                    this.status_window.open();
                }
                if (RGW_ON) {
                    this.gold_window.open();
                }
                inVal.last_WinState = true;
            }
        }
    };

    /* シーンがマップ以外に遷移した時にウィンドウを見えなくする処理 */
    var scene_map_stop = Scene_Map.prototype.stop;
    Scene_Map.prototype.stop = function () {
        this.face_window.close();
        this.status_window.close();
        this.gold_window.close();
        scene_map_stop.call(this);
    };

})();


code:
//=============================================================================
// RetryBattle.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.1 2017/03/20 本体v1.3.4以降で、リトライ後のメニュー画面でコモンイベントアイテムが実行できていた問題を修正
// 1.1.0 2016/07/26 リトライ後のメニュー画面でコモンイベントを実行するアイテム・スキルを実行すると正常に動作しない問題を修正
//                  リトライ後のメニュー画面でゲーム終了を選択できないように修正
//                  リトライ回数をカウントして、スクリプトから取得できる機能を追加
// 1.0.0 2016/07/26 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc RetryBattlePlugin
 * @author triacontane
 *
 * @param RetryNormalEnemy
 * @desc 雑魚敵でゲームオーバーになったあとにリトライできます。
 * @default ON
 *
 * @param RetryBossEnemy
 * @desc ボス敵でゲームオーバーになったあとにリトライできます。
 * @default ON
 *
 * @param CommandRetry
 * @desc ゲームオーバー画面で表示する「リトライする」ためのコマンド文字列です。
 * @default リトライ
 *
 * @param CommandLoad
 * @desc ゲームオーバー画面で表示する「ロード画面に移行する」ためのコマンド文字列です。
 * @default ロード
 *
 * @param CommandTitle
 * @desc ゲームオーバー画面で表示する「タイトル画面に移行する」ためのコマンド文字列です。
 * @default タイトルへ
 *
 * @param WindowY
 * @desc リトライウィンドウの表示Y座標です。
 * @default 464
 *
 * @param ShowMenu
 * @desc リトライ選択後、戦闘開始前にメニュー画面を表示します。
 * @default ON
 *
 * @param Message
 * @desc ウィンドウの上部にメッセージを表示します。
 * @default \c[2]あなたは死にました。\c[0]
 *
 * @param MessageY
 * @desc メッセージの表示Y座標です。
 * @default 360
 *
 * @param FontSize
 * @desc メッセージのフォントサイズです。
 * @default 32
 *
 * @help 戦闘でゲームオーバーになったあとのゲームオーバー画面でリトライ可能になります。
 * 雑魚敵とボス敵とでリトライ可能かどうかを分けることができます。
 * リトライを選択すると一度だけメニュー画面を開いた後で、再戦することができます。
 * メニュー画面ではセーブ及びコモンイベントを実行するアイテム、スキルの使用ができません。
 *
 * 雑魚敵かボス敵かは以下の通り判定されます。
 *
 * ・雑魚敵
 * ランダムエンカウントか「戦闘の処理」で「ランダムエンカウントと同じ」を選択
 *
 * ・ボス敵
 * 上記以外
 *
 * さらにオマケ機能として、戦闘中に実行すると強制的に戦闘を最初からやり直す
 * プラグインコマンドを提供します。有名RPGの某魔法が再現できます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * RB_リトライ禁止  # 一時的にリトライを禁止します。
 * RB_RETRY_DISABLE # 同上
 * RB_リトライ許可  # リトライを再度許可します。
 * RB_RETRY_ENABLE  # 同上
 * RB_強制リトライ  # 戦闘中に使用すると強制的にリトライします。
 * RB_FORCE_RETRY   # 同上
 *
 * スクリプト詳細
 *  イベントコマンド「変数の操作」から実行
 * $gameSystem.getRetryCount(); # リトライ回数を取得して変数に保持します。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 戦闘リトライプラグイン
 * @author トリアコンタン
 *
 * @param 雑魚敵でリトライ可能
 * @desc 雑魚敵でゲームオーバーになったあとにリトライできます。
 * @default ON
 *
 * @param ボス敵でリトライ可能
 * @desc ボス敵でゲームオーバーになったあとにリトライできます。
 * @default ON
 *
 * @param コマンドリトライ
 * @desc ゲームオーバー画面で表示する「リトライする」ためのコマンド文字列です。
 * @default リトライ
 *
 * @param コマンドロード
 * @desc ゲームオーバー画面で表示する「ロード画面に移行する」ためのコマンド文字列です。
 * @default ロード
 *
 * @param コマンドタイトル
 * @desc ゲームオーバー画面で表示する「タイトル画面に移行する」ためのコマンド文字列です。
 * @default タイトルへ
 *
 * @param ウィンドウY座標
 * @desc リトライウィンドウの表示Y座標です。
 * @default 448
 *
 * @param メニュー画面を表示
 * @desc リトライ選択後、戦闘開始前にメニュー画面を表示します。
 * @default ON
 *
 * @param メッセージ
 * @desc ウィンドウの上部にメッセージを表示します。
 * @default \i[1]\c[2]あなたは死にました\c[0]\i[1]
 *
 * @param メッセージY座標
 * @desc メッセージの表示Y座標です。
 * @default 360
 *
 * @param フォントサイズ
 * @desc メッセージのフォントサイズです。
 * @default 32
 *
 * @help 戦闘でゲームオーバーになったあとのゲームオーバー画面でリトライ可能になります。
 * 雑魚敵とボス敵とでリトライ可能かどうかを分けることができます。
 * リトライを選択すると一度だけメニュー画面を開いた後で、再戦することができます。
 * メニュー画面ではセーブ及びコモンイベントを実行するアイテム、スキルの使用ができません。
 *
 * 雑魚敵かボス敵かは以下の通り判定されます。
 *
 * ・雑魚敵
 * ランダムエンカウントか「戦闘の処理」で「ランダムエンカウントと同じ」を選択
 *
 * ・ボス敵
 * 上記以外
 *
 * さらにオマケ機能として、戦闘中に実行すると強制的に戦闘を最初からやり直す
 * プラグインコマンドを提供します。有名RPGの某魔法が再現できます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * RB_リトライ禁止  # 一時的にリトライを禁止します。
 * RB_RETRY_DISABLE # 同上
 * RB_リトライ許可  # リトライを再度許可します。
 * RB_RETRY_ENABLE  # 同上
 * RB_強制リトライ  # 戦闘中に使用すると強制的にリトライします。
 * RB_FORCE_RETRY   # 同上
 *
 * スクリプト詳細
 *  イベントコマンド「変数の操作」から実行
 * $gameSystem.getRetryCount(); # リトライ回数を取得して変数に保持します。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var pluginName = 'RetryBattle';
    var metaTagPrefix = 'RB_';

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

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

    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 getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON';
    };

    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 paramRetryNormalEnemy = getParamBoolean(['RetryNormalEnemy', '雑魚敵でリトライ可能']);
    var paramRetryBossEnemy = getParamBoolean(['RetryBossEnemy', 'ボス敵でリトライ可能']);
    var paramCommandRetry = getParamString(['CommandRetry', 'コマンドリトライ']);
    var paramCommandLoad = getParamString(['CommandLoad', 'コマンドロード']);
    var paramCommandTitle = getParamString(['CommandTitle', 'コマンドタイトル']);
    var paramWindowY = getParamNumber(['WindowY', 'ウィンドウY座標']);
    var paramShowMenu = getParamBoolean(['ShowMenu', 'メニュー画面を表示']);
    var paramMessage = getParamString(['Message', 'メッセージ']);
    var paramMessageY = getParamNumber(['MessageY', 'メッセージY座標']);
    var paramFontSize = getParamNumber(['FontSize', 'フォントサイズ']);

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        var commandPrefix = new RegExp('^' + metaTagPrefix);
        if (!command.match(commandPrefix)) return;
        try {
            this.pluginCommandRetryBattle(command.replace(commandPrefix, ''), args);
        } catch (e) {
            if ($gameTemp.isPlaytest() && Utils.isNwjs()) {
                var window = require('nw.gui').Window.get();
                if (!window.isDevToolsOpen()) {
                    var devTool = window.showDevTools();
                    devTool.moveTo(0, 0);
                    devTool.resizeTo(window.screenX + window.outerWidth, window.screenY + window.outerHeight);
                    window.focus();
                }
            }
            console.log('プラグインコマンドの実行中にエラーが発生しました。');
            console.log('- コマンド名 　: ' + command);
            console.log('- コマンド引数 : ' + args);
            console.log('- エラー原因   : ' + e.stack || e.toString());
        }
    };

    Game_Interpreter.prototype.pluginCommandRetryBattle = function (command) {
        switch (getCommandName(command)) {
            case '強制リトライ':
            case 'FORCE_RETRY':
                if ($gameParty.inBattle()) SceneManager.push(Scene_BattleReturn);
                break;
            case 'リトライ禁止':
            case 'RETRY_DISABLE':
                $gameSystem.setRetryDisable(true);
                break;
            case 'リトライ許可':
            case 'RETRY_ENABLE':
                $gameSystem.setRetryDisable(false);
                break;
        }
    };

    var _Game_Interpreter_command353 = Game_Interpreter.prototype.command353;
    Game_Interpreter.prototype.command353 = function () {
        var result = _Game_Interpreter_command353.apply(this, arguments);
        BattleManager.goToGameover();
        return result;
    };

    var _Game_Interpreter_command301 = Game_Interpreter.prototype.command301;
    Game_Interpreter.prototype.command301 = function () {
        var result = _Game_Interpreter_command301.apply(this, arguments);
        if (!$gameParty.inBattle()) {
            BattleManager.setBossBattle(this._params[0] <= 1);
        }
        return result;
    };

    //=============================================================================
    // Game_Player
    //  雑魚敵の設定処理をします。
    //=============================================================================
    var _Game_Player_executeEncounter = Game_Player.prototype.executeEncounter;
    Game_Player.prototype.executeEncounter = function () {
        var result = _Game_Player_executeEncounter.apply(this, arguments);
        if (result) {
            BattleManager.setBossBattle(false);
        }
        return result;
    };

    //=============================================================================
    // Game_System
    //  リトライ禁止フラグを管理します。
    //=============================================================================
    var _Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        _Game_System_initialize.apply(this, arguments);
        this._retryDisable = false;
        this._retryCount = 0;
    };

    Game_System.prototype.setRetryDisable = function (value) {
        this._retryDisable = !!value;
    };

    Game_System.prototype.isRetryDisable = function () {
        return this._retryDisable;
    };

    Game_System.prototype.addRetryCount = function () {
        this._retryCount = this.getRetryCount() + 1;
    };

    Game_System.prototype.getRetryCount = function () {
        return this._retryCount || 0;
    };

    //=============================================================================
    // Game_BattlerBase
    //  リトライ時はコモンイベント使用を含むアイテムを使用禁止にします。
    //=============================================================================
    var _Game_BattlerBase_meetsUsableItemConditions = Game_BattlerBase.prototype.meetsUsableItemConditions;
    Game_BattlerBase.prototype.meetsUsableItemConditions = function (item) {
        return _Game_BattlerBase_meetsUsableItemConditions.apply(this, arguments) &&
            this.meetsUsableItemConditionsForRetry(item);
    };

    Game_BattlerBase.prototype.meetsUsableItemConditionsForRetry = function (item) {
        return !(SceneManager.isSceneRetry() && this.isCommonEventItemOf(item));
    };

    Game_BattlerBase.prototype.isCommonEventItemOf = function (item) {
        return item.effects.some(function (effect) {
            return effect.code === Game_Action.EFFECT_COMMON_EVENT;
        });
    };

    //=============================================================================
    // Game_Actor
    //  リトライ時はコモンイベント使用を含むアイテムを使用禁止にします。
    //=============================================================================
    var _Game_Actor_meetsUsableItemConditions = Game_Actor.prototype.meetsUsableItemConditions;
    Game_Actor.prototype.meetsUsableItemConditions = function (item) {
        return _Game_Actor_meetsUsableItemConditions.apply(this, arguments) &&
            this.meetsUsableItemConditionsForRetry(item);
    };

    //=============================================================================
    // BattleManager
    //  リトライ関連処理を追加定義します。
    //=============================================================================
    BattleManager.setupRetry = function () {
        SoundManager.playBattleStart();
        $gameTemp.clearCommonEvent();
        $gameTroop.setup($gameTroop.troop().id);
        $gameSystem.addRetryCount();
    };

    BattleManager.setBossBattle = function (value) {
        this._bossBattle = !!value;
    };

    var _BattleManager_startBattle = BattleManager.startBattle;
    BattleManager.startBattle = function () {
        DataManager.saveGameForRetry();
        _BattleManager_startBattle.apply(this, arguments);
    };

    var _BattleManager_updateBattleEnd = BattleManager.updateBattleEnd;
    BattleManager.updateBattleEnd = function () {
        _BattleManager_updateBattleEnd.apply(this, arguments);
        this.goToGameover();
    };

    BattleManager.goToGameover = function () {
        if (SceneManager.isNextScene(Scene_Gameover)) {
            Scene_Gameover.firstShow = true;
            SceneManager.push(Scene_Gameover);
        }
    };

    BattleManager.canRetry = function () {
        return !$gameSystem.isRetryDisable() && this.checkBattleType() && paramCommandRetry && DataManager.hasRetryData();
    };

    BattleManager.checkBattleType = function () {
        return (paramRetryNormalEnemy && !this._bossBattle) || (paramRetryBossEnemy && this._bossBattle);
    };

    //=============================================================================
    // DataManager
    //  リトライ用データのセーブとロードを行います。
    //=============================================================================
    DataManager.saveGameForRetry = function () {
        var json = JsonEx.stringify(this.makeSaveContents());
        if (json.length >= 200000) {
            console.warn('Save data too big!');
        }
        this._retryData = LZString.compressToBase64(json);
    };

    DataManager.hasRetryData = function () {
        return !!this._retryData;
    };

    DataManager.loadGameForRetry = function () {
        if (this._retryData) {
            var json = LZString.decompressFromBase64(this._retryData);
            this.extractSaveContents(JsonEx.parse(json));
        }
    };

    //=============================================================================
    // SceneManager
    //  リトライ中かどうかの判定を行います。
    //=============================================================================
    SceneManager.isSceneRetry = function () {
        return this._stack.some(function (scene) {
            return scene === Scene_Gameover;
        });
    };

    //=============================================================================
    // Window_MenuCommand
    //  リトライ用のメニューでセーブを禁止します。
    //=============================================================================
    var _Window_MenuCommand_isSaveEnabled = Window_MenuCommand.prototype.isSaveEnabled;
    Window_MenuCommand.prototype.isSaveEnabled = function () {
        return _Window_MenuCommand_isSaveEnabled.apply(this, arguments) && !SceneManager.isSceneRetry();
    };

    var _Window_MenuCommand_isGameEndEnabled = Window_MenuCommand.prototype.isGameEndEnabled;
    Window_MenuCommand.prototype.isGameEndEnabled = function () {
        return _Window_MenuCommand_isGameEndEnabled.apply(this, arguments) && !SceneManager.isSceneRetry();
    };

    //=============================================================================
    // Scene_Gameover
    //  リトライ用データのセーブとロードを行います。
    //=============================================================================
    Scene_Gameover.firstShow = false;

    var _Scene_Gameover_create = Scene_Gameover.prototype.create;
    Scene_Gameover.prototype.create = function () {
        _Scene_Gameover_create.apply(this, arguments);
        this.createWindowLayer();
        this.createForeground();
        this.createRetryWindow();
    };

    var _Scene_Gameover_start = Scene_Gameover.prototype.start;
    Scene_Gameover.prototype.start = function () {
        _Scene_Gameover_start.apply(this, arguments);
        if (!Scene_Gameover.firstShow) {
            if (SceneManager.isPreviousScene(Scene_Menu)) {
                this.executeRetry(1);
            }
            if (SceneManager.isPreviousScene(Scene_Load)) {
                this.startFadeIn(this.fadeSpeed(), false);
            }
        }
        Scene_Gameover.firstShow = false;
    };

    var _Scene_Gameover_stop = Scene_Gameover.prototype.stop;
    Scene_Gameover.prototype.stop = function () {
        if (!SceneManager.isNextScene(Scene_Load) && !SceneManager.isNextScene(Scene_Menu)) {
            _Scene_Gameover_stop.apply(this, arguments);
        } else {
            Scene_Base.prototype.stop.call(this);
        }
    };

    var _Scene_Gameover_terminate = Scene_Gameover.prototype.terminate;
    Scene_Gameover.prototype.terminate = function () {
        if (!SceneManager.isNextScene(Scene_Load) && !SceneManager.isNextScene(Scene_Menu)) {
            _Scene_Gameover_terminate.apply(this, arguments);
        } else {
            Scene_Base.prototype.terminate.call(this);
        }
    };

    var _Scene_Gameover_playGameoverMusic = Scene_Gameover.prototype.playGameoverMusic;
    Scene_Gameover.prototype.playGameoverMusic = function () {
        if (!SceneManager.isPreviousScene(Scene_Load)) {
            _Scene_Gameover_playGameoverMusic.apply(this, arguments);
        }
    };

    Scene_Gameover.prototype.createRetryWindow = function () {
        this._retryWindow = new Window_RetryCommand();
        this._retryWindow.setHandler('retry', this.commandRetry.bind(this));
        this._retryWindow.setHandler('load', this.commandLoad.bind(this));
        this._retryWindow.setHandler('title', this.commandTitle.bind(this));
        this.addWindow(this._retryWindow);
    };

    Scene_Gameover.prototype.createForeground = function () {
        this._messageWindow = new Window_Base(0, 0, 0, 0);
        this._messageWindow.opacity = 0;
        this._messageWindow.contents.fontSize = paramFontSize;
        this.addWindow(this._messageWindow);
        if (paramMessage) {
            this.drawMessage();
        }
    };

    Scene_Gameover.prototype.drawMessage = function () {
        var padding = this._messageWindow.padding;
        var width = this._messageWindow.drawTextEx(paramMessage, 0, 0) + padding * 2;
        var height = paramFontSize + 8 + padding * 2;
        var x = Graphics.boxWidth / 2 - width / 2;
        this._messageWindow.move(x, paramMessageY, width, height);
        this._messageWindow.createContents();
        this._messageWindow.drawTextEx(paramMessage, 0, 0);
    };

    Scene_Gameover.prototype.commandRetry = function () {
        DataManager.loadGameForRetry();
        if (paramShowMenu) {
            SceneManager.push(Scene_Menu);
        } else {
            this._retryWindow.close();
            this.executeRetry(this.fadeSpeed());
        }
    };

    Scene_Gameover.prototype.commandLoad = function () {
        this._retryWindow.close();
        SceneManager.push(Scene_Load);
    };

    Scene_Gameover.prototype.commandTitle = function () {
        this._retryWindow.close();
        this.gotoTitle();
    };

    Scene_Gameover.prototype.executeRetry = function (fade) {
        BattleManager.setupRetry();
        this.popScene();
        this.startFadeOut(fade, true);
    };

    Scene_Gameover.prototype.update = function () {
        if (!this.isBusy()) {
            this._retryWindow.open();
        }
        Scene_Base.prototype.update.call(this);
    };

    Scene_Gameover.prototype.isBusy = function () {
        return this._retryWindow.isClosing() || Scene_Base.prototype.isBusy.call(this);
    };

    //=============================================================================
    // Scene_Base
    //  リトライ状態からの再ゲームオーバーを禁止します。
    //=============================================================================
    var _Scene_Base_checkGameover = Scene_Base.prototype.checkGameover;
    Scene_Base.prototype.checkGameover = function () {
        return !SceneManager.isSceneRetry() && _Scene_Base_checkGameover.apply(this, arguments);
    };

    //=============================================================================
    // Scene_Load
    //  ロード時にゲームオーバーMEを止めます。
    //=============================================================================
    var _Scene_Load_onLoadSuccess = Scene_Load.prototype.onLoadSuccess;
    Scene_Load.prototype.onLoadSuccess = function () {
        if (SceneManager.isSceneRetry()) {
            AudioManager.stopAll();
        }
        _Scene_Load_onLoadSuccess.apply(this, arguments);
    };

    //=============================================================================
    // Scene_BattleReturn
    //  そのまま戦闘画面に戻ります。
    //=============================================================================
    function Scene_BattleReturn() {
        this.initialize.apply(this, arguments);
    }

    Scene_BattleReturn.prototype = Object.create(Scene_Gameover.prototype);
    Scene_BattleReturn.prototype.constructor = Scene_BattleReturn;

    Scene_BattleReturn.prototype.create = function () {
    };

    Scene_BattleReturn.prototype.start = function () {
        this.executeRetry(this.fadeSpeed());
    };

    Scene_BattleReturn.prototype.isBusy = function () {
        return Scene_Base.prototype.isBusy.call(this);
    };

    //=============================================================================
    // Window_RetryCommand
    //  リトライ用コマンドウィンドウです。
    //=============================================================================
    function Window_RetryCommand() {
        this.initialize.apply(this, arguments);
    }

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

    Window_RetryCommand.prototype.initialize = function () {
        Window_Command.prototype.initialize.call(this, 0, 0);
        this.updatePlacement();
        this.openness = 0;
    };

    Window_RetryCommand.prototype.windowWidth = function () {
        return 180;
    };

    Window_RetryCommand.prototype.updatePlacement = function () {
        this.x = (Graphics.boxWidth - this.width) / 2;
        this.y = paramWindowY;
    };

    Window_RetryCommand.prototype.makeCommandList = function () {
        if (BattleManager.canRetry()) this.addCommand(paramCommandRetry, 'retry');
        if (paramCommandLoad) this.addCommand(paramCommandLoad, 'load');
        this.addCommand(paramCommandTitle, 'title');
    };
})();