/*--------------------------------------------------------------------------
  
  発動条件に関して詳細な設定が行えるようになります。

  使用方法:
  スキルのカスタムパラメータに{EC_NowHP:'0-50%'}のように設定します。
  (詳しくは別紙参照)
  ※必ずTemporaryDataVirtualAttack.jsとセットで入れてください。
  
  作成者:
  o-to
  
  更新履歴:
  2016/04/24:
  ExtraConfigSkill.jsから大部分の処理を移動
  フュージョンや武器タイプ、ステートの状態をスキル発動条件に設定可能に
  2016/05/03:
  攻撃回数(発動者、相手)と相手との距離を設定しても正常に動作しなかった不具合を修正
  攻撃回数(発動者、相手)と相手との距離を設定時のスキル情報での表示を修正

  2016/10/03：
  FPの使用量設定時にエラーになる不具合を修正

  2017/02/05:
  forループ用に使用している変数の宣言忘れしている箇所を修正
  ※同じように宣言忘れしている別スクリプトがあった場合、意図せぬ動作が起こるため

--------------------------------------------------------------------------*/

(function() {
// 定数
EC_DefineString = {
	  Max                 : '最大'
	, AND                 : '&'
	, OR                  : 'or'
	, Opponent            : '相手の'
	, Opponent2           : '相手が'
	, CommandSkillAttack  : 'コマンドスキル(攻撃型)'
	, CommandSkillWait    : 'コマンドスキル(待機型)'
	, TriggerCountCommand : 'コマンド:'
	, TriggerCountMap     : 'MAP:'
	, TriggerCountTurn    : 'TURN:'
	, TriggerCountBattle  : '1戦闘:'
	, UsePoint            : '消費:'
	, NowStatus           : 'ステータスが一定範囲'
	, AbandonIgnore       : '相手の見切りを無視して発動可能'
	, Physics             : '装備武器が物理系'
	, Magic               : '装備武器が魔法系'
	, SrcTrue             : '先手を取った時'
	, SrcFalse            : '後手に回った時'
	, AttackCount         : '攻撃回数:'
	, NonAttack           : '未攻撃'
	, Count               : '回'
	, Range               : '相手との距離:'
	, Adjacent            : '隣接'
	, Mass                : 'マス'
	, OverStatus          : 'ステータスが相手より一定以上'
	, UnderStatus         : 'ステータスが相手より一定以下'
	, Fusion              : '同行:'
	, FusionALL           : '誰かと同行している'
	, FusionNON           : '同行状態ではない'
	, ClassType           : '兵種:'
	, State               : '状態:'
	, StateALL            : '全ての状態付加'
	, StateGood           : '補助が付加されている'
	, StateBad            : '状態異常になっている'
	, StateNon            : '状態付加されていない'
	, StateNonGood        : '補助が付加されていない'
	, StateNonBad         : '状態異常になっていない'
	, StateNonID          : 'になっていない'
	, WeaponType          : '武器:'
	, WeaponTypePhysics   : '近接系'
	, WeaponTypeShoot     : '射撃系'
	, WeaponTypeMagic     : '魔法系'
	, WeaponTypeNon       : '以外'
};

EC_DefineSetting = {
	  ALL       : 'ALL'
	, GOOD      : 'GOOD'
	, BAD       : 'BAD'
	, PHYSICS   : 'PHYSICS'
	, SHOOT     : 'SHOOT'
	, MAGIC     : 'MAGIC'
	, NON       : 'NON'
	, NONGOOD   : 'NONGOOD'
	, NONBAD    : 'NONBAD'
	, OR        : 'OR'
	, UNDEFINED : -1
};

// ステータスの定義定数
EC_DefineStatus = {
	  LV : 'LV'
	, HP : 'HP'
	, EP : 'EP'
	, FP : 'FP'
};

// 現在値と最大値が分かれているパラメータの紐づけ配列
EC_NowStatusMapping = {
	  MHP : 'HP'
	, MEP : 'EP'
	, MFP : 'FP'
};

// ログを出力
EC_Putlog = function(msg, obj)
{
	if(obj.custom.EC_Putlog == 1 && msg != '')
	{
		root.log(msg);
	}
};

// ログを出力
EC_PutlogSystem = function(msg)
{
	if(root.getMetaSession().global.EC_Putlog == true && msg != '')
	{
		root.log(msg);
	}
};

// コマンドスキルであるかの判定
OT_isCommandSkill = function(skill) {
	var value = skill.custom.EC_Command;
	
	if( value != null )
	{
		switch(value)
		{
			case OT_SkillCommandType.ATTACK:
			case OT_SkillCommandType.WAIT:
				return true;
		}
	}
	
	return false;
};

// 値が範囲内である事を確認
EC_isValueInRange = function(nowValue, maxValue, range)
{
	if( range == null )
	{
		return true;
	}
	
	var regex = /^([0-9]+)\-([0-9]+)\%$/;
	var regexNum = /^([0-9]+)\-([0-9]+)$/;

	if (range.match(regex))
	{
		var min = parseInt(RegExp.$1);
		var max = parseInt(RegExp.$2);
		var MinPercent = Math.floor( maxValue * (min / 100) );
		var MaxPercent = Math.floor( maxValue * (max / 100) );

		if( nowValue < MinPercent || MaxPercent < nowValue )
		{
			return false;
		}
	}
	else if(range.match(regexNum))
	{
		var min = parseInt(RegExp.$1);
		var max = parseInt(RegExp.$2);

		if( nowValue < min || max < nowValue )
		{
			return false;
		}
	}
	
	return true;
};

EC_EnableManager = {
	SkillCheckActivity: function(active, passive, skill) {
		if(skill == null)
		{
			return false;
		}
		
		var msg = '';
		var nowHP          = active.custom.tmpNowVirtualAttack.hp;
		var Mhp            = ParamBonus.getMhp(active);
	
		var passive_nowHP          = passive.custom.tmpNowVirtualAttack.hp;
		var passive_Mhp            = ParamBonus.getMhp(passive);
	
		var direction = PosChecker.getSideDirection(active.getMapX(), active.getMapY(), passive.getMapX(), passive.getMapY());
		var isDirectAttack = direction !== DirectionType.NULL;
		var isSrc = active.custom.tmpNowVirtualAttack.isSrc;
		
		//---発動者の状態でスキル発動可か判定---------------------------------------

		// 現HPが設定範囲内なら発動可
		// いずれ廃止される可能性があるのでEC_NowStatusを使う事
		if( skill.custom.EC_NowHP != null )
		{
			var str = skill.custom.EC_NowHP;

			if( !EC_StatusCheck.isValueInRange(skill, nowHP, Mhp, str, 'HP') )
			{
				return false;
			}
		}

		// 相手の現HPが設定範囲内なら発動可
		// いずれ廃止される可能性があるのでEC_OpponentNowStatusを使う事
		if( skill.custom.EC_OpponentNowHP != null )
		{
			var str = skill.custom.EC_OpponentNowHP;
			
			if( !EC_StatusCheck.isValueInRange(skill, passive_nowHP, passive_Mhp, str, '相手HP') )
			{
				return false;
			}
		}

		// 近接か間接で発動判定
		// いずれ廃止される可能性があるのでEC_Rangeを使う事
		if( skill.custom.EC_isDirectAttack != null )
		{
			if( skill.custom.EC_isDirectAttack )
			{
				EC_Putlog('近接攻撃で発動', skill);
			}
			else
			{
				EC_Putlog('間接攻撃で発動', skill);
			}
	
			if( isDirectAttack != skill.custom.EC_isDirectAttack )
			{
				return false;
			}
		}

		//---自身と相手のステータスは範囲内なら発動
		if( EC_StatusCheck.isNowStatusInRange(active , skill, false) == false ) return false;
		if( EC_StatusCheck.isNowStatusInRange(passive, skill, true ) == false ) return false;
	
		//---相手のステータスより上なら発動
		if( EC_StatusCheck.CheckOverStatus(active, passive, skill) == false ) return false;
	
		//---相手のステータスより下なら発動
		if( EC_StatusCheck.CheckUnderStatus(active, passive, skill) == false ) return false;
		
		// 消費EPを確認
		if( EC_StatusCheck.isUseEP(active, skill, skill.custom.EC_UseEP) == false ) return false;

		// 消費FPを確認
		if( EC_StatusCheck.isUseFP(active, skill, skill.custom.EC_UseFP) == false ) return false;
		
		// 物理か魔法かで発動判定
		if( EC_SituationCheck.isPhysicsEnable(active , skill, false) == false ) return false;
		if( EC_SituationCheck.isPhysicsEnable(passive, skill, true ) == false ) return false;
	
		//---戦闘時の状況に応じて発動可か判定---------------------------------------
		
		// フュージョンの状態で発動できるかチェック
		if( EC_SituationCheck.isEnableFusionID(active , skill, false) == false ) return false;
		if( EC_SituationCheck.isEnableFusionID(passive, skill, true ) == false ) return false;
		
		// ステートの状態で発動できるかチェック
		if( EC_SituationCheck.isEnableStateID(active , skill, false) == false ) return false;
		if( EC_SituationCheck.isEnableStateID(passive, skill, true ) == false ) return false;
		
		// 武器タイプで発動できるかチェック
		if( EC_SituationCheck.isEnableWeaponType(active , skill, false) == false ) return false;
		if( EC_SituationCheck.isEnableWeaponType(passive, skill, true ) == false ) return false;
		
		// ターン数で発動できるかチェック
		if( EC_SituationCheck.isEnableTurn(skill) == false ) return false;
		
		// 先攻か後攻かで発動可能
		if( EC_SituationCheck.isEnableSrc(skill, isSrc) == false ) return false;
	
		// スキル発動までの攻撃回数が一定回数で発動
		if( EC_SituationCheck.isAttackCountEnable(active , skill, false) == false ) return false;
		if( EC_SituationCheck.isAttackCountEnable(passive, skill, true ) == false ) return false;

		// 相手との距離で発動
		if( EC_SituationCheck.isRangeEnable(active, passive, skill) == false ) return false;
		
		// 戦闘時に発動できる回数の制限
		if( EC_SkillCheck.isCheckTriggerCount(active, skill) == false ) return false;
		
		return true;
	}
};

EC_StatusCheck = {
	// パラメータが定義されているか確認
	isDefineParam: function(type) {
		// レベルはスクリプトの定数で定義されている
		switch(type)
		{
			case EC_DefineStatus.LV:
				return true;
		}

		// 現在値と最大値が分かれているパラメータ
		for( var key in EC_NowStatusMapping )
		{
			if( type == EC_NowStatusMapping[key] )
			{
				if(typeof UnitParameter[key] == 'undefined')
				{
					//root.log(type + 'は未宣言のパラメータです。');
					return false;
				}
				return true;
			}
		}

		// パラメータが宣言されていない
		if(typeof UnitParameter[type] == 'undefined')
		{
			//root.log(type + 'は未宣言のパラメータです。');
			return false;
		}
		
		return true;
	},

	// 指定したステータスが範囲内である事を確認
	isNowStatusInRange: function(unit, obj, opponent) {
		var now    = obj.custom.EC_NowStatus;
		var result = EC_DefineSetting.UNDEFINED;
		var msg = 'ステータス範囲チェック';

		if( opponent )
		{
			now = obj.custom.EC_OpponentNowStatus;
			msg = '相手の' + msg;
		}
		else
		{
			now = obj.custom.EC_NowStatus;
		}

		if( now != null && unit != null )
		{
			EC_Putlog(msg, obj);
			for( var key in now )
			{
				if( !this.isParamInRange(unit, obj, key, now[key]) )
				{
					return false;
				}
			}
			result = true;
		}
		
		return result;
	},
	
	// パラメータが範囲内であるかチェック
	isParamInRange: function(unit, obj, type, strRange) {
		// パラメータが宣言されている事を確認する
		if(!this.isDefineParam(type))
		{
			root.log(type + 'は未宣言のパラメータです。');
			return 0;
		}

		var now = 0;
		var max = 0;
		var paramName = type;
		
		switch(type)
		{
			// 現在のHPやEP、FPは現在値と最大値それぞれ取得する
			case EC_DefineStatus.HP:
				if(typeof unit.custom.tmpNowVirtualAttack == 'undefined')
				{
					now = unit.getHp();
				}
				else
				{
					now = unit.custom.tmpNowVirtualAttack.hp;
				}

				max = ParamBonus.getMhp(unit);
				break;

			case EC_DefineStatus.EP:
				now = OT_GetNowEP(unit) - unit.custom.tmpUseEP;
				max = ParamBonus.getEp(unit);
				break;

			case EC_DefineStatus.FP:
				now = OT_GetNowFP(unit) - unit.custom.tmpUseFP;
				max = ParamBonus.getFp(unit);
				break;

			// それ以外のパラメータは最大値を成長限界値とする
			case EC_DefineStatus.LV:
				now = unit.getLv();
				max = Miscellaneous.getMaxLv(unit);
				break;

			default:
				now = ParamBonus.getBonus(unit, ParamType[type]);
				max = UnitParameter[type].getMaxValue(unit);
				paramName = UnitParameter[type].getParameterName();

				break;
		}
		
		return this.isValueInRange(obj, now, max, strRange, paramName);
	},

	// 値が範囲内であるかチェック
	isValueInRange: function(obj, nowValue, maxValue, str, paramName) {
		if( str == null )
		{
			return true;
		}
		
		var regex = /^([0-9]+)\-([0-9]+)\%$/;
		var regexNum = /^([0-9]+)\-([0-9]+)$/;
		//EC_Putlog(paramName + ':' + nowValue, skill);
		if (str.match(regex))
		{
			var min = parseInt(RegExp.$1);
			var max = parseInt(RegExp.$2);
			var MinPercent = Math.floor( maxValue * (min / 100) );
			var MaxPercent = Math.floor( maxValue * (max / 100) );

			EC_Putlog(paramName +  ':' + nowValue +' 発動範囲:' + MinPercent + '～' + MaxPercent + '(' + str + ')', obj);

			if( nowValue < MinPercent || MaxPercent < nowValue )
			{
				return false;
			}
		}
		else if(str.match(regexNum))
		{
			var min = parseInt(RegExp.$1);
			var max = parseInt(RegExp.$2);
			EC_Putlog(paramName +  ':' + nowValue +' 発動範囲:' + min + '～' + max, obj);

			if( nowValue < min || max < nowValue )
			{
				return false;
			}
		}
		
		return true;
	},

	// 消費EPが足りるかをチェック
	isUseEP: function(unit, obj) {
		var value = null;
		if( unit == null || obj == null )
		{
			return false;
		}
		
		if( typeof obj.custom.EC_UseEP != 'undefined' )
		{
			value = obj.custom.EC_UseEP;
		}
		else if( typeof obj.custom.OT_EP != 'undefined' )
		{
			value = obj.custom.OT_EP.Use;
		}
				
		// 消費EPを確認
		// 攻撃とスキルの発動どちらかしか行えないなら攻撃を優先させるようにする
		if( value != null )
		{
			if(typeof UnitParameter.MEP === 'undefined')
			{
				root.log('EP使用:EPシステムが未導入です');
			}
			else
			{
				var weapon = ItemControl.getEquippedWeapon(unit);

				var nowEP = OT_GetNowEP(unit);
				if(typeof unit.custom.tmpUseEP == 'number') {
					nowEP -= unit.custom.tmpUseEP;
				}
				
				var useEP = OT_GetUseEP(unit, value);
				useEP += OT_GetItemUseEP(unit, weapon);
				
				EC_Putlog('現EP:' + nowEP + ' 消費EP:' + useEP, obj)
				if( nowEP < useEP )
				{
					return false;
				}
			}
		}
		else
		{
			return EC_DefineSetting.UNDEFINED;
		}
		
		return true;
	},

	// 消費FPが足りるかをチェック
	isUseFP: function(unit, obj) {
		var value = null;
		if( unit == null || obj == null )
		{
			return false;
		}
		
		if( typeof obj.custom.EC_UseFP != 'undefined' )
		{
			value = obj.custom.EC_UseFP;
		}
		else if( typeof obj.custom.OT_FP != 'undefined' )
		{
			value = obj.custom.OT_FP.Use;
		}

		// 消費FPを確認
		// 攻撃とスキルの発動どちらかしか行えないなら攻撃を優先させるようにする
		if( value != null )
		{
			if(typeof UnitParameter.MFP === 'undefined')
			{
				root.log('FP使用:FPシステムが未導入です');
			}
			else
			{
				var weapon = ItemControl.getEquippedWeapon(unit);

				var nowFP = OT_GetNowFP(unit);
				if(typeof unit.custom.tmpUseFP == 'number') {
					nowFP -= unit.custom.tmpUseFP;
				}
				
				var useFP = OT_GetUseFP(unit, value);
				useFP += OT_GetItemUseFP(unit, weapon);
				
				EC_Putlog('現FP:' + nowFP + ' 消費FP:' + useFP, obj)
				if( nowFP < useFP )
				{
					return false;
				}
			}
		}
		else
		{
			return EC_DefineSetting.UNDEFINED;
		}
		
		return true;
	},

	// 相手よりステータスが上かチェック
	CheckOverStatus: function(active, passive, obj) {
		var over = obj.custom.EC_OverStatus;
		var isTrue  = false;
		var isFalse = false;
		var isOR    = false;
		var msg = '';
		var strTmp = '';
		
		for( var key in over )
		{
			if( key == 'TYPE' )
			{
				if( over[key] == EC_DefineSetting.OR ) isOR = true;
				continue;
			}
			
			var value = parseInt(over[key]);
			
			strTmp = EC_SituationRenderer.getParamName( key );
			if(strTmp != '') msg += strTmp + ':' + value + ' ';

			if( this.CheckStatusDiff(active, passive, key, -value) < 0 )
			{
				isFalse = true;
			}
			else
			{
				isTrue  = true;
			}
		}

		if(msg != '')
		{
			EC_Putlog('下記が相手より指定値以上なら発動', obj)
			EC_Putlog(msg, obj);
		}
		
		if( isOR == false && isFalse == true  ) return false;
		if( isOR == true  && isTrue  == false ) return false;
		if( isTrue == true ) return true;

		return EC_DefineSetting.UNDEFINED;
	},

	// 相手よりステータスが下かチェック
	CheckUnderStatus: function(active, passive, obj) {
		var under = obj.custom.EC_UnderStatus;
		var isTrue  = false;
		var isFalse = false;
		var isOR    = false;
		var msg = '';
		var strTmp = '';

		for( var key in under )
		{
			if( key == 'TYPE' )
			{
				if( under[key] == EC_DefineSetting.OR ) isOR = true;
				continue;
			}

			var value = parseInt(under[key]);
			
			strTmp = EC_SituationRenderer.getParamName( key );
			if(strTmp != '') msg += strTmp + ':' + value + ' ';
			
			if( this.CheckStatusDiff(active, passive, key, value) > 0 )
			{
				isFalse = true;
			}
			else
			{
				isTrue  = true;
			}
		}

		if(msg != '')
		{
			EC_Putlog('下記が相手より指定値以下なら発動', obj)
			EC_Putlog(msg, obj);
		}
		
		if( isOR == false && isFalse == true  ) return false;
		if( isOR == true  && isTrue  == false ) return false;
		if( isTrue == true ) return true;

		return EC_DefineSetting.UNDEFINED;
	},

	// 相手とのステータス差を確認
	CheckStatusDiff: function(active, passive, type, value) {
		var diffValue = 0;
		var acValue = 0;
		var psValue = 0;
		
		// パラメータが宣言されている事を確認する
		if(!this.isDefineParam(type))
		{
			return 0;
		}
		
		switch(type)
		{
			case EC_DefineStatus.LV:
				acValue = active.getLv();
				psValue = passive.getLv();
				diffValue = acValue + value - psValue;
				break;

			case EC_DefineStatus.HP:
				if(typeof active.custom.tmpNowVirtualAttack == 'undefined')
				{
					acValue = active.getHp();
					psValue = passive.getHp();
				}
				else
				{
					acValue = active.custom.tmpNowVirtualAttack.hp;
					psValue = passive.custom.tmpNowVirtualAttack.hp;
				}
				diffValue = acValue + value - psValue;
				break;

			case EC_DefineStatus.EP:
				acValue = OT_GetNowEP(active) - active.custom.tmpUseEP;
				psValue = OT_GetNowEP(passive) - passive.custom.tmpUseEP;
				diffValue = acValue + value - psValue;
				break;

			case EC_DefineStatus.FP:
				acValue = OT_GetNowFP(active) - active.custom.tmpUseFP;
				psValue = OT_GetNowFP(passive) - passive.custom.tmpUseFP;
				diffValue = acValue + value - psValue;
				break;

			default:
				acValue = ParamBonus.getBonus(active,  ParamType[type]);
				psValue = ParamBonus.getBonus(passive, ParamType[type]);
				diffValue = acValue + value - psValue;
				
				break;
		}
		
		return diffValue;
	}
};

EC_SituationCheck = {
	// 先手かどうかで発動できるかチェック
	isEnableSrc: function(obj, isSrc) {
		if( obj == null ) return false;
		if( obj.custom.EC_isSrc == null ) return EC_DefineSetting.UNDEFINED;
		if( isSrc === null ) return true;

		var msg = '';

		if(obj.custom.EC_isSrc == true)
		{
			EC_Putlog('先攻で発動', obj);
		}
		else
		{
			EC_Putlog('後攻で発動', obj);
		}

		if(isSrc == true)
		{
			EC_Putlog('発動者:先攻', obj);
		}
		else
		{
			EC_Putlog('発動者:後攻', obj);
		}
				
		if(isSrc != obj.custom.EC_isSrc)
		{
			return false;
		}
		
		return true;
	},
	
	// ターン数で発動できるかチェック
	isEnableTurn: function(obj) {
		if( obj == null )
		{
			return false;
		}

		var turn = root.getCurrentSession().getTurnCount();
		var msg = '';
		var result = EC_DefineSetting.UNDEFINED;

		// 規定ターンから発動可能
		if( obj.custom.EC_StartTurn != null )
		{
			msg = 'ターン数が' + obj.custom.EC_StartTurn + '以上で発動可:' + '現在' + turn + 'ターン目';
			EC_Putlog(msg, obj);
			if( !this.isMoreTurn(turn, obj.custom.EC_StartTurn) )
			{
				return false;
			}
			result = true;
		}
	
		// 規定ターンまで発動可能
		if( obj.custom.EC_EndTurn != null )
		{
			msg = 'ターン数が' + obj.custom.EC_EndTurn + '以下で発動可:' + '現在' + turn + 'ターン目';
			EC_Putlog(msg, obj);
			if( !this.isMoreTurn(obj.custom.EC_EndTurn, turn) )
			{
				return false;
			}
			result = true;
		}
	
		// ターンが特定の倍数なら発動可能
		if( obj.custom.EC_TimesTurn != null )
		{
			msg = 'ターン数が' + obj.custom.EC_TimesTurn + 'の倍数で発動:' + '現在' + turn + 'ターン目';
			EC_Putlog(msg, obj);
			if( !this.isNotDiffMultTurn(turn, obj.custom.EC_TimesTurn) )
			{
				return false;
			}
			result = true;
		}
		
		return result;
	},
	
	// ターン数が比較するものより上である事を確認する
	isMoreTurn: function(turn, checkTurn) {
		if(typeof turn !== 'number' || typeof checkTurn !== 'number')
		{
			return false;
		}
		
		if( turn < checkTurn )
		{
			return false;
		}
		
		return true;
	},

	// ターンが特定の倍数かを確認
	isNotDiffMultTurn: function(turn, checkTurn) {
		if(typeof turn !== 'number' || typeof checkTurn !== 'number')
		{
			return false;
		}
		
		var check = turn % checkTurn;

		if( check != 0 )
		{
			return false;
		}
		
		return true;
	},

	// 物理か、魔法かで発動できるかチェック
	isPhysicsEnable: function(unit, obj, opponent) {
		var conf = null;
		var weapon = ItemControl.getEquippedWeapon(unit);
		var msg = '';
		var isPhysics;
		
		if( opponent )
		{
			conf = obj.custom.EC_isOpponentPhysics;
		}
		else
		{
			conf = obj.custom.EC_isPhysics;
		}
		
		if( conf != null )
		{
			msg = EC_SituationRenderer.getPhysicsMessage(conf, opponent)
			EC_Putlog(msg, obj);

			if( weapon == null )
			{
				EC_Putlog('武器を持っていないため発動無し', obj);
				return false;
			}
			isPhysics = Miscellaneous.isPhysicsBattle(weapon);
	
			if( isPhysics != conf )
			{
				return false;
			}
		}
		else
		{
			return EC_DefineSetting.UNDEFINED;
		}

		return true;
	},

	// スキル発動までの攻撃回数が一定回数で発動
	isAttackCountEnable: function(unit, obj, opponent) {
		var conf = null;
		var AttackCount = unit.custom.tmpNowVirtualAttack.motionAttackCount;
		var msg = '';
		
		if(AttackCount == null)
		{
			return true;
		}
		
		if( opponent )
		{
			conf = obj.custom.EC_OpponentAttackCount;
		}
		else
		{
			conf = obj.custom.EC_AttackCount;
		}
		
		if( conf != null )
		{
			msg = EC_SituationRenderer.getAttackCountMessage(conf, opponent)
			EC_Putlog(msg, obj);

			if( !EC_isValueInRange(AttackCount, AttackCount, conf) )
			{
				return false;
			}
		}
		else
		{
			return EC_DefineSetting.UNDEFINED;
		}

		return true;
	},

	// 相手との距離で発動
	isRangeEnable: function(active, passive, obj) {
		if( active == null || passive == null )
		{
			return true;
		}

		var conf = obj.custom.EC_Range;
		var range = Math.abs(active.getMapX() - passive.getMapX()) + Math.abs(active.getMapY() - passive.getMapY());
		var msg = '';
		
		if( conf != null )
		{
			msg = EC_SituationRenderer.getRangeMessage(conf)
			EC_Putlog(msg, obj);

			if( !EC_isValueInRange(range, range, conf) )
			{
				return false;
			}
		}
		else
		{
			return EC_DefineSetting.UNDEFINED;
		}

		return true;
	},
	
	// フュージョン専用スキルの条件を満たしているかを確認
	isEnableFusion: function(active, passive, obj) {
		// 自分のフュージョンIDを確認する
		if( !this.isEnableFusionID(active, obj, obj.custom.EC_FusionID) )
		{
			return false;
		}
		
		// 相手のフュージョンIDを確認する
		if( !this.isEnableFusionID(passive, obj, obj.custom.EC_OpponentFusionID) )
		{
			return false;
		}
		
		return true;
	},

	// フュージョンタイプが指定のものかを確認する
	isEnableFusionID: function(unit, obj, opponent) {
		var id;
		
		if( opponent )
		{
			id = obj.custom.EC_OpponentFusionID;
		}
		else
		{
			id = obj.custom.EC_FusionID;
		}
		
		if(unit == null || id == null)
		{
			return EC_DefineSetting.UNDEFINED;
		}
		
		var data = FusionControl.getFusionData(unit);
		var msg  = unit.getName();

		if( data == null )
		{
			EC_Putlog(msg + 'はフュージョンしていない', obj);
			if( id == EC_DefineSetting.NON )
			{
				return true;
			}
			
			return false;
		}
		else
		{
			EC_Putlog(msg + 'はフュージョン中', obj);
			// 何かしらフュージョンしているのが条件ならtrue
			if( id == EC_DefineSetting.ALL )
			{
				EC_Putlog(msg + 'はフュージョンで発動', obj);
				return true;
			}
			else if( id == EC_DefineSetting.NON )
			{
				EC_Putlog(msg + 'はフュージョンで発動不可', obj);
				return false;
			}
		}

		var dataID = data.getId();
		EC_Putlog(msg + 'のフュージョンチェック', obj);
		EC_Putlog('いずれかを含めれば発動:' + id, obj);
		
		for( var i=0 ; i<id.length ; i++ )
		{
			if(typeof id[i] !== 'number') continue;

			if(id[i] === dataID) 
			{
				return true;
			}
		}
		
		return false;
	},

	// ステートタイプが指定のものかを確認する
	isEnableStateID: function(unit, obj, opponent) {
		var id;
		
		if( opponent )
		{
			id = obj.custom.EC_OpponentStateID;
		}
		else
		{
			id = obj.custom.EC_StateID;
		}
		
		if(unit == null || id == null)
		{
			return EC_DefineSetting.UNDEFINED;
		}
		
		var list = unit.getTurnStateList();
		var count = list.getCount();
		var msg  = unit.getName();
		
		// ステートが未付与の場合
		if( count == 0 )
		{
			EC_Putlog(msg + 'はステート付加されてない', obj);

			if( typeof id == 'string' )
			{
				switch(id)
				{
					case EC_DefineSetting.NON:
					case EC_DefineSetting.NONGOOD:
					case EC_DefineSetting.NONBAD:
						EC_Putlog('ステート無しで発動可', obj);
						return true;
						break;
				}
			}
			return false;
		}
		else
		{
			// 何かしらステートしているのが条件ならtrue
			if( id == EC_DefineSetting.ALL )
			{
				return true;
			}
		}

		EC_Putlog(msg + 'のステートチェック', obj);
		EC_Putlog('いずれかを含めれば発動:' + id, obj);
		
		var nonFlag = false;
		var hitCount = 0;
		
		for (var i = 0; i < count; i++) {
			var turnState = list.getData(i);
			var State = turnState.getState();
			var isBad = State.isBadState();
			var dataID = State.getId();
			
			if( typeof id == 'string' )
			{
				switch(id)
				{
					case EC_DefineSetting.GOOD:
						if( isBad == false ) return true;
						break;
	
					case EC_DefineSetting.BAD:
						if( isBad == true ) return true;
						break;
						
					case EC_DefineSetting.NONGOOD:
						EC_Putlog(isBad, obj);
						if( isBad == false ) return false;
						hitCount++;
						break;
	
					case EC_DefineSetting.NONBAD:
						if( isBad == true ) return false;
						hitCount++;
						break;
				}
			}
			else if(typeof id == 'object')
			{
				for( var j=0 ; j<id.length ; j++ )
				{
					if( typeof id[i] == 'string' )
					{
						if(id[i] == EC_DefineSetting.NON)
						{
							nonFlag = true;
						}
						continue;
					}
			
					if(typeof id[j] !== 'number') continue;
		
					if(id[j] === dataID) 
					{
						hitCount++;
					}
				}
			}
		}
		
		// ステートが引っかかっていたら発動不可
		if(nonFlag == true)
		{
			if( hitCount > 0 )
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		else
		{
			if( hitCount > 0 )
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		return false;
	},

	// 武器タイプが指定のものかを確認する
	isEnableWeaponType: function(unit, obj, opponent) {
		var id;
		
		if( opponent )
		{
			id = obj.custom.EC_OpponentWeaponType;
		}
		else
		{
			id = obj.custom.EC_WeaponType;
		}
		
		if(unit == null || id == null)
		{
			return EC_DefineSetting.UNDEFINED;
		}

		var msg  = unit.getName();
		EC_Putlog(msg + 'の武器タイプチェック', obj);
		EC_Putlog('いずれかを含めれば発動:', obj);
		EC_Putlog(EC_SituationRenderer.getWeaponTypeMessage(id, opponent), obj);
		
		var weapon = ItemControl.getEquippedWeapon(unit);
		var nonFlag = false;
		var hitCount = 0;

		// 武器を未装備時
		if( weapon == null )
		{
			EC_Putlog('武器未装備', obj);
			
			if( typeof id == 'object' )
			{
				for( var key in id ) {
					switch(key)
					{
						case EC_DefineSetting.NON     :
							nonFlag = id[key];
					}
				}
			}
			
			return nonFlag;
		}

		var weaponType         = weapon.getWeaponType();
		var weaponCategoryType = weaponType.getWeaponCategoryType();
		var weaponID           = weaponType.getId();

		if( typeof id == 'object' )
		{
			for( var key in id ) {
				switch(key)
				{
					case EC_DefineSetting.PHYSICS :
						index = WeaponCategoryType.PHYSICS;
						break;

					case EC_DefineSetting.SHOOT   :
						index = WeaponCategoryType.SHOOT;
						break;

					case EC_DefineSetting.MAGIC   :
						index = WeaponCategoryType.MAGIC;
						break;

					case EC_DefineSetting.NON     :
						nonFlag = id[key];
						continue;
						
					default:
						index = -1;
						continue;
						break;
				}

				if(weaponCategoryType == index)
				{
					if(typeof id[key] == 'object')
					{
						for( var i=0 ; i<id[key].length ; i++ )
						{
							if( id[key][i] == weaponID)
							{
								hitCount++;
							}
						}
					}
					else if(id[key] == EC_DefineSetting.ALL)
					{
						hitCount++;
					}
				}
			}
		}
		
		// 引っかかっていたら発動不可
		if(nonFlag == true)
		{
			if( hitCount > 0 )
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		else
		{
			if( hitCount > 0 )
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		return false;
	}
};

// 発動条件周りの条件描画関係
EC_SituationRenderer = {
	// パラメータ名取得
	getParamName: function( type )
	{
		// パラメータの定義確認
		if( !EC_StatusCheck.isDefineParam(type) )
		{
			return '';
		}

		// レベルはスクリプトの定数で定義されているため定数を返す
		switch(type)
		{
			case EC_DefineStatus.LV:
				return StringTable.Status_Level;
		}

		// 現在値と最大値が分かれているパラメータ
		for( var key in EC_NowStatusMapping )
		{
			if( type == key )
			{
				return EC_DefineString.Max + UnitParameter[key].getParameterName();
			}
			
			if( type == EC_NowStatusMapping[key] )
			{
				return UnitParameter[key].getParameterName();
			}
		}
		
		return UnitParameter[type].getParameterName();
	},
	
	// 範囲用
	getParamRangeMessage: function( type, msg ) {
		if( !EC_StatusCheck.isDefineParam(type) )
		{
			return '';
		}
		var name = this.getParamName(type);
		var str = name + ':' + msg.replace( /\-/g , "～" ) ;
		
		return str;
	},

	// コマンドスキルのメッセージ
	getCommandSkillMessage: function(obj) {
		msg = '';
		
		switch(obj)
		{
			case OT_SkillCommandType.ATTACK:
				msg = EC_DefineString.CommandSkillAttack;
				break;

			case OT_SkillCommandType.WAIT:
				msg = EC_DefineString.CommandSkillWait;
				break;
		}

		return msg;
	},

	// 発動率下限、上限設定のメッセージ
	getScopePercentMessage: function(obj) {
		msg = '';
		
		//発動率下限、上限を設定している場合
		if( obj != null ) 
		{
			var str = obj;
			
			var regex = /^([0-9]+)\-([0-9]+)/;
			if (str.match(regex))
			{
				var min = parseInt(RegExp.$1);
				var max = parseInt(RegExp.$2);
				msg = '発動率  下限:' + min + '％ 上限:' + max + '％';
			}
		}

		return msg;
	},

	//発動回数設定のメッセージ
	getTriggerCountMessage: function(map, turn, battle) {
		msg = '';
		
		if( map != null ) 
		{
			if(map[1] == OT_SkillTriggerMapType.COMMAND)
			{
				msg += EC_DefineString.TriggerCountCommand + map[0] + '回';
			}
			else if(map[1] == OT_SkillTriggerMapType.MAP)
			{
				msg += EC_DefineString.TriggerCountMap + map[0] + '回';
			}
		}
	
		if( turn != null ) 
		{
			if( msg != '' ) msg += '/';
			msg += EC_DefineString.TriggerCountTurn + turn + '回';
		}
	
		if( battle != null ) 
		{
			if( msg != '' ) msg += '/';
			msg += EC_DefineString.TriggerCountBattle + battle + '回';
		}

		return msg;
	},

	//見切り無視設定のメッセージ
	getAbandonIgnoreMessage: function(obj) {
		msg = '';
		
		if( obj == true ) 
		{
			msg = EC_DefineString.AbandonIgnore;
		}

		return msg;
	},

	//消費EPと消費FP設定のメッセージ
	getUsePointMessage: function(ep, fp) {
		msg = '';
		
		if( ep != null || fp != null )
		{
			msg = EC_DefineString.UsePoint;
			var msg2 = '';
			
			if( ep != null )
				msg2 += this.getParamName(EC_DefineStatus.EP) + ':' + ep;
	
			if( msg2 != '' ) msg2 += ' ';
	
			if( fp != null )
				msg2 += this.getParamName(EC_DefineStatus.FP) + ':' + fp;
	
			msg = msg + msg2;
		}

		return msg;
	},
			
	//物理か魔法かの設定
	getPhysicsMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		if(opponent == true) add = EC_DefineString.Opponent;
		
		if( obj != null )
		{
			if( obj )
			{
				msg = EC_DefineString.Physics;
			}
			else
			{
				msg = EC_DefineString.Magic;
			}
			
			msg = add + msg;
		}

		return msg;
	},

	// ターン設定のメッセージ
	getTurnMessage: function(strat, end, times) {
		var msg = '';

		// ターン数設定がある時
		if( strat != null || end != null || times != null )
		{
			msg = 'ターン数:';
		}

		// 特定のターンから発動可能
		if( strat != null || end != null )
		{
			if( strat != null && end != null )
			{
				if( strat == end )
				{
					msg += '' + strat + 'ターン目の時のみ ';
				}
				else
				{
					msg += strat + '～' + end + ' ';
				}
			} 
			else if( strat != null )
			{
				// 規定ターンから発動可能
				msg += strat + '以上 ';
			}
			else if( end != null )
			{
				// 規定ターンまで発動可能
				msg += end + '以下 ';
			}
		}

		// ターンが特定の倍数なら発動可能
		if( times != null )
		{
			msg += times + 'の倍数';
		}
		
		return msg;
	},
	
	// 先攻、後攻設定のメッセージ
	getSrcMessage: function(obj) {
		var msg = '';

		if( obj != null )
		{
			if(obj == true)
			{
				msg = EC_DefineString.SrcTrue;
			}
			else
			{
				msg = EC_DefineString.SrcFalse;
			}
		}
		
		return msg;
	},

	// 攻撃回数設定のメッセージ
	getAttackCountMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		var min = -1;
		var max = -1;

		if(opponent == true) add = EC_DefineString.Opponent;
		
		if( obj != null )
		{
			msg = add + EC_DefineString.AttackCount;
			var regex = /^([0-9]+)\-([0-9]+)/;
			if (obj.match(regex))
			{
				min = parseInt(RegExp.$1);
				max = parseInt(RegExp.$2);
			}

			if( min == 0 && max == 0 )
			{
				msg += EC_DefineString.NonAttack;
			}
			else if( min == max )
			{
				msg += min;
				msg += EC_DefineString.Count;
			}
			else
			{
				msg += obj;
				msg = msg.replace(/\-/g, '～');
				msg += EC_DefineString.Count;
			}
		}
		
		return msg;
	},
	
	// 相手との距離での発動設定のメッセージ
	getRangeMessage: function(obj) {
		var add = '';
		var msg = '';
		var min = -1;
		var max = -1;

		if( obj != null )
		{
			msg = EC_DefineString.Range;
			var regex = /^([0-9]+)\-([0-9]+)/;
			if (obj.match(regex))
			{
				min = parseInt(RegExp.$1);
				max = parseInt(RegExp.$2);
			}

			if( min == 1 && max == 1 )
			{
				msg += EC_DefineString.Adjacent;
			}
			else if( min == max )
			{
				msg += min;
				msg += EC_DefineString.Mass;
			}
			else
			{
				msg += obj;
				msg = msg.replace(/\-/g, '～');
				msg += EC_DefineString.Mass;
			}
		}
		
		return msg;
	},

	// フージョン設定のメッセージ
	getFusionMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		if(opponent == true) add = EC_DefineString.Opponent;

		if( typeof obj == 'object' )
		{
			for( var i=0 ; i<obj.length ; i++ )
			{
				if(msg != '') msg += EC_DefineString.OR;
				msg += this.getFusionName( obj[i] );
			}
		}
		else if( obj == EC_DefineSetting.ALL )
		{
			msg += EC_DefineString.FusionALL;
		}
		else if( obj == EC_DefineSetting.NON )
		{
			msg += EC_DefineString.FusionNON;
		}

		if(msg != '')
		{
			msg = add + EC_DefineString.Fusion + msg;
		}
		
		return msg;
	},

	// フュージョン名取得
	getFusionName: function( id )
	{
		//var list = root.getMetaSession().getDifficulty().getFusionReferenceList();
		var list = root.getBaseData().getFusionList();
		var data = list.getDataFromId(id);
		
		if(data != null)
		{
			return data.getName();
		}
		
		return '';
	},
	
	// 兵種設定のメッセージ
	getClassTypeMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		if(opponent == true) add = EC_DefineString.Opponent;

		if( typeof obj == 'object' )
		{
			for( var i=0 ; i<obj.length ; i++ )
			{
				if(msg != '') msg += EC_DefineString.OR;
				msg += this.getClassName( obj[i] );
			}
	
			if(msg != '')
			{
				msg = add + EC_DefineString.ClassType + msg;
			}
		}
		
		return msg;
	},

	// 兵種名取得
	getClassName: function( id )
	{
		var list = root.getBaseData().getClassTypeList();
		var data = list.getDataFromId(id);
		
		if(data != null)
		{
			return data.getName();
		}
		
		return '';
	},

	// ステート設定のメッセージ
	getStateMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		var msg2 = '';
		if(opponent == true) add = EC_DefineString.Opponent;

		if( typeof obj == 'object' )
		{
			for( var i=0 ; i<obj.length ; i++ )
			{
				if(msg != '') msg += ' ';
				
				if(typeof obj[i] == 'string')
				{
					if(obj[i] == EC_DefineSetting.NON)
					{
						msg2 = EC_DefineString.StateNonID;
					}
					continue;
				}
				msg += this.getStateName( obj[i] );
			}
			
			msg += msg2;
		}
		else if( typeof obj == 'string' )
		{
			switch(obj)
			{
				case EC_DefineSetting.ALL:
					msg = EC_DefineString.StateALL;
					break;

				case EC_DefineSetting.GOOD:
					msg = EC_DefineString.StateGood;
					break;

				case EC_DefineSetting.BAD:
					msg = EC_DefineString.StateBad;
					break;
					
				case EC_DefineSetting.NON:
					msg = EC_DefineString.StateNon;
					break;

				case EC_DefineSetting.NONGOOD:
					msg = EC_DefineString.StateNonGood;
					break;

				case EC_DefineSetting.NONBAD:
					msg = EC_DefineString.StateNonBad;
					break;
			}
		}

		if(msg != '')
		{
			msg = add + EC_DefineString.State + msg;
		}
		
		return msg;
	},

	// ステート名取得
	getStateName: function( id )
	{
		//var list = root.getMetaSession().getDifficulty().getFusionReferenceList();
		var list = root.getBaseData().getStateList();
		var data = list.getDataFromId(id);
		
		if(data != null)
		{
			return data.getName();
		}
		
		return '';
	},
	
	// 武器タイプ設定のメッセージ
	getWeaponTypeMessage: function(obj, opponent) {
		var add = '';
		var msg = '';
		var msg2 = '';
		if(opponent == true) add = EC_DefineString.Opponent;

		var index = -1;

		if( typeof obj == 'object' )
		{
			for( var key in obj ) {
				switch(key)
				{
					case EC_DefineSetting.PHYSICS :
						index = WeaponCategoryType.PHYSICS;
						break;

					case EC_DefineSetting.SHOOT   :
						index = WeaponCategoryType.SHOOT;
						break;

					case EC_DefineSetting.MAGIC   :
						index = WeaponCategoryType.MAGIC;
						break;

					case EC_DefineSetting.NON     :
						msg2 = EC_DefineString.WeaponTypeNon;
						continue;
						
					default:
						index = -1;
						break;
				}

				if(typeof obj[key] == 'object')
				{
					for( var i=0 ; i<obj[key].length ; i++ )
					{
						if(index == -1) continue;
						
						if(msg != '') msg += ' ';
						msg += this.getWeaponTypeName( index, obj[key][i] );
					}
				}
				else if(obj[key] == EC_DefineSetting.ALL)
				{
					if(msg != '') msg += ' ';
					msg += this.getWeaponTypeName( index, EC_DefineSetting.ALL );
				}
			}
			
			if(msg != '')
			{
				msg = add + EC_DefineString.WeaponType + msg;
			}
		}
		
		return msg + msg2;
	},

	// 武器タイプ名取得
	getWeaponTypeName: function(index, id)
	{
		if(id == EC_DefineSetting.ALL)
		{
			switch(index)
			{
				case WeaponCategoryType.PHYSICS :
					return EC_DefineString.WeaponTypePhysics;
					break;

				case WeaponCategoryType.SHOOT   :
					return EC_DefineString.WeaponTypeShoot;
					break;

				case WeaponCategoryType.MAGIC   :
					return EC_DefineString.WeaponTypeMagic;
					break;
			}
		}
		else
		{
			//var list = root.getMetaSession().getDifficulty().getFusionReferenceList();
			var list = root.getBaseData().getWeaponTypeList(index);
			var data = list.getDataFromId(id);
			
			if(data != null)
			{
				return data.getName();
			}
		}
		
		return '';
	},
	
	// 複数パラメータを指定されてる時のメッセージ作成
	getArrayParamMessage: function(obj, length) {
		var num = 0;

		for( var key in obj ) {
			num++;
		}

		var aryMsg = [];
		var strTmp = '';
		var returnMsg = [];
		
		for( var key in obj )
		{
			strTmp = this.getParamName( key );
			
			if(strTmp != '')
			{
				aryMsg.push( strTmp + ':' + obj[key] + ' ' );
			}
		}

		var msg = '';
		var i = 0;
		for(i = 0 ; i < aryMsg.length ; i++)
		{
			msg += aryMsg[i];
			
			len = this.getStringLen(msg);
			if( len > length )
			{
				returnMsg.push( msg );
				msg = '';
			}
		}

		if(msg != '') {
			returnMsg.push( msg );
		}
		
		return returnMsg;
	},

	// メッセージ作成
	rendererMessage: function(obj, msg, length, color, font, space) {
		if(typeof msg == 'object')
		{
			var len = msg.length;
			for( var i = 0 ; i < len ; i++ )
			{
				TextRenderer.drawKeywordText(obj[0], obj[1], msg[i], length, color, font);
				obj[0] += space[0];
				obj[1] += space[1];
			}
		}
		else if( msg != '' )
		{
			if( typeof msg == 'string' && msg.match(/\r\n|\r|\n/) )
			{
				var ary = msg.split(/\r\n|\r|\n/);
				this.rendererMessage(obj, ary, length, color, font, space);
			}
			else
			{
				TextRenderer.drawKeywordText(obj[0], obj[1], msg, length, color, font);
				obj[0] += space[0];
				obj[1] += space[1];
			}
		}
	},

	// 文字列長さ取得
	getStringLen: function(str) {
		var len = 0;
		var str = escape(str);
		for (var j = 0; j < str.length; j++, len++) {
			if (str.charAt(j) == "%") {
				if (str.charAt(++j) == "u") {
					j += 3;
					len++;
				}
				j++;
			}
		}
		
		return len;
	}
};

})();