//=============================================================================
// TMPlugin - 魔法スロット
// バージョン: 1.2.0
// 最終更新日: 2018/10/25
// 配布元    : https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================
/*:
@plugindesc A system for memorizing magic will be added in addition to regular equipment.
@author tomoaky
@url https://github.com/munokura/tomoaky-MV-plugins
@license MIT License

@help
English Help Translator: munokura
This is an unofficial English translation of the plugin help,
created to support global RPG Maker users.
Feedback is welcome to improve translation quality
(see: https://github.com/munokura/tomoaky-MV-plugins ).
Original plugin by tomoaky.
-----
TMPlugin - Magic Slot ver1.2.0

How to Use:

Add a new type named "Magic" to the "Weapon Type" section of the Database Type tab. Weapons with this type will be treated as magic.

Next, set the spell you want to memorize in the "Add Skill" Traits of the magic weapon.

Add the tag <magicSlot:1> to the actor's or class's Note field. The value set here will determine the maximum number of spells that can be memorized.

Obtain a weapon set as magic in the game and memorize it in the actor's magic memorization scene to use magic.

This plugin has been tested with RPG Maker MV Version 1.6.1.

Note field Tag (Actor, Class, Weapon, Armor):

<magicSlot:1>
The maximum number of spells that can be memorized will increase by 1. The actual maximum number is the sum of the values of this tag set for the actor, class, equipped weapon, and armor.

Memo Tag (Skill):

<magicSlotCost:1>
Sets the number of slots required for memorization to 1. For example, a skill with a value of 2
cannot be memorized unless there are two available slots.

Memo Tag (Weapon):

<equippableActor:1 2>
Specifies the actors who can memorize the spell by number.
If multiple actors are specified, separate them with a space.
If this tag is omitted, all actors will be able to memorize the spell.

<equippableClass:3>
Specifies the jobs that can memorize the spell by number.
If multiple jobs are specified, separate them with a space.
If this tag is omitted, all jobs will be able to memorize the spell.

Plugin Command:

callMagicEquip
Calls the magic memorization scene.

callMagicEquip 2
Calls the magic memorization scene for actor number 2.
If the specified actor is not in the party, the first actor in the party will be targeted.

addMagicSlot 3 1
Increases the available slot for actor number 3 by 1.
The control character \V[n] can be used as the value.

Plugin Parameter Notes:

menuCommand
If this parameter is left empty, the magic memory scene cannot be opened from the menu.
Use this if you want to swap magic only in specific locations.
In that case, you will need to call the magic memory scene with the plugin command callMagicEquip.

magicTypeName
Changes the weapon type name treated as magic.
Change this if the type name "Magic" is already in use.

slotCostColor
This is the same as the control character \C[n] used in Event's Contents such as "Show Text."
Set a value between 0 and 31.

maxMpText
Sets the name of the actor's maximum MP to be displayed in the magic memory scene.
The string %1 will be replaced with the MP string set in the database Terms.
If this parameter is empty, the maximum MP will not be displayed.

@param menuCommand
@desc Command to add to the menu scene. Default: Magic Memory
@default Magic Memory

@param actorSelectCommand
@desc Actor selection command to display in magic memory scene. Default: Actor selection (command is hidden if not entered)
@default Actor Selection

@param magicSlot
@desc The parameter name of the magic slot to display in the magic memory scene. Default: Memory slot
@default Memory slot

@param equipCommand
@desc The equipment command to display in the magic memory scene. Default: Memory
@default Memory

@param clearCommand
@desc Command to remove all displayed in the magic memory scene. Default: Forget all
@default Forget all
@type string

@param magicTypeName
@desc The name of the weapon type to treat as magic. Default: Magic
@default Magic
@type string

@param blankText
@desc Text to display in empty slots. Default: empty slots
@default empty slots
@type string

@param slotCostColor
@desc The text color number of the required number of free slots. Default: 31
@default 31
@type number
@max 31

@param statusWidth
@desc The width of the status window in the magic memory scene. Default: 340
@default 340
@type number

@param maxMpText
@desc Maximum MP item name for magic memory scene. Initial value: Max %1
@default Max %1
@type string
*/


/*:ja
@plugindesc 通常の装備とは別に魔法を記憶するシステムを追加します。
@author tomoaky
@url https://github.com/munokura/tomoaky-MV-plugins
@license MIT License

@help
TMPlugin - 魔法スロット ver1.2.0

使い方:

  データベースのタイプタブにある『武器タイプ』に 魔法 という名前の
  新しいタイプを追加してください。このタイプを設定した武器は魔法として
  扱われるようになります。

  次に、魔法として扱う武器の特徴『スキル追加』に実際に記憶する魔法を
  設定してください。

  アクター、あるいは職業のメモ欄に <magicSlot:1> というタグを
  設定してください。ここで設定した数値が記憶できる魔法の最大数になります。

  あとはゲーム内で魔法として設定した武器を入手し、魔法記憶シーンで
  アクターに記憶させれば、魔法が使えるようになります。

  このプラグインは RPGツクールMV Version 1.6.1 で動作確認をしています。


メモ欄タグ（アクター、職業、武器、防具）:

  <magicSlot:1>
    記憶できる魔法の最大数が 1 増えます。実際の最大数はアクター、職業、
    装備している武器と防具に設定されたこのタグの合計値が採用されます。


メモ欄タグ（スキル）:

  <magicSlotCost:1>
    記憶に必要なスロット数を 1 に設定します。たとえばこの値が 2 のスキルは
    スロットに 2 空きがないと記憶することができません。


メモ欄タグ（武器）:

  <equippableActor:1 2>
    魔法を記憶することができるアクターを番号で指定します、
    複数のアクターを設定する場合は半角スペースで区切ってください。
    このタグを省略した場合はすべてのアクターが記憶可能になります。

  <equippableClass:3>
    魔法を記憶することができる職業を番号で指定します、
    複数の職業を設定する場合は半角スペースで区切ってください。
    このタグを省略した場合はすべての職業が記憶可能になります。


プラグインコマンド:

  callMagicEquip
    魔法記憶シーンを呼び出します。

  callMagicEquip 2
    アクター 2 番の魔法記憶シーンを呼び出します。
    指定したアクターがパーティにいない場合はパーティの先頭にいるアクターが
    対象になります。

  addMagicSlot 3 1
    アクター 3 番の空きスロットを 1 増やします。
    数値には制御文字 \V[n] が使用できます。


プラグインパラメータ補足:

  menuCommand
    このパラメータに何も入力しなかった場合、メニューから魔法記憶シーンを
    開くことができなくなります。
    特定の場所でのみ魔法の入れ替えをしたい場合に利用してください、
    その場合はプラグインコマンド callMagicEquip で魔法記憶シーンを
    呼び出す必要があります。

  magicTypeName
    魔法として扱う武器タイプ名を変更することができます。
    『魔法』というタイプ名をすでに使用している場合に変更してください。

  slotCostColor
    イベントコマンド『文章の表示』などで使用する制御文字 \C[n] と同じです。
    0 ～ 31 の範囲で値を設定してください。

  maxMpText
    魔法記憶シーンに表示するアクターの最大MPの項目名を設定します。
    %1 という文字列がデータベースの用語で設定したMPの文字列と置換。
    このパラメータが空の場合は最大MPを表示しなくなります。

@param menuCommand
@desc メニューシーンに追加するコマンド。 初期値: 魔法の記憶
@default 魔法の記憶

@param actorSelectCommand
@desc 魔法記憶シーンで表示するアクター選択コマンド。 初期値: アクター選択 (未入力ならコマンドを非表示にする)
@default アクター選択

@param magicSlot
@desc 魔法記憶シーンで表示する魔法スロットのパラメータ名。 初期値: 記憶スロット
@default 記憶スロット

@param equipCommand
@desc 魔法記憶シーンで表示する装備コマンド。 初期値: 記憶
@default 記憶

@param clearCommand
@desc 魔法記憶シーンで表示する全て外すコマンド。 初期値: 全て忘れる
@default 全て忘れる
@type string

@param magicTypeName
@desc 魔法として扱う武器タイプ名。 初期値: 魔法
@default 魔法
@type string

@param blankText
@desc 空きスロットに表示するテキスト。 初期値: 空きスロット
@default 空きスロット
@type string

@param slotCostColor
@desc 必要な空きスロット数の文字色番号。 初期値: 31
@default 31
@type number
@max 31

@param statusWidth
@desc 魔法記憶シーンのステータスウィンドウの幅。 初期値: 340
@default 340
@type number

@param maxMpText
@desc 魔法記憶シーンの最大MPの項目名。 初期値: 最大%1
@default 最大%1
@type string
*/

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

var TMPlugin = TMPlugin || {};
TMPlugin.MagicSlot = {};
TMPlugin.MagicSlot.Parameters = PluginManager.parameters('TMMagicSlot');
TMPlugin.MagicSlot.MenuCommand = TMPlugin.MagicSlot.Parameters['menuCommand'];
TMPlugin.MagicSlot.ActorSelectCommand = TMPlugin.MagicSlot.Parameters['actorSelectCommand'];
TMPlugin.MagicSlot.MagicSlot = TMPlugin.MagicSlot.Parameters['magicSlot'] || '記憶スロット';
TMPlugin.MagicSlot.EquipCommand	= TMPlugin.MagicSlot.Parameters['equipCommand'] || '記憶';
TMPlugin.MagicSlot.ClearCommand	= TMPlugin.MagicSlot.Parameters['clearCommand'] || '全て忘れる';
TMPlugin.MagicSlot.MagicTypeName = TMPlugin.MagicSlot.Parameters['magicTypeName'] || '魔法';
TMPlugin.MagicSlot.BlankText = TMPlugin.MagicSlot.Parameters['blankText'] || '空きスロット';
TMPlugin.MagicSlot.SlotCostColor = +(TMPlugin.MagicSlot.Parameters['slotCostColor'] || 31);
TMPlugin.MagicSlot.StatusWidth = +(TMPlugin.MagicSlot.Parameters['statusWidth'] || 340);
TMPlugin.MagicSlot.MaxMpText = TMPlugin.MagicSlot.Parameters['maxMpText'];

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

(function() {

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

	var _Game_Actor_setup = Game_Actor.prototype.setup;
	Game_Actor.prototype.setup = function(actorId) {
		_Game_Actor_setup.call(this, actorId);
		this.initMagics();
	};

	var _Game_Actor_refresh = Game_Actor.prototype.refresh;
	Game_Actor.prototype.refresh = function() {
		this.releaseUnequippableMagics();
		_Game_Actor_refresh.call(this);
	};

	var _Game_Actor_traitObjects = Game_Actor.prototype.traitObjects;
	Game_Actor.prototype.traitObjects = function() {
		return _Game_Actor_traitObjects.call(this).concat(this.magics());
	};

	Game_Actor.prototype.initMagics = function() {
		this._magics = [];
		this._magicSlotPlus = 0;
	};

	Game_Actor.prototype.magics = function() {
		this._magics = this._magics || [];
		return this._magics.map(function(itemId) {
			return $dataWeapons[itemId];
		});
	};
	
	Game_Actor.prototype.magicSlotPlus = function() {
		this._magicSlotPlus = this._magicSlotPlus || 0;
		return this._magicSlotPlus;
	};

	Game_Actor.prototype.magicSlots = function() {
		var objects = [this.actor(), this.currentClass()];
		var equips = this.equips();
		for (var i = 0; i < equips.length; i++) {
			var item = equips[i];
			if (item) objects.push(item);
		}
		var result = objects.reduce(function(n, item) {
			return n + (+item.meta.magicSlot || 0);
		}.bind(this), this.magicSlotPlus());
		return Math.max(result, 0);
	};

	Game_Actor.prototype.totalMagicSlotCost = function() {
		return this.magics().reduce(function(n, item) {
			return n + (+item.meta.magicSlotCost || 1);
		}.bind(this), 0);
	};

	Game_Actor.prototype.blankMagicSlots = function() {
		return this.magicSlots() - this.totalMagicSlotCost();
	};

	Game_Actor.prototype.releaseUnequippableMagics = function(forcing) {
		for (;;) {
			var magics = this.magics();
			var magicSlots = this.magicSlots();
			var totalCost = this.totalMagicSlotCost();
			if (magicSlots < totalCost) {
				var itemId = this._magics.pop();
				if (!forcing) {
					$gameParty.gainItem($dataWeapons[itemId], 1);
				}
			} else {
				break;
			}
		}
	};

	Game_Actor.prototype.changeMagic = function(slotId, item) {
		var oldItem = this.magics()[slotId];
		if (oldItem) $gameParty.gainItem(oldItem, 1);
		if (item) {
			this._magics[slotId] = item.id;
			$gameParty.loseItem(item, 1);
		} else {
			this._magics.splice(slotId, 1);
		}
	};

	Game_Actor.prototype.clearMagics = function() {
		while (this.magics().length > 0) {
			this.changeMagic(0, null);
		}
	};

	Game_Actor.prototype.addMagicSlot = function(value) {
		this._magicSlotPlus = this._magicSlotPlus || 0;
		this._magicSlotPlus += value;
		this.refresh();
	};

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

	var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
	Game_Interpreter.prototype.pluginCommand = function(command, args) {
		_Game_Interpreter_pluginCommand.call(this, command, args);
		if (command === 'callMagicEquip') {
			if (args[0]) {
				var arr = args.map(this.convertEscapeCharactersTM, this);
				var actor = $gameActors.actor(+arr[0]);
				if (actor) {
					$gameParty.setMenuActor(actor);
				}
			}
			SceneManager.push(Scene_MagicEquip);
		} else if (command === 'addMagicSlot') {
			var arr = args.map(this.convertEscapeCharactersTM, this);
			var actor = $gameActors.actor(+arr[0]);
			if (actor) {
				actor.addMagicSlot(+arr[1]);
			}
		}
	};
	
	//-----------------------------------------------------------------------------
	// Window_MenuCommand
	//

	var _Window_MenuCommand_addMainCommands = Window_MenuCommand.prototype.addMainCommands;
	Window_MenuCommand.prototype.addMainCommands = function() {
		_Window_MenuCommand_addMainCommands.call(this);
		var enabled = this.areMainCommandsEnabled();
		if (TMPlugin.MagicSlot.MenuCommand) {
			this.addCommand(TMPlugin.MagicSlot.MenuCommand, 'magicEquip', enabled);
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MagicStatus
	//

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

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

	Window_MagicStatus.prototype.initialize = function(x, y) {
		var width = this.windowWidth();
		var height = this.windowHeight();
		Window_Base.prototype.initialize.call(this, x, y, width, height);
		this._actor = null;
		this.refresh();
	};

	Window_MagicStatus.prototype.windowWidth = function() {
		return TMPlugin.MagicSlot.StatusWidth;
	};

	Window_MagicStatus.prototype.windowHeight = function() {
		return this.fittingHeight(this.numVisibleRows());
	};

	Window_MagicStatus.prototype.numVisibleRows = function() {
		return TMPlugin.MagicSlot.MaxMpText ? 3 : 2;
	};

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

	Window_MagicStatus.prototype.refresh = function() {
		this.contents.clear();
		if (this._actor) {
			var x = this.textPadding();
			var lineHeight = this.lineHeight();
			var width = this.contents.width - x * 2;
			this.drawActorName(this._actor, x, 0);
			this.changeTextColor(this.systemColor());
			this.drawText(TMPlugin.MagicSlot.MagicSlot, x, lineHeight, width);
			this.changeTextColor(this.normalColor());
			var text = '' + this._actor.totalMagicSlotCost() + ' / ' + this._actor.magicSlots();
			this.drawText(text, x, lineHeight, width, 'right');
			if (TMPlugin.MagicSlot.MaxMpText) {
				this.changeTextColor(this.systemColor());
				this.drawText(TMPlugin.MagicSlot.MaxMpText.format(TextManager.mp),
											x, lineHeight * 2, width);
				this.changeTextColor(this.normalColor());
				this.drawText(this._actor.mmp, x, lineHeight * 2, width, 'right');
			}
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MagicCommand
	//

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

	Window_MagicCommand.prototype = Object.create(Window_HorzCommand.prototype);
	Window_MagicCommand.prototype.constructor = Window_MagicCommand;

	Window_MagicCommand.prototype.initialize = function(x, y, width) {
		this._windowWidth = width;
		Window_HorzCommand.prototype.initialize.call(this, x, y);
	};

	Window_MagicCommand.prototype.windowWidth = function() {
		return this._windowWidth;
	};

	Window_MagicCommand.prototype.maxCols = function() {
		return TMPlugin.MagicSlot.ActorSelectCommand ? 3 : 2;
	};

	Window_MagicCommand.prototype.makeCommandList = function() {
		this.addCommand(TMPlugin.MagicSlot.EquipCommand, 'equip');
		this.addCommand(TMPlugin.MagicSlot.ClearCommand, 'clear');
		if (TMPlugin.MagicSlot.ActorSelectCommand) {
			this.addCommand(TMPlugin.MagicSlot.ActorSelectCommand, 'actorSelect');
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MagicSlot
	//

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

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

	Window_MagicSlot.prototype.initialize = function(x, y, width) {
		var height = this.fittingHeight(5);
		Window_Selectable.prototype.initialize.call(this, x, y, width, height);
		this._actor = null;
		this.refresh();
	};

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

	Window_MagicSlot.prototype.update = function() {
		Window_Selectable.prototype.update.call(this);
		if (this._itemWindow) {
			var blankSlots = this._actor && this.index() >= 0 ? this._actor.blankMagicSlots() : 0;
			var item = this.item();
			if (item) blankSlots += (+item.meta.magicSlotCost || 1);
			this._itemWindow.setBlankSlots(blankSlots);
		}
	};

	Window_MagicSlot.prototype.maxItems = function() {
		return this._actor ? this._actor.magics().length + this._actor.blankMagicSlots() : 0;
	};

	Window_MagicSlot.prototype.item = function() {
		return this._actor ? this._actor.magics()[this.index()] : null;
	};

	Window_MagicSlot.prototype.drawItem = function(index) {
		if (this._actor) {
			var rect = this.itemRectForText(index);
			var item = this._actor.magics()[index];
			this.changeTextColor(this.normalColor());
			if (item) {
				this.drawItemName(item, rect.x, rect.y, rect.width);
				this.changeTextColor(this.textColor(TMPlugin.MagicSlot.SlotCostColor));
				this.drawText(item.meta.magicSlotCost || '1', rect.x, rect.y, rect.width, 'right');
			} else {
				this.drawText(TMPlugin.MagicSlot.BlankText, rect.x, rect.y, rect.width);
			}
		}
	};

	Window_MagicSlot.prototype.isEnabled = function(index) {
		return true;
	};

	Window_MagicSlot.prototype.isCurrentItemEnabled = function() {
		return this.isEnabled(this.index());
	};

	Window_MagicSlot.prototype.setItemWindow = function(itemWindow) {
		this._itemWindow = itemWindow;
		this.update();
	};

	Window_MagicSlot.prototype.updateHelp = function() {
		Window_Selectable.prototype.updateHelp.call(this);
		this.setHelpWindowItem(this.item());
	};

	//-----------------------------------------------------------------------------
	// Window_MagicItem
	//

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

	Window_MagicItem.prototype = Object.create(Window_ItemList.prototype);
	Window_MagicItem.prototype.constructor = Window_MagicItem;

	Window_MagicItem.prototype.initialize = function(x, y, width, height) {
		Window_ItemList.prototype.initialize.call(this, x, y, width, height);
		this._actor = null;
		this._blankSlots = 0;
	};

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

	Window_MagicItem.prototype.setBlankSlots = function(blankSlots) {
		if (this._blankSlots !== blankSlots) {
			this._blankSlots = blankSlots;
			this.refresh();
			this.resetScroll();
		}
	};

	Window_MagicItem.prototype.includes = function(item) {
		if ($dataSystem.weaponTypes[item.wtypeId] !== TMPlugin.MagicSlot.MagicTypeName) {
			return false;
		}
		if (this._actor.magics().some(function(magic) {
			return item == magic;
		})) return false;
		if (item.meta.equippableActor) {
			var actorId = this._actor.actorId();
			if (!item.meta.equippableActor.split(" ").map(Number).some(function(id) {
				return actorId === id;
			})) return false;
		}
		if (item.meta.equippableClass) {
			var classId = this._actor._classId;
			if (!item.meta.equippableClass.split(" ").map(Number).some(function(id) {
				return classId === id;
			})) return false;
		}
		return this._blankSlots >= +(item.meta.magicSlotCost || 1);
	};

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

	Window_MagicItem.prototype.makeItemList = function() {
		this._data = $gameParty.weapons().filter(function(item) {
			return this.includes(item);
		}, this);
		this._data.push(null);
	};

	Window_MagicItem.prototype.selectLast = function() {
	};

	Window_MagicItem.prototype.playOkSound = function() {
	};

	//-----------------------------------------------------------------------------
	// Scene_Menu
	//

	var _Scene_Menu_createCommandWindow = Scene_Menu.prototype.createCommandWindow;
	Scene_Menu.prototype.createCommandWindow = function() {
		_Scene_Menu_createCommandWindow.call(this);
		this._commandWindow.setHandler('magicEquip', this.commandPersonal.bind(this));
	};

	var _Scene_Menu_onPersonalOk = Scene_Menu.prototype.onPersonalOk;
	Scene_Menu.prototype.onPersonalOk = function() {
		_Scene_Menu_onPersonalOk.call(this);
		if (this._commandWindow.currentSymbol() === 'magicEquip') {
			SceneManager.push(Scene_MagicEquip);
		}
	};

	//-----------------------------------------------------------------------------
	// Scene_MagicEquip
	//

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

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

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

	Scene_MagicEquip.prototype.create = function() {
		Scene_MenuBase.prototype.create.call(this);
		this.createHelpWindow();
		this.createStatusWindow();
		this.createCommandWindow();
		this.createSlotWindow();
		this.createItemWindow();
		this.createActorSelectWindow();
		this.refreshActor();
	};

	Scene_MagicEquip.prototype.start = function() {
		Scene_MenuBase.prototype.start.call(this);
		if (TMPlugin.MagicSlot.ActorSelectCommand) {
			this._actorSelectWindow.refresh();
		}
	};
	
	Scene_MagicEquip.prototype.createStatusWindow = function() {
		this._statusWindow = new Window_MagicStatus(0, this._helpWindow.height);
		this.addWindow(this._statusWindow);
	};

	Scene_MagicEquip.prototype.createCommandWindow = function() {
		var wx = this._statusWindow.width;
		var wy = this._helpWindow.height;
		var ww = Graphics.boxWidth - this._statusWindow.width;
		this._commandWindow = new Window_MagicCommand(wx, wy, ww);
		this._commandWindow.setHelpWindow(this._helpWindow);
		this._commandWindow.setHandler('equip',	this.commandEquip.bind(this));
		this._commandWindow.setHandler('clear',	this.commandClear.bind(this));
		this._commandWindow.setHandler('actorSelect', this.commandActorSelect.bind(this));
		this._commandWindow.setHandler('cancel', this.popScene.bind(this));
		this._commandWindow.setHandler('pagedown', this.nextActor.bind(this));
		this._commandWindow.setHandler('pageup', this.previousActor.bind(this));
		this.addWindow(this._commandWindow);
	};

	Scene_MagicEquip.prototype.createSlotWindow = function() {
		var wx = this._statusWindow.width;
		var wy = this._commandWindow.y + this._commandWindow.height;
		var ww = Graphics.boxWidth - this._statusWindow.width;
		this._slotWindow = new Window_MagicSlot(wx, wy, ww);
		this._slotWindow.setHelpWindow(this._helpWindow);
		this._slotWindow.setHandler('ok', this.onSlotOk.bind(this));
		this._slotWindow.setHandler('cancel', this.onSlotCancel.bind(this));
		this.addWindow(this._slotWindow);
	};

	Scene_MagicEquip.prototype.createItemWindow = function() {
		var wx = 0;
		var wy = Math.max(this._statusWindow.y + this._statusWindow.height,
				this._slotWindow.y + this._slotWindow.height);
		var ww = Graphics.boxWidth;
		var wh = Graphics.boxHeight - wy;
		this._itemWindow = new Window_MagicItem(wx, wy, ww, wh);
		this._itemWindow.setHelpWindow(this._helpWindow);
		this._itemWindow.setHandler('ok',		 this.onItemOk.bind(this));
		this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
		this._slotWindow.setItemWindow(this._itemWindow);
		this.addWindow(this._itemWindow);
	};
	
	Scene_MagicEquip.prototype.createActorSelectWindow = function() {
		if (TMPlugin.MagicSlot.ActorSelectCommand) {
			this._actorSelectWindow = new Window_MenuStatus(0, 0);
			this._actorSelectWindow.setHandler('ok', this.onActorSelectOk.bind(this));
			this._actorSelectWindow.setHandler('cancel', this.onActorSelectCancel.bind(this));
			this._actorSelectWindow.reserveFaceImages();
			this._actorSelectWindow.hide();
			this.addWindow(this._actorSelectWindow);
		}
	};

	Scene_MagicEquip.prototype.refreshActor = function() {
		var actor = this.actor();
		this._statusWindow.setActor(actor);
		this._slotWindow.setActor(actor);
		this._itemWindow.setActor(actor);
	};

	Scene_MagicEquip.prototype.commandEquip = function() {
		this._slotWindow.activate();
		this._slotWindow.select(0);
	};

	Scene_MagicEquip.prototype.commandClear = function() {
		SoundManager.playEquip();
		this.actor().clearMagics();
		this._statusWindow.refresh();
		this._slotWindow.refresh();
		this._commandWindow.activate();
	};

	Scene_MagicEquip.prototype.commandActorSelect = function() {
		this._actorSelectWindow.selectLast();
		this._actorSelectWindow.show();
		this._actorSelectWindow.activate();
	};

	Scene_MagicEquip.prototype.onSlotOk = function() {
		this._itemWindow.activate();
		this._itemWindow.select(0);
	};

	Scene_MagicEquip.prototype.onSlotCancel = function() {
		this._slotWindow.deselect();
		this._commandWindow.activate();
	};

	Scene_MagicEquip.prototype.onItemOk = function() {
		SoundManager.playEquip();
		var slotId = this._slotWindow.index();
		if (slotId > this.actor().magics().length) {
			slotId = this.actor().magics().length;
		}
		this.actor().changeMagic(slotId, this._itemWindow.item());
		this._slotWindow.activate();
		this._slotWindow.refresh();
		this._itemWindow.deselect();
		this._itemWindow.refresh();
		this._statusWindow.refresh();
	};

	Scene_MagicEquip.prototype.onItemCancel = function() {
		this._slotWindow.activate();
		this._itemWindow.deselect();
	};

	Scene_MagicEquip.prototype.onActorSelectOk = function() {
		this._actorSelectWindow.hide();
		$gameParty.setMenuActor($gameParty.members()[this._actorSelectWindow.index()]);
		this.updateActor();
		this.onActorChange();
	};

	Scene_MagicEquip.prototype.onActorSelectCancel = function() {
		this._actorSelectWindow.hide();
		this._commandWindow.activate();
	};

	Scene_MagicEquip.prototype.onActorChange = function() {
		this.refreshActor();
		this._commandWindow.activate();
	};

})();