/*:
 * @plugindesc Allows developers to create skills that summon Actors into the player's party using various parameters.
 * @author SumRndmDde
 *
 * @param Battlelog Message
 * @desc The message that appears in the battle log when an Actor is summoned.
 * @default %1 has been summoned!
 *
 * @param Max Summons
 * @desc The maximum amount of summons allowed in battle.
 * @default 4
 *
 * @param Restrict Per Skill
 * @desc If 'true', then once a Skill has summoned Actors, it will not be able to do so again until they're gone.
 * @default true
 *
 * @param Restrict Per Position
 * @desc If 'true', then a summon cannot be preformed if multiple summons will appear in the same spot.
 * @default true
 *
 * @param == Defaults ==
 * @default
 *
 * @param Default Actor ID
 * @desc The Actor ID used if one is not specified for the Summoned Actor to be based off of.
 * @default 1
 *
 * @param Default Level
 * @desc The level of the Summoned Actor if one is not specified.
 * @default 1
 *
 * @param Default Animation
 * @desc The animation used for the Summoned Actor's intro if one is not specified.
 * @default 51
 *
 * @param Default Exit Ani.
 * @desc The animation used for the Summoned Actor's exit transition if one is not specified.
 * @default 51
 *
 * @param Default Turns
 * @desc The number of turns the Summoned Actor lasts if it's not specified. Use -1 to make it indefinite.
 * @default -1
 *
 * @param Default X Pos
 * @desc The default X position of the Summoned Actor if one is not specified.
 * @default master._homeX - 120
 *
 * @param Default Y Pos
 * @desc The default Y position of the Summoned Actor if one is not specified.
 * @default master._homeY
 *
 * @help
 *
 * Summon Core
 * Version 1.05
 * SumRndmDde
 *
 *
 * This plugin allows developers to create skills that summon Actors into the 
 * player's party using various parameters.
 *
 *
 * ==============================================================================
 *  Setting up Summoning Skill
 * ==============================================================================
 *
 * In order to make a Skill become a Summon Skill, use the following notetag:
 *
 *   <Summon>
 *   Actor ID: x
 *   <End Summon>
 *
 * Simply set "x" to the Actor ID you wish to be summoned.
 *
 *
 * ==============================================================================
 *  Summoning Properties
 * ==============================================================================
 *
 * Various properties can be added to the Summoning Skills. They can be
 * customized within the Summon notetags:
 *
 *   <Summon>
 *   Actor ID: 2
 *   Level: 10
 *   Turns: 2
 *   <End Summon>
 *
 *
 * Here is a list of all the properties available:
 *
 *
 *   Level
 *
 * Determines the level of the summoned Actor. This can be a number or
 * JavaScript code that uses the "actor" variable to reference the user.
 *
 *
 *   Turns
 *
 * Determines the number of turns the summon will last. Set to -1 to make
 * the summon last until the end of the battle or death.
 *
 *
 *   Animation
 *
 * Determines the animation used for when the summon is summoned.
 *
 *
 *   Exit Animation
 *
 * Determines the exit animation used for when the summon leaves.
 *
 *
 *   X
 *
 * Determines the X position of the summon. Can use JavaScript code.
 * If using JavaScript code, "index" refers to the summon's index within the
 * party and "master" refers to the sprite of the summoner.*
 *
 *   Y
 *
 * Determines the Y position of the summon. Can use JavaScript code.
 * If using JavaScript code, "index" refers to the summon's index within the
 * party and "master" refers to the sprite of the summoner.
 *
 *
 * ==============================================================================
 *  Position Examples
 * ==============================================================================
 *
 * If one wants to position the summoned Actor relative to the summoner, 
 * the following code could be used:
 *
 *   <Summon>
 *   Actor ID: 2
 *   X: master._mainX - 120
 *   Y: master._mainY
 *   <End Summon>
 *
 * This would position the summon 120 pixels to the left of the summoner.
 *
 *
 * ==============================================================================
 *  End of Help File
 * ==============================================================================
 * 
 * Welcome to the bottom of the Help file.
 *
 *
 * Thanks for reading!
 * If you have questions, or if you enjoyed this Plugin, please check
 * out my YouTube channel!
 *
 * https://www.youtube.com/c/SumRndmDde
 *
 *
 * Until next time,
 *   ~ SumRndmDde
 *
 */
/*:ja
 * @plugindesc プレイヤーのパーティにアクターを召喚するスキルを作成できます。
 * @author SumRndmDde
 *
 * @param Battlelog Message
 * @text 戦闘ログメッセージ
 * @desc アクターが召喚された時に戦闘ログに表示されるメッセージ
 * @default %1が召喚された！
 *
 * @param Max Summons
 * @text 召喚最大数
 * @desc 戦闘中に召喚できる最大召喚回数
 * @default 4
 *
 * @param Restrict Per Skill
 * @text スキル毎の制限
 * @type boolean
 * @on 有効
 * @off 無効
 * @desc 一度アクターを召喚したスキルは、アクターがいなくなるまで召喚できない
 * @default true
 *
 * @param Restrict Per Position
 * @text 位置毎の制限
 * @type boolean
 * @on 有効
 * @off 無効
 * @desc 同じ場所に複数の召喚が出現する場合、召喚できない
 * @default true
 *
 * @param == Defaults ==
 * @text -- デフォルト --
 * @default
 *
 * @param Default Actor ID
 * @text デフォルトのアクターID
 * @desc 召喚されるアクターのアクターIDが指定されていない場合に使用
 * @default 1
 *
 * @param Default Level
 * @text デフォルトレベル
 * @desc 召喚されるアクターのレベル
 * @default 1
 *
 * @param Default Animation
 * @text デフォルト開始アニメーション
 * @desc 召喚されたアクターのイントロに使用するアニメーション
 * @default 51
 *
 * @param Default Exit Ani.
 * @text デフォルト終了アニメーション
 * @desc 召喚されたアクターの終了時のアニメーションを指定
 * @default 51
 *
 * @param Default Turns
 * @text デフォルトターン数
 * @desc 召喚アクターのターン数を指定
 * 不定にするには-1に
 * @default -1
 *
 * @param Default X Pos
 * @text デフォルトX位置
 * @desc 召喚されたアクターのデフォルトのX位置を指定
 * @default master._homeX - 120
 *
 * @param Default Y Pos
 * @text デフォルトY位置
 * @desc 召喚されたアクターのYの位置を指定
 * @default master._homeY
 *
 * @help
 * 翻訳:ムノクラ
 * https://fungamemake.com/
 * https://twitter.com/munokura/
 *
 * 元プラグイン: http://sumrndm.site/summon-core/
 *
 *
 * Summon Core
 * Version 1.05
 * SumRndmDde
 *
 *
 * このプラグインを使用することで、パラメータを使用して、
 * プレイヤーのパーティにアクターを召喚するスキルを作成できます。
 *
 *
 * ==========================================================================
 *  召喚スキルの設定
 * ==========================================================================
 *
 * スキルを召喚スキルにするには、以下のメモタグを使用します。
 *
 *   <Summon>
 *   Actor ID: x
 *   <End Summon>
 *
 * 召喚したいアクターIDをxに設定します。
 *
 *
 * ==========================================================================
 *  召喚のプロパティ
 * ==========================================================================
 *
 * 召喚スキルには様々なプロパティを追加することができます。
 * これらは召喚メモタグ内でカスタマイズすることができます。
 *
 *   <Summon>
 *   Actor ID: 2
 *   Level: 10
 *   Turns: 2
 *   <End Summon>
 *
 *
 * 全プロパティを紹介します。
 *
 *   Level
 * 召喚されたアクターのレベルを決定します。
 * 数値か、"actor"変数を使って使用者を参照するJavaScriptのコードになります。
 *
 *
 *   Turns
 * 召喚が持続するターン数を指定します。
 * 1に設定すると、戦闘終了か死亡するまで召喚を持続させることができます。
 *
 *
 *   Animation
 * 召喚時に使用するアニメーションを決定します。
 *
 *
 *   Exit Animation
 * 召喚時に使用される終了アニメーションを決定します。
 *
 *
 *   X
 * 召喚のX位置を決定します。
 * JavaScriptコードを使用できます。
 * JavaScriptコードを使用する場合、
 * "index"はパーティ内での召喚士のインデックス、
 * "master"は召喚士のスプライトを指します。
 *
 *
 *   Y
 * 召喚のY位置を決定します。
 * JavaScriptコードを使用できます。
 * JavaScriptコードを使用する場合、
 * "index"はパーティ内での召喚士のインデックス、
 * "master"は召喚士のスプライトを指します。
 *
 *
 * ==========================================================================
 *  ポジション例
 * ==========================================================================
 *
 * 召喚されたアクターを相対的に配置したい場合、
 * 以下のコードを使うことができます。
 *
 *   <Summon>
 *   Actor ID: 2
 *   X: master._mainX - 120
 *   Y: master._mainY
 *   <End Summon>
 *
 * これで召喚士の左に120ピクセルの位置になります。
 *
 *
 * ==========================================================================
 *  ヘルプファイルの終わり
 * ==========================================================================
 *
 * ヘルプファイルの終わりへようこそ。
 *
 * 読んでくれてありがとう!
 * 質問があったり、このプラグインを楽しめたら、
 * 私のYouTubeチャンネルを登録してください!!
 *
 * https://www.youtube.com/c/SumRndmDde
 *
 *
 * 次の機会まで
 *   ~ SumRndmDde
 *
 */

var SRD = SRD || {};
SRD.SummonCore = SRD.SummonCore || {};
SRD.NotetagGetters = SRD.NotetagGetters || [];

var Imported = Imported || {};
Imported["SumRndmDde Summon Core"] = 1.05;

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

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

(function (_, N) {

	"use strict";

	const params = PluginManager.parameters('SRD_SummonCore');

	_.battlelog = String(params['Battlelog Message']);
	_.maxSummons = parseInt(params['Max Summons']);
	_.perSkill = String(params['Restrict Per Skill']).trim().toLowerCase() === 'true';
	_.perPosition = String(params['Restrict Per Position']).trim().toLowerCase() === 'true';

	_.defaults = {
		id: String(params['Default Actor ID']),
		lvl: String(params['Default Level']),
		ani: String(params['Default Animation']),
		exit: String(params['Default Exit Ani.']),
		turn: String(params['Default Turns']),
		x: String(params['Default X Pos']),
		y: String(params['Default Y Pos'])
	};

	_.loadNotetags = function () {
		const data = $dataSkills;
		const regex = /<\s*Summon\s*>([^<>]*)<\s*End\s*Summon\s*>/ig;
		const regex1 = /Actor\s*ID\s*:\s*(.*)/im;
		const regex2 = /Level\s*:\s*(.*)/im;
		const regex3 = /Animation\s*:\s*(.*)/im;
		const regex4 = /Turns\s*:\s*(.*)/im;
		const regex5 = /X\s*:\s*(.*)/im;
		const regex6 = /Y\s*:\s*(.*)/im;
		const regex7 = /Exit\s*Animation\s*:\s*(.*)/im;
		for (let i = 1; i < data.length; i++) {
			const note = data[i].note;
			let match;
			while (match = regex.exec(note)) {
				if (!data[i].summonInfo) {
					data[i].summonInfo = [];
					data[i].scope = 0;
				}
				const stuff = {};
				const info = match[1];
				if (info.match(regex1)) {
					stuff.id = String(RegExp.$1);
				} else {
					stuff.id = _.defaults.id;
				}
				if (info.match(regex2)) {
					stuff.lvl = String(RegExp.$1);
				} else {
					stuff.lvl = _.defaults.lvl;
				}
				if (info.match(regex3)) {
					stuff.ani = String(RegExp.$1);
				} else {
					stuff.ani = _.defaults.ani;
				}
				if (info.match(regex4)) {
					stuff.turn = String(RegExp.$1);
				} else {
					stuff.turn = _.defaults.turn;
				}
				if (info.match(regex5)) {
					stuff.x = String(RegExp.$1);
				} else {
					stuff.x = _.defaults.x;
				}
				if (info.match(regex6)) {
					stuff.y = String(RegExp.$1);
				} else {
					stuff.y = _.defaults.y;
				}
				if (info.match(regex7)) {
					stuff.exit = String(RegExp.$1);
				} else {
					stuff.exit = _.defaults.exit;
				}
				data[i].summonInfo.push(stuff);
			}
		}
	};

	SRD.NotetagGetters.push(_.loadNotetags);

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

	if (!SRD.DataManager_isDatabaseLoaded) {

		SRD.notetagsLoaded = false;
		SRD.DataManager_isDatabaseLoaded = DataManager.isDatabaseLoaded;
		DataManager.isDatabaseLoaded = function () {
			if (!SRD.DataManager_isDatabaseLoaded.apply(this, arguments)) return false;
			if (!SRD.notetagsLoaded) {
				N.forEach(function (func) {
					func.call(this);
				}, this);
				SRD.notetagsLoaded = true;
			}
			return true;
		};

	}

	//-----------------------------------------------------------------------------
	// BattleManager
	//-----------------------------------------------------------------------------

	_.BattleManager_initMembers = BattleManager.initMembers;
	BattleManager.initMembers = function () {
		_.BattleManager_initMembers.apply(this, arguments);
		this.summonsSkillIds = [];
		this.summonsItemIds = [];
		this.summonsXPositions = [];
		this.summonsYPositions = [];
	};

	BattleManager.allSummonMembers = function () {
		return $gameParty.summonMembers();
	};

	_.BattleManager_endTurn = BattleManager.endTurn;
	BattleManager.endTurn = function () {
		_.BattleManager_endTurn.apply(this, arguments);
		this.decrementSummonTurns();
	};

	BattleManager.decrementSummonTurns = function () {
		this.allSummonMembers().forEach(function (battler) {
			if (battler.hasNoTurns()) {
				$gameParty.removeSummon(battler);
			}
		}, this);
	};

	_.BattleManager_endBattle = BattleManager.endBattle;
	BattleManager.endBattle = function (result) {
		_.BattleManager_endBattle.apply(this, arguments);
		if (this.allSummonMembers().length > 0) {
			$gameParty.removeAllSummons();
		}
	};

	//-----------------------------------------------------------------------------
	// Game_BattlerBase
	//-----------------------------------------------------------------------------

	_.Game_BattlerBase_canUse = Game_BattlerBase.prototype.canUse;
	Game_BattlerBase.prototype.canUse = function (item) {
		if (item && item.summonInfo && !this.isActor()) {
			return false;
		}
		return _.Game_BattlerBase_canUse.apply(this, arguments);
	};

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

	_.Game_Actor_initMembers = Game_Actor.prototype.initMembers;
	Game_Actor.prototype.initMembers = function () {
		_.Game_Actor_initMembers.apply(this, arguments);
		this._summons = [];
	};

	Game_Actor.prototype.addSummon = function (summon) {
		this._summons.push(summon);
	};

	Game_Actor.prototype.removeSummon = function (summon) {
		this._summons.splice(this._summons.indexOf(summon), 1);
	};

	_.Game_Actor_refresh = Game_Actor.prototype.refresh;
	Game_Actor.prototype.refresh = function () {
		_.Game_Actor_refresh.apply(this, arguments);
		if (this._hp === 0) {
			this._summons.forEach(function (summon) {
				$gameParty.removeSummon(summon);
			}, this);
			this._summons = [];
		}
	};

	_.Game_Actor_canUse = Game_Actor.prototype.canUse;
	Game_Actor.prototype.canUse = function (item) {
		let result = true;
		if (this.actorId() && item && item.summonInfo && $gameParty.inBattle()) {
			result = this.canUseSummon(item);
		}
		return _.Game_Actor_canUse.apply(this, arguments) && result;
	};

	Game_Actor.prototype.canUseSummon = function (item) {
		if (_.perPosition) {
			for (let i = 0; i < item.summonInfo.length; i++) {
				const info = item.summonInfo[i];
				const x = info.x;
				const y = info.y;
				const id = this.actorId();
				const pos = BattleManager._spriteset.getPositionsForSummons(x, y, id);
				if (BattleManager.summonsXPositions[pos.x] && BattleManager.summonsXPositions[pos.y]) {
					return false;
				}
			}
		}
		if (_.perSkill) {
			const id = item.id;
			if (DataManager.isSkill(item)) {
				if (BattleManager.summonsSkillIds[id] > 0) return false;
			} else {
				if (BattleManager.summonsItemIds[id] > 0) return false;
			}
		}
		if ($gameParty.hasMaxSummons()) return false;
		return true;
	};

	//-----------------------------------------------------------------------------
	// Game_Summon
	//-----------------------------------------------------------------------------

	Game_Summon.prototype = Object.create(Game_Actor.prototype);
	Game_Summon.prototype.constructor = Game_Summon;

	Game_Summon.prototype.initialize = function (actorId, level, turns, introAni, exitAni, masterId) {
		Game_Actor.prototype.initialize.call(this, actorId);
		this._level = level;
		this._turns = turns;
		this._introAnimation = introAni;
		this._exitAnimation = exitAni;
		this.setMasterId(masterId || 0);
		this.recoverAll();
	};

	Game_Summon.prototype.initMembers = function () {
		Game_Actor.prototype.initMembers.call(this);
		this._turns = 0;
		this._masterId = 0;
		this._introAnimation = 0;
		this._exitAnimation = 0;
		this._isReady = false;
		this._sprite_x = "0";
		this._sprite_y = "0";
		this._baseSkillId = 0;
		this._baseSkillType = '';
		this._battleSprite = null;
	};

	Game_Summon.prototype.battleSprite = function () {
		return this._battleSprite;
	};

	Game_Summon.prototype.setBattleSprite = function (sprite) {
		this._battleSprite = sprite;
	};

	Game_Summon.prototype.ready = function () {
		return this._isReady;
	};

	Game_Summon.prototype.setReady = function (ready) {
		this._isReady = ready;
	};

	Game_Summon.prototype.introAnimation = function () {
		return this._introAnimation;
	};

	Game_Summon.prototype.exitAnimation = function () {
		return this._exitAnimation;
	};

	Game_Summon.prototype.masterId = function () {
		return this._masterId;
	};

	Game_Summon.prototype.setMasterId = function (actorId) {
		this._masterId = actorId;
	};

	Game_Summon.prototype.setX = function (x) {
		this._sprite_x = x;
	};

	Game_Summon.prototype.setY = function (y) {
		this._sprite_y = y;
	};

	Game_Summon.prototype.baseSkillId = function () {
		return this._baseSkillId;
	};

	Game_Summon.prototype.baseSkillType = function () {
		return this._baseSkillType;
	};

	Game_Summon.prototype.setSkillId = function (id, type) {
		this._baseSkillId = id;
		this._baseSkillType = type;
		if (type === 's') {
			if (!BattleManager.summonsSkillIds[id]) BattleManager.summonsSkillIds[id] = 0;
			BattleManager.summonsSkillIds[id]++;
		} else if (type === 'i') {
			if (!BattleManager.summonsItemIds[id]) BattleManager.summonsItemIds[id] = 0;
			BattleManager.summonsItemIds[id]++;
		}
	};

	Game_Summon.prototype.getPosition = function () {
		return { x: this._sprite_x, y: this._sprite_y };
	};

	Game_Summon.prototype.hasNoTurns = function () {
		return this._turns === 0;
	};

	Game_Summon.prototype.onTurnEnd = function () {
		Game_Actor.prototype.onTurnEnd.call(this);
		this.decrementTurns();
	};

	Game_Summon.prototype.decrementTurns = function () {
		if (this._turns > 0) {
			this._turns--;
		}
	};

	Game_Summon.prototype.refresh = function () {
		Game_Actor.prototype.refresh.apply(this, arguments);
		if (this._hp === 0) {
			$gameParty.removeSummon(this);
		}
	};

	Game_Summon.prototype.refreshMaster = function () {
		const actor = $gameActors.actor(this.masterId());
		if (actor.hp === 0) {
			$gameParty.removeSummon(this);
		}
	};

	Game_Summon.prototype.canUse = function (item) {
		if (item && item.summonInfo) {
			return false;
		}
		return Game_Actor.prototype.canUse.apply(this, arguments);
	};

	//-----------------------------------------------------------------------------
	// Game_Action
	//-----------------------------------------------------------------------------

	_.Game_Action_makeTargets = Game_Action.prototype.makeTargets;
	Game_Action.prototype.makeTargets = function () {
		if (this._subjectActorId && this.item().summonInfo) {
			return this.createSummons();
		} else {
			return _.Game_Action_makeTargets.apply(this, arguments);
		}
	};

	Game_Action.prototype.createSummons = function () {
		const item = this.item();
		const result = [];
		for (let i = 0; i < item.summonInfo.length; i++) {
			const actor = $gameActors.actor(this._subjectActorId);
			const info = item.summonInfo[i];
			const id = eval(info.id);
			const lvl = eval(info.lvl);
			const turns = eval(info.turn);
			const introAni = eval(info.ani);
			const exitAni = eval(info.exit);
			const summon = $gameParty.summonActor(id, lvl, turns, introAni, exitAni, this._subjectActorId);
			if (!summon) break;
			actor.addSummon(summon);
			summon.setX(info.x);
			summon.setY(info.y);
			if (this.isSkill()) {
				summon.setSkillId(item.id, 's');
			} else if (this.isItem()) {
				summon.setSkillId(item.id, 'i');
			}
			BattleManager._spriteset.registerSummonSprite(summon);
			result.push(summon);
		}
		return result;
	};

	//-----------------------------------------------------------------------------
	// Game_Party
	//-----------------------------------------------------------------------------

	_.Game_Party_initialize = Game_Party.prototype.initialize;
	Game_Party.prototype.initialize = function () {
		_.Game_Party_initialize.apply(this, arguments);
		this._summons = [];
	};

	Game_Party.prototype.summonMembers = function () {
		return this._summons;
	};

	Game_Party.prototype.maxSummonMembers = function () {
		return _.maxSummons;
	};

	Game_Party.prototype.hasMaxSummons = function () {
		return this.summonMembers().length >= this.maxSummonMembers();
	};

	Game_Party.prototype.summonActor = function (actorId, level, turns, introAni, exitAni, masterId) {
		if (this._summons.length <= this.maxSummonMembers()) {
			const summon = new Game_Summon(actorId, level, turns, introAni, exitAni, masterId);
			this._summons.push(summon);
			return summon;
		}
		return false;
	};

	Game_Party.prototype.removeSummon = function (summon) {
		if (this._summons.contains(summon)) {
			this._summons.splice(this._summons.indexOf(summon), 1);
			const actor = $gameActors.actor(summon.masterId());
			actor.removeSummon(summon);
			if (summon.baseSkillType() === 's') {
				BattleManager.summonsSkillIds[summon.baseSkillId()]--;
			} else if (summon.baseSkillType() === 'i') {
				BattleManager.summonsItemIds[summon.baseSkillId()]--;
			}
			BattleManager._spriteset.removeSummonSprite(summon);
			summon.setBattleSprite(null);
			summon = null;
		}
	};

	Game_Party.prototype.removeAllSummons = function () {
		const temp = [];
		const members = this.summonMembers();
		members.forEach(function (mem) {
			temp.push(mem);
		}, this);
		for (let i = 0; i < temp.length; i++) {
			this.removeSummon(temp[i]);
		}
	};

	_.Game_Party_battleMembers = Game_Party.prototype.battleMembers;
	Game_Party.prototype.battleMembers = function () {
		return _.Game_Party_battleMembers.apply(this, arguments).concat(this._summons);
	};

	Game_Party.prototype.rawBattleMembers = function () {
		return _.Game_Party_battleMembers.apply(this, arguments);
	};

	//-----------------------------------------------------------------------------
	// Spriteset_Battle
	//-----------------------------------------------------------------------------

	_.Spriteset_Battle_createActors = Spriteset_Battle.prototype.createActors;
	Spriteset_Battle.prototype.createActors = function () {
		_.Spriteset_Battle_createActors.apply(this, arguments);
		this.createSummons();
	};

	Spriteset_Battle.prototype.updateActors = function () {
		var members = $gameParty.rawBattleMembers();
		for (var i = 0; i < this._actorSprites.length; i++) {
			this._actorSprites[i].setBattler(members[i]);
		}
	};

	Spriteset_Battle.prototype.createSummons = function () {
		this._summonSprites = [];
		for (var i = 0; i < $gameParty.maxSummonMembers(); i++) {
			this._summonSprites[i] = new Sprite_Summon();
			this._battleField.addChild(this._summonSprites[i]);
		}
	};

	_.Spriteset_Battle_battlerSprites = Spriteset_Battle.prototype.battlerSprites;
	Spriteset_Battle.prototype.battlerSprites = function () {
		return _.Spriteset_Battle_battlerSprites.apply(this, arguments).concat(this._summonSprites);
	};

	Spriteset_Battle.prototype.registerSummonSprite = function (battler) {
		for (let i = 0; i < this._summonSprites.length; i++) {
			const summon = this._summonSprites[i];
			if (!summon.hasBattler()) {
				battler.setBattleSprite(summon);
				summon.setBattler(battler);
				this.reorganizeSummonSprites();
				return summon;
			}
		}
		return false;
	};

	Spriteset_Battle.prototype.removeSummonSprite = function (battler) {
		this._summonSprites.forEach(function (summon) {
			if (summon.isBattler(battler)) {
				summon.setBattler(null);
			}
		}, this);
	};

	Spriteset_Battle.prototype.reorganizeSummonSprites = function () {
		const temp = [];
		for (let i = 0; i < this._summonSprites.length; i++) {
			this._battleField.removeChild(this._summonSprites[i]);
			temp.push(this._summonSprites[i]);
		};
		for (let i = 0; i < this._actorSprites.length; i++) {
			this._battleField.removeChild(this._actorSprites[i]);
			temp.push(this._actorSprites[i]);
		};
		temp.sort(function (a, b) {
			if (a.y !== b.y) {
				return a.y - b.y;
			} else {
				return a.spriteId - b.spriteId;
			}
		}.bind(this));
		for (let i = 0; i < temp.length; i++) {
			this._battleField.addChild(temp[i]);
		};
	};

	Spriteset_Battle.prototype.updateSummonMasters = function () {
		const actors = $gameParty.rawBattleMembers();
		const summons = $gameParty.summonMembers();
		for (let i = 0; i < summons.length; i++) {
			if (!summons[i]) continue;
			const masterId = summons[i].masterId();
			if (masterId) {
				for (let j = 0; j < actors.length; j++) {
					if (actors[j].actorId() === masterId) {
						summons[i].battleSprite().setMaster(this._actorSprites[j]);
					}
				}
			}
		}
	};

	Spriteset_Battle.prototype.getPositionsForSummons = function (x, y, id) {
		const actors = $gameParty.rawBattleMembers();
		const index = actors.length;
		for (let i = 0; i < actors.length; i++) {
			if (actors[i].actorId() === id) {
				const master = this._actorSprites[i];
				const result = {};
				result.x = eval(x);
				result.y = eval(y);
				return result;
			}
		}
		return { x: -1, y: -1 };
	};

	//-----------------------------------------------------------------------------
	// Sprite_Summon
	//-----------------------------------------------------------------------------

	Sprite_Summon.prototype = Object.create(Sprite_Actor.prototype);
	Sprite_Summon.prototype.constructor = Sprite_Summon;

	Sprite_Summon.prototype.initialize = function () {
		Sprite_Actor.prototype.initialize.apply(this, arguments);
		this._transitionType = 0;
		this._introStarted = false;
		this._exitAnimation = 0;
		this._masterSprite = null;
	};

	Sprite_Summon.prototype.updateVisibility = function () { };

	Sprite_Summon.prototype.setActorHome = function (index) {
		BattleManager._spriteset.updateSummonMasters();
		const position = this._actor.getPosition();
		const master = this._masterSprite;
		const x = eval(position.x);
		const y = eval(position.y);
		this.setHome(x, y);
		BattleManager.summonsXPositions[x] = true;
		BattleManager.summonsXPositions[y] = true;
	};

	Sprite_Summon.prototype.update = function () {
		Sprite_Actor.prototype.update.call(this);
		this.updateSummonIntro();
		this.updateTransition();
	};

	Sprite_Summon.prototype.updateSummonIntro = function () {
		if (!this._introStarted) {
			if (this._actor && this._actor.ready()) {
				this.setupIntroAnimation();
				this._introStarted = true;
			}
		}
	};

	Sprite_Summon.prototype.updateTransition = function () {
		if (this._summonSprite) {
			if (this._transitionType === 1) {
				this.opacity = Math.floor(((this._maxDuration - this._summonSprite._duration) / this._maxDuration) * 255);
			} else if (this._transitionType === 2) {
				this.opacity = Math.floor((this._summonSprite._duration / this._maxDuration) * 255);
			}
			if (!this._summonSprite.isPlaying()) {
				if (this._transitionType === 2) {
					BattleManager.summonsXPositions[this._homeX] = false;
					BattleManager.summonsXPositions[this._homeY] = false;
					this._introStarted = false;
					this._exitAnimation = 0;
				}
				this._transitionType = 0;
				this._summonSprite = null;
			}
		}
	};

	Sprite_Summon.prototype.setMaster = function (master) {
		this._masterSprite = master;
	};

	Sprite_Summon.prototype.hasBattler = function () {
		return !!this._battler;
	};

	Sprite_Summon.prototype.isBattler = function (battler) {
		return battler === this._battler;
	};

	Sprite_Summon.prototype.setBattler = function (battler) {
		Sprite_Battler.prototype.setBattler.call(this, battler);
		const changed = (battler !== this._actor);
		if (changed) {
			this._actor = battler;
			if (battler) {
				this.setActorHome(battler.index());
			}
			this.startEntryMotion();
			this._stateSprite.setup(battler);
			if (this._actor) {
				this._exitAnimation = this._actor.exitAnimation();
			} else {
				this.setupExitAnimation();
			}
		}
	};

	Sprite_Summon.prototype.startEntryMotion = function () {
		if (this._actor) {
			this.refreshMotion();
			this.startMove(0, 0, 0);
			this.opacity = 0;
		}
	};

	Sprite_Summon.prototype.setupIntroAnimation = function () {
		this.cancelTransitionAnimation();
		if (this._actor.introAnimation() > 0) {
			this.opacity = 0;
			this._transitionType = 1;
			this._summonSprite = new Sprite_Animation();
			this._summonSprite.setup(this._effectTarget, $dataAnimations[this._actor.introAnimation()], false, 4);
			this.parent.addChild(this._summonSprite);
			this._animationSprites.push(this._summonSprite);
			this._maxDuration = this._summonSprite._duration;
		} else {
			this.opacity = 255;
		}
	};

	Sprite_Summon.prototype.setupExitAnimation = function () {
		this.cancelTransitionAnimation();
		if (this._exitAnimation > 0) {
			this.opacity = 255;
			this._transitionType = 2;
			this._summonSprite = new Sprite_Animation();
			this._summonSprite.setup(this._effectTarget, $dataAnimations[this._exitAnimation], false, 4);
			this.parent.addChild(this._summonSprite);
			this._animationSprites.push(this._summonSprite);
			this._maxDuration = this._summonSprite._duration;
		} else {
			this.opacity = 0;
		}
	};

	Sprite_Summon.prototype.cancelTransitionAnimation = function () {
		if (this._summonSprite) {
			this.parent.removeChild(this._summonSprite);
			this._animationSprites = [];
		}
	};

	Sprite_Summon.prototype.isAnimationPlaying = function () {
		if (!BattleManager.isBattleEnd()) {
			return Sprite_Actor.prototype.isAnimationPlaying.apply(this, arguments);
		}
		return false;
	};

	Sprite_Summon.prototype.isMoving = function () {
		if (!BattleManager.isBattleEnd()) {
			return Sprite_Actor.prototype.isMoving.apply(this, arguments);
		}
		return false;
	};

	//-----------------------------------------------------------------------------
	// Window_BattleLog
	//-----------------------------------------------------------------------------

	Window_BattleLog.prototype.initSummonIntros = function (targets) {
		targets.forEach(function (target) {
			target.setReady(true);
			target.result().isSummonedThisTurn = true;
		});
	};

	_.Window_BattleLog_displayFailure = Window_BattleLog.prototype.displayFailure;
	Window_BattleLog.prototype.displayFailure = function (target) {
		if (target.result().isSummonedThisTurn) {
			this.push('addText', _.battlelog.format(target.name()));
			target.result().isSummonedThisTurn = false;
		} else {
			_.Window_BattleLog_displayFailure.apply(this, arguments);
		}
	};

	//-----------------------------------------------------------------------------
	// YEP
	//-----------------------------------------------------------------------------

	if (!Imported.YEP_BattleEngineCore) {

		_.Window_BattleLog_startAction = Window_BattleLog.prototype.startAction;
		Window_BattleLog.prototype.startAction = function (subject, action, targets) {
			const item = action.item();
			if (item.summonInfo) {
				this.push('performActionStart', subject, action);
				this.push('waitForMovement');
				this.push('performAction', subject, action);
				this.push('initSummonIntros', targets.clone());
				this.displayAction(subject, item);
			} else {
				_.Window_BattleLog_startAction.apply(this, arguments);
			}
		};

	} else {

		//Random Compatibility Fixes ;-;

		_.BattleManager_createFollowActions = BattleManager.createFollowActions;
		BattleManager.createFollowActions = function () {
			_.BattleManager_createFollowActions.apply(this, arguments);
			if (this._action.item().summonInfo) this._logWindow.initSummonIntros(this._targets);
		};

		_.Window_Base_drawGauge = Window_Base.prototype.drawGauge;
		Window_Base.prototype.drawGauge = function (x, y, width, rate, color1, color2) {
			if (!rate && rate !== 0) return;
			_.Window_Base_drawGauge.apply(this, arguments);
		};

		Game_Summon.prototype.battler = function () {
			return this.battleSprite();
		};

	}

	if (Imported.YEP_VictoryAftermath) {

		_.Window_VictoryExp_drawItem = Window_VictoryExp.prototype.drawItem;
		Window_VictoryExp.prototype.drawItem = function (index) {
			if (index >= $gameParty.rawBattleMembers().length) return;
			_.Window_VictoryExp_drawItem.apply(this, arguments);
		};

		_.Window_VictoryExp_drawItemGauge = Window_VictoryExp.prototype.drawItemGauge;
		Window_VictoryExp.prototype.drawItemGauge = function (index) {
			if (index >= $gameParty.rawBattleMembers().length) return;
			_.Window_VictoryExp_drawItemGauge.apply(this, arguments);
		};

	}

})(SRD.SummonCore, SRD.NotetagGetters);