ycrpg/js/plugins/MOG_ATB.js

//=============================================================================
// MOG_ATB.js
//=============================================================================

/*:
 * @plugindesc (v0.3 *) Sistema de batalha em tempo real.
 * @author Moghunter
 *
 * @param ATB Mode
 * @desc Definição do Modo de ATB. 
 * 0 Wait / 1 SemiActive-I / 2 SemiActive-II / 3 Full Active  
 * @default 2
 * @type select
 * @option Wait
 * @value 0
 * @option Semi Active I
 * @value 1
 * @option Semi Active II
 * @value 2
 * @option Full Active
 * @value 3 
 * @parent -> EXP <<<<<<<<<<<<<<<<<<<<<<<
 * 
 * @param ATB Max Value
 * @desc Definição do tempo máximo de ATB  (Velocidade).
 * @default 4000
 * @type number 
 *
 * @param Turn Duration
 * @desc Definição da duração do turno.
 * @default 480
 * @type number 
 *
 * @param States Duration
 * @desc Definição da duração das condições.
 * @default 180
 * @type number 
 *
 * @param Escape Duration
 * @desc Definição do tempo para escapar.
 * @default 180
 * @type number 
 *
 * @param Skip Emerge Message
 * @desc Desativar a janela de mensagem de emergir.
 * @default true
 * @type boolean
 *
 * @param Full SE
 * @desc Definição do som quando o ATB atingir o nível máximo.
 * @type file
 * @default audio/se/Book1
 *
 * @param Change Actor Left
 * @desc Definição do botão para mudar o personagem.
 * @default pagedown
 *
 * @param Change Actor Right
 * @desc Definição do botão para mudar o personagem.
 * @default pageup
 *
 * @param Escape Button
 * @desc Definição do botão para escapar.
 * @default cancel
 *
 * @param Escape Layout X
 * @desc Definição da posição do layout de fugir X-axis.
 * @default 600
 * @type number 
 *
 * @param Escape Layout Y
 * @desc Definição da posição do layout de fugir Y-axis.
 * @default 64
 * @type number 
 *
 * @param Escape Gauge X
 * @desc Definição da posição do medidor de fugir X-axis.
 * @default 6
 * @type number 
 *
 * @param Escape Gauge Y
 * @desc Definição da posição do medidor de fugir Y-axis.
 * @default 16
 * @type number 
 * 
 * @help  
 * =============================================================================
 * +++ MOG - Active Time Battle [ATB] (v0.3 *) +++
 * By Moghunter 
 * https://mogplugins.wordpress.com
 * =============================================================================
 * Sistema de batalha em tempo real.
 *
 * =============================================================================
 * IMAGES
 * =============================================================================
 * As imagens deverão ser gravadas na pasta. (img/atb/)
 * Imagens necessárias.
 *
 * Escape_A.png
 * Escape_B.png
 *
 * =============================================================================
 * PLUGIN COMMAND
 * =============================================================================
 * Para definir o modo do ATB utilize o comando abaixo.
 * 
 * atb_mode : MODE
 * 
 * 0 - Wait
 *     - Os inimigos não atacam na seleção de comando.
 * 1 - Semi Active I
 *     - Os inimigos não atacam na seleção de items/skills e seleção de alvo.
 * 2 - Semi Active II
 *     - Os inimigos não atacam na seleção de items/skills.
 * 3 - Full Active
 *     - Os inimigos atacam em qualquer situação.
 *
 * =============================================================================
 * CAST TIME
 * =============================================================================
 * Para definir o tempo de ativar uma ação (magias), defina pelo valor da
 * velocidade (Speed) da ação da habilidade ou item.
 *
 * =============================================================================
 * STATE DURATION
 * =============================================================================
 * Para definir o tempo da duração da condição, defina um valor em 
 *
 * Durations in Turns
 *
 * =============================================================================
 * BUTTONS
 * =============================================================================
 * Q - Selecionar o personagem da direita.
 * W - Selecionar o personagem da esquerda.
 * X - Escapar
 *
 * =============================================================================
 * - WHAT'S  NEW (version 0.3b) 
 * =============================================================================
 * - (BUG FIX)     - Correção de não poder mudar de personagem durante a ação. 
 * 
 */

//=============================================================================
// ** PLUGIN PARAMETERS
//=============================================================================
　　var Imported = Imported || {};
　　Imported.MOG_ATB = true;
　　var Moghunter = Moghunter || {}; 

  　Moghunter.parameters = PluginManager.parameters('MOG_ATB');
    Moghunter.atb_Mode = Number(Moghunter.parameters['ATB Mode'] || 3);
    Moghunter.atb_MaxValue = Number(Moghunter.parameters['ATB Max Value'] || 4000);
	Moghunter.atb_TurnDuration = Number(Moghunter.parameters['Turn Duration'] || 480);
	Moghunter.atb_StatesDuration = Number(Moghunter.parameters['States Duration'] || 180);
	Moghunter.atb_SkipEmerge = String(Moghunter.parameters['Skip Emerge Message'] || 'true');
	Moghunter.atb_EscapeDuration = Number(Moghunter.parameters['Escape Duration'] || 180);
	
    Moghunter.atb_EscapeGaugeX = Number(Moghunter.parameters['Escape Layout X'] || 600); 
    Moghunter.atb_EscapeGaugeY = Number(Moghunter.parameters['Escape Layout Y'] || 64); 
    Moghunter.atb_EscapeGaugeX2 = Number(Moghunter.parameters['Escape Gauge X'] || 6); 
    Moghunter.atb_EscapeGaugeY2 = Number(Moghunter.parameters['Escape Gauge Y'] || 16); 
    Moghunter.atb_EscapeButton = String(Moghunter.parameters['Escape Button'] || 'cancel');	
    Moghunter.atb_FullSE = String(Moghunter.parameters['Full SE'] || 'Book1'); 
    Moghunter.atb_NextActorLeft = String(Moghunter.parameters['Change Actor Left'] || 'pagedown'); 
    Moghunter.atb_NextActorRight = String(Moghunter.parameters['Change Actor Right'] || 'pageup');
	 
//=============================================================================
// ** Game Temp
//=============================================================================

//==============================
// * Initialize
//==============================
var _mog_atb_gtemp_initialize = Game_Temp.prototype.initialize;
Game_Temp.prototype.initialize = function() {
	_mog_atb_gtemp_initialize.call(this);
	this._atbForceHideWindows = false;
	this._atbEscape = [0,1,false];
	this._atbWinData = [false,false,false];
	this._atbWaitTemp = [0,0,0];
	this._atbneedRefWind = false;
	this._atbBattleEnd = false;
	this._atbInTurn = false;
	this._battleEnd = false;
};

//=============================================================================
// ** Game System
//=============================================================================

//==============================
// * Initialize
//==============================
var _mog_atb_gsys_initialize = Game_System.prototype.initialize;
Game_System.prototype.initialize = function() {
	_mog_atb_gsys_initialize.call(this);
	this._atbEventPhase = [0,0,0,false,false];
	this._atbEventPhase[1] = Math.max(Moghunter.atb_TurnDuration,120);
	this._atbEspcapeDuration = Math.max(Moghunter.atb_EscapeDuration,60);
    this._atbMode = [Moghunter.atb_Mode,false];
};

//==============================
// * Play Sound MX 2
//==============================
SoundManager.playSoundMX2 = function(fileName){
   var se = {};
   var file = fileName.split('/');
   var fileReal =  file[file.length - 1];
   se.name = String(fileReal);
   se.pitch = 100;
   se.volume = 100;
   AudioManager.playSe(se);
};  

//=============================================================================
// ** Game_Interpreter
//=============================================================================	

//==============================
// * PluginCommand
//==============================
var _mog_atb_pluginCommand = Game_Interpreter.prototype.pluginCommand
Game_Interpreter.prototype.pluginCommand = function(command, args) {
	_mog_atb_pluginCommand.call(this,command, args)
    this.setATBParInt(command, args);
	return true;
};

//==============================
// * set ATB ParInt
//==============================
Game_Interpreter.prototype.setATBParInt = function(command, args) {
	if (command === "atb_mode" && args[1])  {
		var mode = Math.min(Math.max(Number(args[1]),0),3);
		$gameSystem._atbMode[0] = mode;	
	};
};

//=============================================================================
// ** Game Battler Base
//=============================================================================

//==============================
// * Init Members
//==============================
var _mog_atb_gbbase_initMembers = Game_BattlerBase.prototype.initMembers;
Game_BattlerBase.prototype.initMembers = function() {
	_mog_atb_gbbase_initMembers.call(this);
	this.initATBSetup();
};

//==============================
// * Init ATB Setup
//==============================
Game_BattlerBase.prototype.initATBSetup = function() {
	this._atb = 0;
	this._max_atb = Math.max(Moghunter.atb_MaxValue,100);
	this._wait_atb = 0;
	this._cast_atb = [null,0,1];
	this._atbItem = null;
	this._inSelection = false;
	this._intTurn = false;	
	this._stateTime = Math.max(Moghunter.atb_StatesDuration,60);
	this._stateDuration = [];
	this._buffTime = Math.max(Moghunter.atb_StatesDuration,60);
	this._buffDuration = [0,0,0,0,0,0,0,0];
};

//==============================
// * ATB
//==============================
Game_BattlerBase.prototype.atb = function() {
    return this._atb;
};

//==============================
// * Max ATB
//==============================
Game_BattlerBase.prototype.maxAtb = function() {
    return this._max_atb;
};

//==============================
// * ATB Speed
//==============================
Game_BattlerBase.prototype.atbSpeed = function() {
	return this.agi;
};

//==============================
// * Die
//==============================
var _mog_atb_gbbase_die = Game_BattlerBase.prototype.die;
Game_BattlerBase.prototype.die = function() {
    _mog_atb_gbbase_die.call(this);
	if ($gameParty.inBattle()) {
		if (this.needForceClearSelection()){
			this.refreshCommandSelectionATB(); 
		};
		$gameTemp._atbneedRefWind = true;
		this.clearATB();
    };
};

//==============================
// * Need Force Clear Selection
//==============================
Game_BattlerBase.prototype.needForceClearSelection = function() {
   if (!BattleManager._atbBattlerInput) {return false};
   if (BattleManager._atbBattlerInput[0] != this) {return false};
   if (this.isRestricted()) {return true};
   if (this.isDead()) {return true}
   return false;
};

//==============================
// * Refresh
//==============================
var _mog_atb_gBat_refresh = Game_Battler.prototype.refresh;
Game_Battler.prototype.refresh = function() {
    _mog_atb_gBat_refresh.call(this);
	if (this.needForceClearSelection()){
	 	this.refreshCommandSelectionATB(); 
 	};
};

//==============================
// * refresh Command Selection ATB
//==============================
Game_BattlerBase.prototype.refreshCommandSelectionATB = function() {
	BattleManager.selectionComAtbClear()
	BattleManager._atbBattlerInput = [null,false];
	$gameTemp._atbForceHideWindows = true;	
};

//==============================
// * clear ATB
//==============================
Game_BattlerBase.prototype.clearATB = function() {
    this._atb = 0;
	this._wait_atb = 0;
	this._intTurn = false
	this._atbItem = null;
	this.clearActions()
	this.clearCast();
};

//==============================
// * clear Cast
//==============================
Game_BattlerBase.prototype.clearCast = function() {
    this._cast_atb = [null,0,1];
};

//==============================
// * is Max ATB
//==============================
Game_BattlerBase.prototype.isMaxAtb = function() {
    return this.atb() >= this.maxAtb();
};

//*******************************
// * is Chanting  *(Overwritten)*
//*******************************
Game_Battler.prototype.isChanting = function() {
    if (this._cast_atb[1] > 0) {return true};
};

//==============================
// * is Casting
//==============================
Game_BattlerBase.prototype.isCasting = function() {
    return this._cast_atb[0];
};

//==============================
// * update Count Atb
//==============================
Game_BattlerBase.prototype.updateCountAtb = function() {
	this._atb += this.atbSpeed();
};

//*******************************
// * Can Input    *(Overwritten)*
//*******************************
Game_BattlerBase.prototype.canInput = function() {
	if (!this.isAppeared()) {return false};
	if (this.isRestricted()) {return false};
	if (this.isAutoBattle()) {return false};
	if (!this.isMaxAtb()) {return false};
	if (this.isCasting()) {return false};
	if (this._intTurn) {return false};
	if (this._atbItem) {return false};
	return true;
};

//==============================
// * Can Move Atb
//==============================
Game_BattlerBase.prototype.canMoveAtb = function() {
	if (!this.isAppeared()) {return false};
	if ($gameSystem._atbEventPhase[3]) {return false};
	if (Imported.MOG_BattleCameraFrontal && $gameSystem._atbMode[0] < 3) {
	    if ($gameTemp._bcam.atbwaitFocus && $gameTemp._bcam.sMov) {return false};
	};
	return true;
};

//==============================
// * Can Fill ATB
//==============================
Game_BattlerBase.prototype.canFillATB = function() {
	if (this.restriction() >= 4) {return false};
	if (this._wait_atb > 0) {return false};
	return true;
};

//*******************************
// * On End Turn  *(Overwritten)*
//*******************************
Game_Battler.prototype.onTurnEnd = function() {
    this.clearResult();
};

//==============================
// * clear States
//==============================
var _mog_atb_gbatbase_clearStates = Game_BattlerBase.prototype.clearStates;
Game_BattlerBase.prototype.clearStates = function() {
	_mog_atb_gbatbase_clearStates.call(this);
	this._stateDuration = [];
};

//==============================
// * Reset States Counts
//==============================
var _mog_atb_gbatbase_resetStateCounts = Game_BattlerBase.prototype.resetStateCounts;
Game_BattlerBase.prototype.resetStateCounts = function(stateId) {
    _mog_atb_gbatbase_resetStateCounts.call(this,stateId);
	if (!this._stateDuration[stateId]) {
		this._stateDuration[stateId] = this._stateTime
	};
	if (this._stateDuration[stateId] < 60) {
	    this._stateDuration[stateId] = this._stateTime;
	};
};

//==============================
// * erase State
//==============================
var _mog_atb_gbatbase_eraseState = Game_BattlerBase.prototype.eraseState;
Game_BattlerBase.prototype.eraseState = function(stateId) {
	_mog_atb_gbatbase_eraseState.call(this,stateId);
	delete this._stateDuration[stateId];
};

//==============================
// * update State Turns ATB
//==============================
Game_BattlerBase.prototype.updateStateTurns_ATB = function() {
    this._states.forEach(function(stateId) {
		 if (this._stateDuration[stateId] == null) {
			  this._stateDuration[stateId] = 0
		 }
		 this._stateDuration[stateId]--;
		 if (this._stateDuration[stateId] <= 0) {
			 this._stateDuration[stateId] = this._stateTime;
		 	 if (this._stateTurns[stateId] > 0) {
				 this._stateTurns[stateId]--;
			 };
			 this.executeStatesEffect_ATB(stateId);		 
		 };
	}, this);	
};

//==============================
// * executeStatesEffect_ATB
//==============================
Game_BattlerBase.prototype.executeStatesEffect_ATB = function(stateId) {
	this.regenerateAll();
	this.startDamagePopup();
	if (this._stateTurns[stateId] === 0) {this.eraseState(stateId)};
};

//==============================
// * remove Guard State
//==============================
Game_BattlerBase.prototype.removeGuardState = function(stateId) {
    this.states().forEach(function(state) {
		    for (var i = 0; i < state.traits.length; i++) {
				 var effect = state.traits[i]
				 if (effect.dataId === 1) {
					 this.eraseState(state.id)
				 };
			};
    }, this);
};

//==============================
// * clear Buffs
//==============================
var _mog_atb_gBatbase_clearBuffs = Game_BattlerBase.prototype.clearBuffs;
Game_BattlerBase.prototype.clearBuffs = function() {
	_mog_atb_gBatbase_clearBuffs.call(this);
	this._buffDuration = [0,0,0,0,0,0,0,0];
};

//==============================
// * erase Buff
//==============================
var _mog_atb_gBatbase_eraseBuff = Game_BattlerBase.prototype.eraseBuff;
Game_BattlerBase.prototype.eraseBuff = function(paramId) {
	_mog_atb_gBatbase_eraseBuff.call(this,paramId)
	this._buffDuration[paramId] = 0;
};

//==============================
// * update Buff Turn ATB
//==============================
Game_BattlerBase.prototype.updateBuffTurns_ATB = function() {
    for (var i = 0; i < this._buffTurns.length; i++) {
		if (this._buffDuration[i] == null) {
			 this._buffDuration[i] = 0
		};
		this._buffDuration[i]--;
		if (this._buffDuration[i]  <= 0) {
		    this._buffDuration[i] = this._buffTime;
			if (this._buffTurns[i] > 0) {
				this._buffTurns[i]--;
				this.executeBuffEffect_ATB(i)
			};
		};
    };
};

//==============================
// * executeBuffEffect_ATB
//==============================
Game_BattlerBase.prototype.executeBuffEffect_ATB = function(buffId) {
    if (this._buffTurns[buffId] === 0) {this.removeBuff(buffId)};
};

//=============================================================================
// ** Game Battler
//=============================================================================

//==============================
// * perform Action End
//==============================
var _mog_atb_gBat_performActionEnd = Game_Battler.prototype.performActionEnd;
Game_Battler.prototype.performActionEnd = function() {
	_mog_atb_gBat_performActionEnd.call(this);
	this.setActionState('undecided');
};

//=============================================================================
//=============================================================================
// ** Battle Manager
//=============================================================================
//=============================================================================

//==============================
// * init Members
//==============================
var _mog_atb_btmngr_initMembers = BattleManager.initMembers;
BattleManager.initMembers = function() {
     _mog_atb_btmngr_initMembers.call(this);
	 this.setupATB();
};

//==============================
// * setup ATB
//==============================
BattleManager.setupATB = function() {
   this._atbBattler = null;
   this._atbBattlerInput = [null,false];
   $gameTemp._atbEscape = [0,$gameSystem._atbEspcapeDuration,false];
   $gameTemp._battleEnd = false;
   $gameTemp._atbBattleEnd = false;
   $gameTemp._atbWaitTemp = [0,40,0];
   $gameTemp._atbneedRefWind = false;
   $gameTemp._atbInTurn = false;
   $gameSystem._atbEventPhase[0] = 0;
   $gameSystem._atbEventPhase[3] = false;
};

//==============================
// * clear ATB Base
//==============================
BattleManager.clearATBBase = function() {
   $gameTemp._atbForceHideWindows = true;
   $gameTemp._atbEscape[0] = 0;
   this._atbBattler = null;
   this._atbBattlerInput = [null,false];
   this._actorIndex = -1;
   $gameSystem._atbEventPhase[0] = 0;
   $gameSystem._atbEventPhase[3] = false;   
};

//==============================
// * prepare Initial ATB Value
//==============================
BattleManager.prepareInitialATBValue = function() {
	for (var i = 0; i < $gameParty.members().length; i++) {
		 var battler =  $gameParty.members()[i];
		 battler.clearATB();
		 battler._wait_atb = 5;
		 var per = battler._max_atb * 30 / 100;
		 var value = Math.randomInt(per);
		 if (this._preemptive) {
		     value += (per * 2);
		 };
		 battler._atb = Math.floor(value);
	};
	for (var i = 0; i < $gameTroop.members().length; i++) {
		 var battler =  $gameTroop.members()[i];
         battler.clearATB();
		 battler._wait_atb = 5;	 
		 var per = battler._max_atb * 30 / 100;
		 var value = Math.randomInt(per);
         if (this._surprise) {
		     value += (per * 2);
		 };
		 battler._atb = Math.floor(value);
	};
   this.clearATBBase();
};

//==============================
// * clear ATB Value Party
//==============================
BattleManager.clearATBValueParty = function() {
	for (var i = 0; i < $gameParty.members().length; i++) {
		var battler = $gameParty.members()[i];
	    battler.clearATB();
		battler.setActionState('undecided')
	};
	if ($gameTemp._battleEnd || $gameSystem._atbBattleEnd) {
		for (var i = 0; i < $gameTroop.members().length; i++) {
			var battler = $gameTroop.members()[i];
			battler.clearATB();
		};
	};
    this.clearATBBase();
};

//==============================
// * need Update ATB Basic
//==============================
BattleManager.needUpdate_ATBBasic = function() {
    if (this._phase == 'action') {return false}; 
    if (this._phase == 'turn') {return false};
	if ($gameTemp._atbBattleEnd) {return false};
	if ($gameMessage.isBusy()) {return false};
	if ($gameTemp._battleEnd) {return false};
	if ($gameSystem._atbEventPhase[3]) {return false};
	if ($gameTemp._atbWaitTemp[0] > 0) {return false}
	if ($gameTemp._atbWaitTemp[1] > 0) {return false}
	if ($gameSystem._atbMode[1]) {return false};
    return true;
};

//==============================
// * need Update ATB
//==============================
BattleManager.needUpdate_ATB = function() {
    if (this._phase === 'action') {return false}; 
    if (this._phase === 'turn') {return false};
	if (BattleManager.isBusy()) {return false};
	if ($gameTemp._atbInTurn) {return false};
    return true;
};

//==============================
// * Update ATB
//==============================
BattleManager.update_ATB = function() {
	if (this.actor()) {this.updateCheckActorPar(this.actor())};
	this.allBattleMembers().forEach(function(battler) {
    		if (battler.canMoveAtb() && !battler.isDead()) {this.updateBattlers_ATB(battler)}; 
    }, this);
};

//==============================
// * need Force Clear Command
//==============================
BattleManager.needForceClearCommand = function(battler) {
	if (!battler) {return true};
	if (battler.restriction() > 0) {return true};
	if (battler._intTurn) {return true};
	if (!battler.isMaxAtb()) {return true};
	if (!battler.currentAction()) {return true};
	if (battler.isCasting()) {return true};
	return false;
};

//==============================
// * Update Check Actor Par
//==============================
BattleManager.updateCheckActorPar = function(battler) {
	if (this.needForceClearCommand(battler)) {
		if (battler) {
			battler._intTurn = false
			battler._atbItem = null;
			battler.clearActions()
			battler.clearCast();
		};
	    this.selectionComAtbClear();
	};
};

//==============================
// * Update Battlers ATB
//==============================
BattleManager.updateBattlers_ATB = function(battler) {
	if (battler._wait_atb > 0) {battler._wait_atb--};
	if (battler.canFillATB()) {this.updateFill_ATB(battler)};
    this.updateStateBuffTurn_ATB(battler);
};

//==============================
// * Update State Buff Turn_ATB
//==============================
BattleManager.updateStateBuffTurn_ATB = function(battler) {
    battler.updateStateTurns_ATB();
	battler.updateBuffTurns_ATB();
};

//==============================
// * update par Correction
//==============================
BattleManager.updateParCorretionBattler_ATB = function(battler) {
    battler._intTurn = false;
	battler._atbItem = null;
};

//==============================
// * update Fill ATB
//==============================
BattleManager.updateFill_ATB = function(battler) {
    if (!battler.isMaxAtb()) {
    	battler.updateCountAtb();
		this.updateParCorretionBattler_ATB(battler)
		if (battler.isMaxAtb()) {this.executeATBFullEffect(battler)};
	} else {
        this.updateBattlerFull_ATB(battler);
    };
};

//==============================
// * executeATBFullEffect
//==============================
BattleManager.executeATBFullEffect = function(battler) {
	if (battler._atb > battler._max_atb) {battler._atb = battler._max_atb};
    if (battler.isActor()) {SoundManager.playSoundMX2(Moghunter.atb_FullSE)};
	battler.removeGuardState();
};

//==============================
// * update Battler Full ATB
//==============================
BattleManager.updateBattlerFull_ATB = function(battler) {
    if (!this._atbBattler) {
	    if (battler.isCasting(battler)) {
		   this.updateATBCast_ATB(battler);
    	} else {
		   this.prepareNextSubject_ATB(battler);
		};
	};
};

//==============================
// * update Battler Full ATB
//==============================
BattleManager.updateATBCast_ATB = function(battler) {
	 battler._cast_atb[1]++;
	 if (battler._cast_atb[1] >= battler._cast_atb[2]) {this.prepareNextSubjectCast_ATB(battler);};
};
 
//==============================
// * update Escape
//==============================
BattleManager.canEscape_ATB = function(active) {
	if (!active) {return false};
	if (!this._canEscape) {return false};
	if (!Input.isPressed(Moghunter.atb_EscapeButton)) {return false};
	return true;
};
 
//==============================
// * update Escape ATB
//==============================
BattleManager.updateEscape_ATB = function(active) {
	if ($gameTemp._atbEscape[2]) {return};
    if (this.canEscape_ATB(active)) {
		$gameTemp._atbEscape[0]++;
		if ($gameTemp._atbEscape[0] >= $gameTemp._atbEscape[1]) {
			$gameTemp._atbEscape[2] = true;
	     	$gameTemp._atbEscape[0] = $gameTemp._atbEscape[1];
            this.executeEscape_ATB();
	    };
	} else {
	   if ($gameTemp._atbEscape[0] > 0) {
		   $gameTemp._atbEscape[0] -= 2;
		   if ($gameTemp._atbEscape <= 0) {
			   $gameTemp._atbEscape[0] = 0;
		   };
	   };
	};
};

//==============================
// * execute Escape ATB
//==============================
BattleManager.executeEscape_ATB = function() {
	this._escapeRatio = 100;
	this.processEscape();
	$gameTemp._battleEnd = true;
	$gameTemp._atbBattleEnd = true;
	this.selectionComAtbClear();
	this._escaped = true;
	this.clearATBValueParty();
};

//==============================
// * prepare Next Subject Cast
//==============================
BattleManager.prepareNextSubjectCast_ATB = function(battler) {
	var item = battler._cast_atb[0];
    if (battler.canUse(item)) {
        this._atbBattler = battler;
		this._atbBattler._atbItem = item;
	} else {
		battler.clearATB();
	};
};

//==============================
// * prepare Next Subject ATB
//==============================
BattleManager.prepareNextSubject_ATB = function(battler) {
    if (battler.isEnemy()) {
	    this.prepareActionEnemy(battler);
	} else {
		if (battler.isConfused()) {  
		    this.prepareConfusionActionActor(battler);
    	} else if (this.needPrepareSelection(battler)) {	
			this.prepareCommandSelection(battler);
		} else {;
			if (battler._atbItem) {
				this._atbBattler = battler;
				battler._intTurn = true;
			};
		};
	};
};

//==============================
// * prepare Confusion Action
//==============================
BattleManager.prepareConfusionActionActor = function(battler) {
	battler.clearActions()
    battler.makeActions();
	var action = battler.currentAction();
	if (action && action.item() && battler.canUse(action.item())) {
	    battler._atbItem = action.item()
        this._atbBattler = battler;
	} else {
		battler.clearATB();
	};
};

//==============================
// * need Prepare Action Actor
//==============================
BattleManager.needPrepareActionActor = function(action) {
	if (!action) {return false};
	if (!this._atbBattlerInput) {return false};
	if (!this._atbBattlerInput[0]) {return false};
	if (!this._atbBattlerInput[0].currentAction()) {return false};
	if (!this._atbBattlerInput[0].currentAction().item()) {return false};
	return true;
};

//==============================
// * selection Com Atb Cler
//==============================
BattleManager.selectionComAtbClear = function() {
   var action = BattleManager.inputtingAction();
   var actor = this.actor();
   var active = false
   if (this.needPrepareActionActor(action)) {
       this.prepareActionActor(this._atbBattlerInput[0]);
	   active = true;  
   };
   this._atbBattlerInput = [null,false];
   this._actorIndex = -1;
   if (actor) {
	   if (!this._atbBattler && active && !actor.isCasting()) {
		   this.updateBattlerFull_ATB(actor)
	   } else {
	       actor.setActionState('done');
	   };
    };
};

//*******************************
// * start Input  *(Overwritten)*
//*******************************
BattleManager.startInput = function() {
	if (!this._atbBattler) {return};
	this._atbBattler._intTurn = true;
	this.startTurn();
};

//==============================
// * needPrepare Action Actor
//==============================
BattleManager.prepareActionActor = function(battler) {
	var action = battler.currentAction();
	if (action && action.item() && battler.canUse(action.item())) {
		var castTime = Math.abs(action.item().speed);
		if (castTime > 0 && battler.guardSkillId() != action.item().id) {
			battler._cast_atb = [action.item(),0,castTime];
		} else {
			battler._atbItem = action.item();
		};
	} else {
		battler.clearATB();
	};
};

//==============================
// * prepare Action Enemy
//==============================
BattleManager.prepareActionEnemy = function(battler) {
	battler.makeActions();
	var action = battler.currentAction();
	if (action && action.item() && battler.canUse(action.item())) {
	    battler._atbItem = action.item();
		var castTime = Math.abs(action.item().speed)
		if (castTime > 0 && battler.guardSkillId() != action.item().id) {
			battler._cast_atb = [action.item(),0,castTime];
		} else {
			this._atbBattler = battler;
		};
	} else {
		battler.clearATB();
	};
};

//==============================
// * end Action
//==============================
var _mog_atb_bMngr_endAction = BattleManager.endAction;
BattleManager.endAction = function() {
    _mog_atb_bMngr_endAction.call(this);
	if (this._subject) { 
		this._subject.clearATB();
		this._subject._wait_atb = 5;
	};
	$gameTemp._atbInTurn = false;
};

//*******************************
// * updateTurnEnd (Overwritten)*
//*******************************
BattleManager.updateTurnEnd = function() {
    this._atbBattler = null;
	this._phase = 'start'
	$gameTemp._atbInTurn = false;
};

//*******************************
// * get Next Subject *(Overwritten)*
//*******************************
BattleManager.getNextSubject = function() {
    for (;;) {
        var battler = this._actionBattlers.shift();
        if (!battler) {
            return null;
        }
        if (battler.isBattleMember() && battler.isAlive() && battler._intTurn) {
            return battler;
        };
    };
};

//*******************************
// * is Inputting *(Overwritten)*
//*******************************
BattleManager.isInputting = function() {
    return this._atbBattlerInput[0];
};

//==============================
// * gget Available Actors
//==============================
BattleManager.getAvailableActors = function(index,value) {	
    var battler = null 	
	if (value > 0) {
		for (var i = index; i < $gameParty.battleMembers().length; i++) {
			var actor = $gameParty.battleMembers()[i];
			if (actor && actor.canInput() && this.actor() != actor) {
				battler = actor;
				break;
			};
		};
	} else if (value < 0) {
		for (var i = index; i >= 0; i--) {
			var actor = $gameParty.battleMembers()[i];
			if (actor && actor.canInput() && this.actor() != actor) {
				battler = actor;
				break;
			};
		};
	};
	return battler;
};

//==============================
// * change Actor Button
//==============================
BattleManager.changeActorButton_ATB = function(value) {
	var currentActor = this.actor();
	var battler = null;
	var index = this._actorIndex;
	var maxBatMembers = $gameParty.battleMembers().length
	index += value;
	if (index >= maxBatMembers) {
		index = 0;
	} else if (index < 0) {
		index = maxBatMembers - 1;
	};
	if (value > 0) {
	   battler = this.getAvailableActors(index,value);
	   if (!battler) {
		   battler = this.getAvailableActors(0,value); 
	   };
	} else if (value < 0) {	
	   battler = this.getAvailableActors(index,value);
	   if (!battler) {
		   battler = this.getAvailableActors(maxBatMembers - 1,value); 
	   };	
	};	
	if (battler) {
		currentActor.clearActions()
		SoundManager.playCursor();
		this.selectionComAtbClear()
		this.prepareCommandSelection(battler);
		currentActor.setActionState('undecided')
	};
};

//==============================
// * prepare Command Selection
//==============================
BattleManager.setActorIndexATB = function(battler) {
	for (var i = 0; i < $gameParty.members().length; i++) {
		 var actor = $gameParty.members()[i];
         if (battler === actor) {return i};
 	};			
	return -1;
};

//==============================
// * prepare Command Selection
//==============================
BattleManager.prepareCommandSelection = function(battler) {
	battler.clearActions()
	this._atbBattlerInput = [battler,false];
	this._actorIndex = this.setActorIndexATB(battler);
	battler.makeActions();
	battler._atbItem = null;
	battler.setActionState('inputting');
};

//==============================
// * need Prepare Selection
//==============================
BattleManager.needPrepareSelection = function(battler) {
	if (this._atbBattlerInput[0]) {return false};
	if (!battler.canInput()) {return false};
	if (battler._atbItem) {return false};
	if (battler._intTurn) {return false};
	return true
};

//==============================
// * end Battle
//==============================
var _mog_atb_btmngr_endBattle = BattleManager.endBattle;
BattleManager.endBattle = function(result) {
	$gameTemp._atbForceHideWindows = true;
	this.clearATBValueParty();
	_mog_atb_btmngr_endBattle.call(this,result); 
};

//==============================
// * can Use Item ATB
//==============================
BattleManager.canUseItemATB = function() {
	if (!this._atbBattler._atbItem) {return false};	
	if (!this._atbBattler.canUse(this._atbBattler._atbItem)) {return false};
	return true;
};

//*******************************
// * start Turn   *(Overwritten)*
//*******************************
BattleManager.startTurn = function() {
   $gameTemp._atbInTurn = false;
   if (!this._atbBattler) {return};	
   if (!this.canUseItemATB()) {
	   this._atbBattler.clearATB();
       this._atbBattler = null;
	   this._phase = 'start'
	   return;
   };
   this._phase = 'turn';
   $gameTemp._atbInTurn = true;
   this._actionBattlers = [this._atbBattler]
   if (this._atbBattler.isActor()) {this._atbBattler.requestMotionRefresh()};
   this._atbBattler.requestMotionRefresh()
   this._logWindow.startTurn();
};

//==============================
// * can Event Turn ATB
//==============================
BattleManager.canUpdateEventTurnATB = function() {
	if ($gameSystem._atbEventPhase[3]) {return false};
    return true;
};

//==============================
// * Update Event Turn ATB
//==============================
BattleManager.updateEventTurnATB = function() {
    $gameSystem._atbEventPhase[0]++;
	if ($gameSystem._atbEventPhase[0] >= $gameSystem._atbEventPhase[1]) {
		$gameSystem._atbEventPhase[0] = 0;
		this.refreshEventPhase_ATB()
	};
};

//==============================
// * can Event Phase
//==============================
BattleManager.canUpdateEventPhase = function() {
	if ($gameTemp._battleEnd) {return false};
    return $gameSystem._atbEventPhase[3];
}; 

//==============================
// * Update Event Phase
//==============================
BattleManager.updateEventPhase = function() {
	var active = $gameSystem._atbEventPhase[3];
    if (this.isActionForced()) {
        this.processForcedAction();
        $gameSystem._atbEventPhase[3] = true;
    } else {
        $gameSystem._atbEventPhase[3] = this.updateEventMain();
    };	
	if (active != $gameSystem._atbEventPhase[3]) {
		$gameTemp._atbWinData[1] = true;
		$gameTemp._atbWaitTemp[0] = 10;
	};
}; 

//==============================
// * refresh Event Phase ATB
//==============================
BattleManager.refreshEventPhase_ATB = function() {
	$gameTroop.increaseTurn();
    $gameSystem._atbEventPhase[3] = this.updateEventMain();
	$gameTemp._atbWinData[0] = $gameSystem._atbEventPhase[3];
};

//==============================
// * display Start Messages
//==============================
var _mog_atb_BatMngr_displayStartMessages = BattleManager.displayStartMessages;
BattleManager.displayStartMessages = function() {
	if (String(Moghunter.atb_SkipEmerge) == 'true') {return};
	_mog_atb_BatMngr_displayStartMessages.call(this);
};

//==============================
// * processVictory
//==============================
var _mog_atbSprt_processVictory = BattleManager.processVictory;
BattleManager.processVictory = function() {
	 $gameTemp._battleEnd = true;
    _mog_atbSprt_processVictory.call(this);	 
};

//==============================
// * processAbort
//==============================
var _mog_atbSprt_processAbort = BattleManager.processAbort;
BattleManager.processAbort = function() {
	 $gameTemp._battleEnd = true;
	_mog_atbSprt_processAbort.call(this);	 
};

//==============================
// * processDefeat
//==============================
var _mog_atbSprt_processDefeat = BattleManager.processDefeat;
BattleManager.processDefeat = function() {
	 $gameTemp._battleEnd = true;
	_mog_atbSprt_processDefeat.call(this);	 
};

//=============================================================================
//=============================================================================
// ** Scene Battle
//=============================================================================
//=============================================================================

//==============================
// * Start
//==============================
var _mog_atb_sBat_start = Scene_Battle.prototype.start;
Scene_Battle.prototype.start = function() {
	_mog_atb_sBat_start.call(this);
	BattleManager.prepareInitialATBValue();
	$gameSystem._atbEventPhase[3] = BattleManager.updateEventMain();
};

//*******************************
// * Update Battle Process  *(Overwritten)*
//*******************************
Scene_Battle.prototype.updateBattleProcess = function() {
	if (Imported.MOG_EmergeMotion && $gameTemp.needSkipBattleProcessEM()) {
		$gameTemp._emerging[1]--;
		if ($gameTemp._emergingInt > 0) {$gameTemp._emergingInt--};
		return;
	};	
	this.updateCommandsATB();
	if (!BattleManager.isAborting() || BattleManager.isBattleEnd()) {
		if (BattleManager.canUpdateEventPhase()) {BattleManager.updateEventPhase()};
		if (BattleManager.needUpdate_ATBBasic()) {
			if (BattleManager.canUpdateEventTurnATB()) {BattleManager.updateEventTurnATB()};
			BattleManager.update_ATB();
			if ($gameSystem._atbMode[0] > 0 && !$gameTemp._atbInTurn) {
			    BattleManager.updateEscape_ATB(this._actorCommandWindow.active);
			};
			
		};
		if ($gameSystem._atbMode[0] === 0) {
	    	BattleManager.updateEscape_ATB(this._actorCommandWindow.active);
		};
        BattleManager.update();
        if (this.canStartCommandSelection()) {
			BattleManager._atbBattlerInput[1] = true
			this.changeInputWindow()
		};
    };
	if (Imported.MOG_BalloonActionName) {this.updateBalloonName()};
};

//==============================
// * update
//==============================
var _mog_atb_sBat_update = Scene_Battle.prototype.update;
Scene_Battle.prototype.update = function() {
	_mog_atb_sBat_update.call(this);
	this.updateAtbScBat();
};
	
//==============================
// * update Atb Sc Bat
//==============================
Scene_Battle.prototype.updateAtbScBat = function() {
    if ($gameTemp._atbForceHideWindows) {this.forceHideWindows()};	
	if ($gameTemp._atbWinData[0]) {this.forceHideWindowsTemp()};
	if ($gameTemp._atbWinData[1]) {this.loadWindowAtbData()};
	if ($gameTemp._atbneedRefWind) {this.forceRefreshWindowATB()};
	if ($gameTemp._atbWaitTemp[0] > 0) {$gameTemp._atbWaitTemp[0]--};
	if ($gameTemp._atbWaitTemp[1] > 0) {$gameTemp._atbWaitTemp[1]--};
	$gameSystem._atbMode[1] = !this.canUpdateAtbMode();
	if (this._actorCommandWindow.isClosed() && this._actorCommandWindow.active && BattleManager.actor()) {
		this._actorCommandWindow.open();
	};
};

//==============================
// * force Refresh WindowATB
//==============================
Scene_Battle.prototype.forceRefreshWindowATB = function() {
	$gameTemp._atbneedRefWind = false;
    if (this._enemyWindow.active) {
		if (this._enemyWindow.enemy().isDead()) {
			this._enemyWindow.refresh()
			this._enemyWindow.select(0);
			if (!this._enemyWindow.enemy()) {
				this.onEnemyCancel();
			};
		};
	};
};

//==============================
// * can Update Atb Mode
//==============================
Scene_Battle.prototype.canUpdateAtbMode = function() {
	if ($gameSystem._atbMode[0] === 0) {
	    if (this._partyCommandWindow.active) {return false};
		if (this._actorCommandWindow.active) {return false};
	    if (this._actorWindow.active) {return false};
		if (this._enemyWindow.active) {return false};
		if (this._skillWindow.active) {return false};
		if (this._itemWindow.active) {return false};
	} else if ($gameSystem._atbMode[0] === 1) {
	    if (this._actorWindow.active) {return false};
		if (this._enemyWindow.active) {return false};
		if (this._skillWindow.active) {return false};
		if (this._itemWindow.active) {return false};
	} else if ($gameSystem._atbMode[0] === 2) {
		if (this._skillWindow.active) {return false};
		if (this._itemWindow.active) {return false};				
	};
	return true;
};

//==============================
// * forceHideWindowsTemp
//==============================
Scene_Battle.prototype.forceHideWindowsTemp = function() {
	$gameTemp._atbWinData[0] = false;
    this.saveWindowAtbData();
	this.disableAllWindowATB();
};

//==============================
// * create Display Objects
//==============================
var _mog_atb_sBat_createDisplayObjects = Scene_Battle.prototype.createDisplayObjects;
Scene_Battle.prototype.createDisplayObjects = function() {
	_mog_atb_sBat_createDisplayObjects.call(this);
	this.saveWindowAtbData();
};

//==============================
// * load Window Atb Data
//==============================
Scene_Battle.prototype.disableAllWindowATB = function() {
	this._partyCommandWindow.visible = false;
	this._partyCommandWindow.active = false;	
	this._actorCommandWindow.visible = false;
	this._actorCommandWindow.active = false;	
	this._actorWindow.visible = false;
	this._actorWindow.active = false;
	this._enemyWindow.visible = false;
	this._enemyWindow.active = false;
	this._skillWindow.visible = false;
	this._skillWindow.active = false; 
	this._itemWindow.visible = false;
	this._itemWindow.active = false;
};

//==============================
// * save Window Atb Data
//==============================
Scene_Battle.prototype.saveWindowAtbData = function() {
	$gameTemp._atbWinData[0] = false;
    this._partyCommandWindowData = {};
	this._partyCommandWindowData.visible = this._partyCommandWindow.visible;
	this._partyCommandWindowData.active = this._partyCommandWindow.active;
	
    this._actorCommandWindowData = {};
	this._actorCommandWindowData.visible = this._actorCommandWindow.visible;
	this._actorCommandWindowData.active = this._actorCommandWindow.active;	
	
    this._actorWindowData = {};
	this._actorWindowData.visible = this._actorWindow.visible;
	this._actorWindowData.active = this._actorWindow.active;

	this._enemyWindowData = {};
	this._enemyWindowData.visible = this._enemyWindow.visible;
	this._enemyWindowData.active = this._enemyWindow.active;

	this._skillWindowData = {};
	this._skillWindowData.visible = this._skillWindow.visible;
	this._skillWindowData.active = this._skillWindow.active;
   
    this._itemWindowData = {};
	this._itemWindowData.visible = this._itemWindow.visible;
	this._itemWindowData.active = this._itemWindow.active;
};

//==============================
// * load Window Atb Data
//==============================
Scene_Battle.prototype.loadWindowAtbData = function() {
	$gameTemp._atbWinData[1] = false;
	if (!this._actorWindowData) {return};
	this._partyCommandWindow.visible = this._partyCommandWindowData.visible;
	this._partyCommandWindow.active = this._partyCommandWindowData.active;
	
	this._actorCommandWindow.visible = this._actorCommandWindowData.visible;
	this._actorCommandWindow.active = this._actorCommandWindowData.active;	
	if (this._actorCommandWindow.active) {
        this._actorCommandWindow.open();
	};
	this._actorWindow.visible = this._actorWindowData.visible;
	this._actorWindow.active = this._actorWindowData.active;

	this._enemyWindow.visible = this._enemyWindowData.visible;
	this._enemyWindow.active = this._enemyWindowData.active;
	
	this._skillWindow.visible = this._skillWindowData.visible;
	this._skillWindow.active = this._skillWindowData.active;
   
	this._itemWindow.visible = this._itemWindowData.visible;
	this._itemWindow.active = this._itemWindowData.active;
};

//==============================
// * force Hide Windows
//==============================
Scene_Battle.prototype.forceHideWindows = function() {
    $gameTemp._atbForceHideWindows = false;
    this._partyCommandWindow.close();
	this._partyCommandWindow.active = false;
    this._actorCommandWindow.close();
    this._actorCommandWindow.active = false;
	this._actorWindow.hide();
	this._actorWindow.active = false;
	this._enemyWindow.hide();

	this._enemyWindow.active = false;
    this._skillWindow.hide();
	this._skillWindow.active = false;
    this._itemWindow.hide();
	this._itemWindow.active = false;
};

//==============================

// * can Start Command Selection
//==============================
Scene_Battle.prototype.canStartCommandSelection = function() {
	if (!BattleManager._atbBattlerInput[0]) {return false};
	if (BattleManager._atbBattlerInput[1]) {return false};
	return true;
};

//==============================
// * update Commands ATB
//==============================
Scene_Battle.prototype.updateCommandsATB = function() {
    if (this._actorCommandWindow.active) {
		if (Input.isTriggered(Moghunter.atb_NextActorLeft)) {
			BattleManager.changeActorButton_ATB(1);
		} else if (Input.isTriggered(Moghunter.atb_NextActorRight)) {
			BattleManager.changeActorButton_ATB(-1);
		};
	};
};

//*******************************
// * Select Next Command  *(Overwritten)*
//*******************************
Scene_Battle.prototype.selectNextCommand = function() {
   BattleManager.selectionComAtbClear();
   this.endCommandSelection();
};

//==============================
// * create Actor Command Window
//==============================
var _mog_atb_createActorCommandWindow = Scene_Battle.prototype.createActorCommandWindow;
Scene_Battle.prototype.createActorCommandWindow = function() {
	_mog_atb_createActorCommandWindow.call(this)
    this._actorCommandWindow.setHandler('cancel', null);
};

//=============================================================================
//=============================================================================
// ** SPRITES
//=============================================================================
//=============================================================================


//==============================
// * load ATB Icon
//==============================
ImageManager.loadATBIcon = function(filename) {
	return this.loadBitmap('img/atb/', filename, 0, true);
};	

//=============================================================================
// ** Window Battle Actor
//=============================================================================

//==============================
// * Update
//==============================
var _mog_atb_wBatActor_update = Window_BattleActor.prototype.update;
Window_BattleActor.prototype.update = function() {
	if (!BattleManager.actor()) {return};
	_mog_atb_wBatActor_update.call(this);
};

//=============================================================================
// ** Window Battle Enemy
//=============================================================================

//==============================
// * Update
//==============================
var _mog_atb_wBatEnemy_update = Window_BattleEnemy.prototype.update;
Window_BattleEnemy.prototype.update = function() {
	if (!BattleManager.actor()) {return};
	_mog_atb_wBatEnemy_update.call(this);
};

//=============================================================================
// ** Window Actor Command
//=============================================================================

//==============================
// * Update
//==============================
var _mog_atb_wActCom_processOk = Window_ActorCommand.prototype.processOk;
Window_ActorCommand.prototype.processOk = function() {
	if (!BattleManager.actor()) {return};
	if ($gameTroop.isAllDead()) {return};
	_mog_atb_wActCom_processOk.call(this);
};

//*******************************
// * cursor Page Down  *(Overwritten)*
//*******************************
Window_ActorCommand.prototype.cursorPagedown = function() {
};

//*******************************
// * cursor Page UP  *(Overwritten)*
//*******************************
Window_ActorCommand.prototype.cursorPageup = function() {
};

//=============================================================================
// ** Sprite Actor
//=============================================================================

//==============================
// * is Moving
//==============================
Sprite_Actor.prototype.isMoving = function() {
	if (this._actor && !this._actor._intTurn) {return false};
    return this._movementDuration > 0;
};

//=============================================================================
// ** Scene Base
//=============================================================================

//==============================
// ** create Hud Field
//==============================
Scene_Base.prototype.createHudField = function() {
	this._hudField = new Sprite();
	this._hudField.z = 10;
	this.addChild(this._hudField);
};

//==============================
// ** sort MZ
//==============================
Scene_Base.prototype.sortMz = function() {
   this._hudField.children.sort(function(a, b){return a.mz-b.mz});
};


//==============================
// * Create Escape Gauge ATB
//==============================
Scene_Base.prototype.createEscapeGaugeATB = function() {	
    this._escapeGaugeATB = new EscapeGaugeATB();
	this._escapeGaugeATB.mz = 140;
	this._hudField.addChild(this._escapeGaugeATB);
};

//=============================================================================
// ** Scene Battle
//=============================================================================

//==============================
// ** create Spriteset
//==============================
var _mog_atbEscapeGauge_sbattle_createSpriteset = Scene_Battle.prototype.createSpriteset;
Scene_Battle.prototype.createSpriteset = function() {
	_mog_atbEscapeGauge_sbattle_createSpriteset.call(this);
	if (!this._hudField) {this.createHudField()};
    this.createEscapeGaugeATB();
	this.sortMz();	
};

//=============================================================================
// ** EscapeGaugeATB
//=============================================================================	
function EscapeGaugeATB() {
    this.initialize.apply(this, arguments);
}

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

//==============================
// * Initialize
//==============================
EscapeGaugeATB.prototype.initialize = function() {
    Sprite.prototype.initialize.call(this);	
	this.setup();
    this.createSprites();
};

//==============================
// * Setup
//==============================
EscapeGaugeATB.prototype.setup = function() {
   this.opacity = 0;
   this.x = Moghunter.atb_EscapeGaugeX;
   this.y = Moghunter.atb_EscapeGaugeY;
};

//==============================
// * create Sprites
//==============================
EscapeGaugeATB.prototype.createSprites = function() {
    this.createLayout();
	this.createGauge();
};

//==============================
// * create Layout
//==============================
EscapeGaugeATB.prototype.createLayout = function() {
    this._layout = new Sprite(ImageManager.loadATBIcon("Escape_A"));
	this.addChild(this._layout);
};

//==============================
// * create Gauge
//==============================
EscapeGaugeATB.prototype.createGauge = function() {
    this._gauge = new Sprite(ImageManager.loadATBIcon("Escape_B"));
	this._gauge.x = Moghunter.atb_EscapeGaugeX2;
	this._gauge.y = Moghunter.atb_EscapeGaugeY2;
	this.addChild(this._gauge);  
};

//==============================
// * Update Gauge
//==============================
EscapeGaugeATB.prototype.updateGauge = function() {
    var cw = this._gauge.bitmap.width;
	var ch = this._gauge.height;
	var rg = cw * $gameTemp._atbEscape[0] / $gameTemp._atbEscape[1];
	this._gauge.setFrame(0,0,rg,ch);
};

//==============================
// * need Fade
//==============================
EscapeGaugeATB.prototype.needFade = function() {
	if ($gameTemp._atbEscape[0] <= 0) {return true};
	if ($gameMessage.isBusy()) {return true};
	if ($gameTemp._battleEnd) {return true};
	return false;
};

//==============================
// * Update Visible
//==============================
EscapeGaugeATB.prototype.updateVisible = function() {
    if (this.needFade()) {
		this.opacity -= 10;
	} else {
		this.opacity += 10;
	};
};

//==============================
// * Update
//==============================
EscapeGaugeATB.prototype.update = function() {
    Sprite.prototype.update.call(this);	
	this.updateVisible();
    this.updateGauge();
};