#include "gamesrv.h"

#include "stdafx.h"
#include "InfluenceObject.h"
#include "SkillManager.h"
#include "SkillScript.h"
#include "StatusCalc_Server.h"
#include "ObjectManager.h"
#include "Protocol.h"
#include "Skill_Common.h"
#include "Player.h"
#include "Totem.h"



cInfluenceObject::cInfluenceObject()
{
	mTime1 = 0;
	mTime2 = 0;

	mCopySkillClassIdx = 0;
	mSwitchType = eSWITCHTYPE_NONE;
	mParentUniqueIdx = 0;
	mCopyRange = 0;
	mCopyApplyType = eAPPLYTYPE_SELF;
	mAttriButeType = eATTRIBUTETYPE_PHYSICAL;
	mCopyCheckTime = 0;

	mInfluenceValue1 = 0;
	mInfluenceValue2 = 0;

	mProcessStart = true;
	mSendDelMsg = true;

	mIsTotem = false;

	mIsDelReady = false;
	mDistressPoint = 0;

	mItemIdx = 0;
	mDieDelete = true;
}



cInfluenceObject::~cInfluenceObject()
{
	SKILLMANAGER->DelInfluenceUniqueIdx( mUniqueIdx );
}



void* cInfluenceObject::operator new( size_t n )
{
	if( n != sizeof(cInfluenceObject) ) 
	{
		assert(0);
		return NULL;
	}

	return SKILLMANAGER->AllocInfluenceObject();
}



void cInfluenceObject::operator delete( void* ptr, size_t n )
{
	/// NULL 포인터 검사
	if( ptr == 0 )
	{
		assert(0);
		return;
	}

	if( n != sizeof(cInfluenceObject) ) 
	{
		assert(0);
		return;
	}

	SKILLMANAGER->FreeInfluenceObject( static_cast<cInfluenceObject*>(ptr) );

	return;
}


bool cInfluenceObject::NormalInit( sObject attacker, sObject target, unsigned long uniqueIdx, unsigned long infClassIdx,
								  unsigned long skillClassIdx, unsigned long* plusTime )
{

	/// 효과 스크립트 정보 읽어옴
	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( infClassIdx );
	if( !pInfluence )	
	{ 
		NETWORK2->PostServerEvent("influence init - GetInfluenceInfo(%d)", infClassIdx);
		return false; 
	}

	mUniqueIdx = uniqueIdx;
	mDBIdx = 0;
	mInfluenceClassIdx = infClassIdx;
	mTarget = target;
	mAttacker = attacker;
	mInfluenceCreationTime = NETWORK2->GetAccumTime();

	/// 스킬 스크립트에서 필요한 수치를 얻어 기록한다.
	sPlayerSkillBaseInfo* pSkillInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillClassIdx );
	if( pSkillInfo != NULL )	
	{ 
		cHaveSkillObject* pPlayerHaveSkill = SKILLMANAGER->GetPlayerHaveSkill( mAttacker.index, skillClassIdx );
		if( pPlayerHaveSkill )	
		{ 
			unsigned char skillStep = pPlayerHaveSkill->GetSkillStep();
			if( skillStep < pSkillInfo->mStepCount )
			{
				sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[skillStep];

				/// 스킬 어그로 수치
				mDistressPoint = pStepInfo->mDistressValue;

				mAttriButeType = pSkillInfo->mAttributeType;
			}
		}
		else
		{
			sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[0];

			/// 스킬 어그로 수치
			mDistressPoint = pStepInfo->mDistressValue;

			mAttriButeType = pSkillInfo->mAttributeType;
		}
	}

	mIsSleep = false;
	if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_SLEEP )
		mIsSleep = true;
	if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_SLEEP )
		mIsSleep = true;
	if( pInfluence->mStatusPlusIdx3 == eSTATUSPLUS_SLEEP )
		mIsSleep = true;

	bool timeDelay = mIsSleep;
	if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_STUN )
		timeDelay = true;
	if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_STUN )
		timeDelay = true;
	if( pInfluence->mStatusPlusIdx3 == eSTATUSPLUS_STUN )
		timeDelay = true;

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime1 != 0 )	
	{
		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue1 > 0 )
				mInfluenceValue1 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue1 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue1 = pInfluence->mValue1;
		}
		else
			mInfluenceValue1 = pInfluence->mValue1;
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime2 != 0 )	
	{
		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue2 > 0 )
				mInfluenceValue2 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue2 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue2 = pInfluence->mValue2;
		}
		else
			mInfluenceValue2 = pInfluence->mValue2;
	}

	if( pInfluence->mContinuanceTime == -1 )
	{
		mInfluenceRestTime = 0;
		mSwitchType = eSWITCHTYPE_PARENT;
	}
	else
		mInfluenceRestTime = pInfluence->mContinuanceTime;

	if( timeDelay == true && plusTime != NULL )
		mInfluenceRestTime = mInfluenceRestTime + *plusTime;
	else
		*plusTime = 0;

	return true;
}

bool cInfluenceObject::SwitchParentInit( sObject attacker, sObject target, unsigned long uniqueIdx, unsigned long infClassIdx,
                                        unsigned long skillClassIdx )
{
	/// 효과 스크립트 정보 읽어옴
	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( infClassIdx );
	if( !pInfluence )	
	{ 
		NETWORK2->PostServerEvent("influence init - GetInfluenceInfo(%d)", infClassIdx);
		return false; 
	}

	mUniqueIdx = uniqueIdx;
	mDBIdx = 0;
	mInfluenceClassIdx = infClassIdx;
	mTarget = target;
	mAttacker = attacker;
	mInfluenceCreationTime = NETWORK2->GetAccumTime();
	mCopyCheckTime = NETWORK2->GetAccumTime();
	mDieDelete = pInfluence->mDieDelete;
	mSwitchType = eSWITCHTYPE_PARENT;

	/// 스킬 스크립트에서 필요한 수치를 얻어 기록한다.
	sPlayerSkillBaseInfo* pSkillInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillClassIdx );
	if( pSkillInfo != NULL )	
	{ 
		cHaveSkillObject* pPlayerHaveSkill = SKILLMANAGER->GetPlayerHaveSkill( mAttacker.index, skillClassIdx );
		if( pPlayerHaveSkill )	
		{ 
			unsigned char skillStep = pPlayerHaveSkill->GetSkillStep();
			if( skillStep < pSkillInfo->mStepCount )
			{
				sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[skillStep];

				/// 스킬 어그로 수치
				mDistressPoint = pStepInfo->mDistressValue;

				mCopySkillClassIdx = skillClassIdx;
				mCopyRange = pStepInfo->mBoundDist;
				mCopyApplyType = pSkillInfo->mApplyType;
				mAttriButeType = pSkillInfo->mAttributeType;
			}
		}
		else
		{
			sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[0];

			/// 스킬 어그로 수치
			mDistressPoint = pStepInfo->mDistressValue;

			mAttriButeType = pSkillInfo->mAttributeType;
		}
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime1 != 0 )	
	{
		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue1 > 0 )
				mInfluenceValue1 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue1 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue1 = pInfluence->mValue1;
		}
		else
			mInfluenceValue1 = pInfluence->mValue1;
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime2 != 0 )	
	{
		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue2 > 0 )
				mInfluenceValue2 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue2 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue2 = pInfluence->mValue2;
		}
		else
			mInfluenceValue2 = pInfluence->mValue2;
	}

	/// 오라는 시간되서 꺼지는 스킬이 아니다!
	mInfluenceRestTime = 0;
	
	return true;
}

bool cInfluenceObject::SwitchChildAuraInit( sObject attacker, sObject target, unsigned long uniqueIdx, unsigned long infClassIdx,
                                       unsigned long skillClassIdx, unsigned long parenUniqueIdx )
{

	/// 효과 스크립트 정보 읽어옴
	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( infClassIdx );
	if( !pInfluence )	
	{ 
		assert(NULL); 
		NETWORK2->PostServerEvent("influence init - GetInfluenceInfo(%d)", infClassIdx);
		return false; 
	}

	mUniqueIdx = uniqueIdx;
	mDBIdx = 0;
	mInfluenceClassIdx = infClassIdx;
	mTarget = target;
	mAttacker = attacker;
	mSwitchType = eSWITCHTYPE_CHILD;
	mInfluenceCreationTime = NETWORK2->GetAccumTime();
	mCopyCheckTime = NETWORK2->GetAccumTime();
	mParentUniqueIdx = parenUniqueIdx;
	mIsTotem = false;

	/// 스킬 스크립트에서 필요한 수치를 얻어 기록한다.
	sPlayerSkillBaseInfo* pSkillInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillClassIdx );
	if( pSkillInfo != NULL )	
	{ 
		cHaveSkillObject* pPlayerHaveSkill = SKILLMANAGER->GetPlayerHaveSkill( mAttacker.index, skillClassIdx );
		if( pPlayerHaveSkill )	
		{ 
			unsigned char skillStep = pPlayerHaveSkill->GetSkillStep();
			if( skillStep < pSkillInfo->mStepCount )
			{
				sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[skillStep];

				/// 스킬 어그로 수치
				mDistressPoint = pStepInfo->mDistressValue;

				mCopyRange = pStepInfo->mBoundDist;
				mCopyApplyType = pSkillInfo->mApplyType;
				mAttriButeType = pSkillInfo->mAttributeType;
			}
		}
		else
		{
			sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[0];

			/// 스킬 어그로 수치
			mDistressPoint = pStepInfo->mDistressValue;

			mAttriButeType = pSkillInfo->mAttributeType;
		}
	}


	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime1 != 0 )	
	{
		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue1 > 0 )
				mInfluenceValue1 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue1 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue1 = pInfluence->mValue1;
		}
		else
			mInfluenceValue1 = pInfluence->mValue1;
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime2 != 0 )	
	{
		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue2 > 0 )
				mInfluenceValue2 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue2 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue2 = pInfluence->mValue2;
		}
		else
			mInfluenceValue2 = pInfluence->mValue2;
	}

	mInfluenceRestTime = 0;

	return true;
}


bool cInfluenceObject::SwitchChildTotemInit( sObject attacker, sObject target, unsigned long uniqueIdx, unsigned long infClassIdx,
										   unsigned long skillClassIdx, unsigned long parenUniqueIdx )
{

	/// 효과 스크립트 정보 읽어옴
	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( infClassIdx );
	if( !pInfluence )	
	{ 
		assert(NULL); 
		NETWORK2->PostServerEvent("influence init - GetInfluenceInfo(%d)", infClassIdx);
		return false; 
	}

	mUniqueIdx = uniqueIdx;
	mDBIdx = 0;
	mInfluenceClassIdx = infClassIdx;
	mTarget = target;
	mAttacker = attacker;
	mSwitchType = eSWITCHTYPE_CHILD;
	mInfluenceCreationTime = NETWORK2->GetAccumTime();
	mCopyCheckTime = NETWORK2->GetAccumTime();
	mParentUniqueIdx = parenUniqueIdx;
	mIsTotem = true;

	/// 스킬 스크립트에서 필요한 수치를 얻어 기록한다.
	sPlayerSkillBaseInfo* pSkillInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillClassIdx );
	if( pSkillInfo != NULL )	
	{ 
		cHaveSkillObject* pPlayerHaveSkill = SKILLMANAGER->GetPlayerHaveSkill( mAttacker.index, skillClassIdx );
		if( pPlayerHaveSkill )	
		{ 
			unsigned char skillStep = pPlayerHaveSkill->GetSkillStep();
			if( skillStep < pSkillInfo->mStepCount )
			{
				sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[skillStep];

				/// 스킬 어그로 수치
				mDistressPoint = pStepInfo->mDistressValue;

				mSwitchType = eSWITCHTYPE_PARENT;
				mCopyRange = pStepInfo->mBoundDist;
				mCopyApplyType = pSkillInfo->mApplyType;
				mAttriButeType = pSkillInfo->mAttributeType;
			}
		}
		else
		{
			sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[0];

			/// 스킬 어그로 수치
			mDistressPoint = pStepInfo->mDistressValue;

			mAttriButeType = pSkillInfo->mAttributeType;
		}
	}


	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime1 != 0 )	
	{
		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue1 > 0 )
				mInfluenceValue1 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue1 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue1 = pInfluence->mValue1;
		}
		else
			mInfluenceValue1 = pInfluence->mValue1;
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime2 != 0 )	
	{
		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;

		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
		if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS )
		{
			/// +수치는 힐 -수치는 데미지
			if( pInfluence->mValue2 > 0 )
				mInfluenceValue2 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue2 );
			else	/// 데미지 계산공식 아직 없음
				mInfluenceValue2 = pInfluence->mValue2;
		}
		else
			mInfluenceValue2 = pInfluence->mValue2;
	}

	mInfluenceRestTime = 0;

	return true;
}


//bool cInfluenceObject::Init( unsigned long uniqueIdx, unsigned long influenceClassIdx, sObject target, sObject attacker, 
//							eAURATYPE auraType, unsigned short auraRange, eAPPLYTYPE auraCopyType, unsigned long skillClassIdx, 
//							eATTRIBUTETYPE attriButeType, bool loop, bool dieDelete, unsigned long* plusTime )
//{
//	mUniqueIdx = uniqueIdx;
//	mDBIdx = 0;
//	mInfluenceClassIdx = influenceClassIdx;
//	mTarget = target;
//	mAttacker = attacker;
//	mAuraType = auraType;
//	mAuraRange = auraRange;
//	mInfluenceCreationTime = NETWORK2->GetAccumTime();
//	mAuraCheckTime = mInfluenceCreationTime;
//	mAuraCopyType = auraCopyType;
//	mAttriButeType = attriButeType;
//	mDieDelete = dieDelete;
//	/// 스킬 번호는 오라 스킬에만 넣어 준다.
//	if( auraType == eSWITCHTYPE_PARENT )
//		mAuraSkillClassIdx = skillClassIdx;
//
//
//	/// 스킬 스크립트에서 필요한 수치를 얻어 기록한다.
//	sPlayerSkillBaseInfo* pSkillInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillClassIdx );
//	if( pSkillInfo != NULL )	
//	{ 
//		cHaveSkillObject* pPlayerHaveSkill = SKILLMANAGER->GetPlayerHaveSkill( mAttacker.index, skillClassIdx );
//		if( pPlayerHaveSkill )	
//		{ 
//			unsigned char skillStep = pPlayerHaveSkill->GetSkillStep();
//			if( skillStep >= pSkillInfo->mStepCount )
//			{
//				sPlayerSkillStepInfo* pStepInfo = &pSkillInfo->mpSetpInfoArray[skillStep];
//
//				/// 스킬 어그로 수치
//				mDistressPoint = pStepInfo->mDistressValue;
//			}
//		}
//	}
//
//	/// 효과 스크립트 정보 읽어옴
//	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( influenceClassIdx );
//	if( !pInfluence )	
//	{ 
//		assert(NULL); 
//		NETWORK2->PostServerEvent("influence init - GetInfluenceInfo(%d)", influenceClassIdx);
//		return false; 
//	}
//
//	mIsSleep = false;
//	if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_SLEEP )
//		mIsSleep = true;
//	if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_SLEEP )
//		mIsSleep = true;
//	if( pInfluence->mStatusPlusIdx3 == eSTATUSPLUS_SLEEP )
//		mIsSleep = true;
//
//	bool mIsStun = false;
//	if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_STUN )
//		mIsStun = true;
//	if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_STUN )
//		mIsStun = true;
//	if( pInfluence->mStatusPlusIdx3 == eSTATUSPLUS_STUN )
//		mIsStun = true;
//
//	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
//	if( pInfluence->mTime1 != 0 )	
//	{
//		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;
//
//		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
//		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
//		if( pInfluence->mStatusPlusIdx1 == eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS )
//		{
//			/// +수치는 힐 -수치는 데미지
//			if( pInfluence->mValue1 > 0 )
//				mInfluenceValue1 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue1 );
//			else	/// 데미지 계산공식 아직 없음
//				mInfluenceValue1 = pInfluence->mValue1;
//		}
//		else
//			mInfluenceValue1 = pInfluence->mValue1;
//	}
//
//	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
//	if( pInfluence->mTime2 != 0 )	
//	{
//		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;
//
//		/// 효과 번호에 힐데미지 계산 공식이 있으면 미리 계산해서 결과만 가지고 있는다
//		/// ※ 적용당시 공격자 객체가 사라져 계산이 불가능하게 되는 경우를 막음
//		if( pInfluence->mStatusPlusIdx2 == eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS )
//		{
//			/// +수치는 힐 -수치는 데미지
//			if( pInfluence->mValue2 > 0 )
//				mInfluenceValue2 = DAMAGECALC->HealHPCalc( attacker, pInfluence->mValue2 );
//			else	/// 데미지 계산공식 아직 없음
//				mInfluenceValue2 = pInfluence->mValue2;
//		}
//		else
//			mInfluenceValue2 = pInfluence->mValue2;
//	}
//
//	mInfluenceRestTime = pInfluence->mContinuanceTime;
//
//	if( ( mIsSleep == true || mIsStun == true ) && plusTime != NULL )
//		mInfluenceRestTime = mInfluenceRestTime + *plusTime;
//	else
//		*plusTime = 0;
//
//	mLoop = loop;
//
//	return true;
//}



bool cInfluenceObject::RestorePlayerInfluence( unsigned long playerIdx, unsigned long uniqueidx, sInfluence* pInfluence )
{
	/// db에서 읽어들인 자료는 gamein 메세지가 오기전까지 프로세스를 하지 않는다.
	mProcessStart = false;

	mUniqueIdx = uniqueidx;
	mDBIdx = pInfluence->mDbIdx;

	mInfluenceClassIdx = pInfluence->mInfluenceClassIdx;

	/// 오라는 DB에 저장 되어있지 않음
	mCopySkillClassIdx = 0;

	sInfluenceScript* pPlayerInfluence = SKILLSCRIPT->GetInfluenceInfo( mInfluenceClassIdx );
	if( !pPlayerInfluence )	
	{ 
		assert(NULL); 
		NETWORK2->PostServerEvent("cInfluenceObject::RestorePlayerInfluence - pPlayer[%d]Influence[%d] == NULL", playerIdx, mInfluenceClassIdx );
		return false; 
	}

	mTarget.index = playerIdx;
	mTarget.type = eOBJECTTYPE_PLAYER;

	mAttacker = pInfluence->mAttacker;

	/// DB에서 읽어온 효과는 클라이언트 gamein 메세지가 오는 시점이 효과 생성 시점이다.
	mInfluenceCreationTime = NETWORK2->GetAccumTime();

	mInfluenceRestTime = pInfluence->mRestTime;// * SECOND_THOUSAND;

	mTime1 = 0; 
	mTime2 = 0; 

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime1 != 0 )	
	{
		mTime1 = mInfluenceCreationTime + pInfluence->mTime1;
		mInfluenceValue1 = pInfluence->mInfluenceValue1;
	}

	/// 지속 적으로 효과적용(데미지) 인경우 다음 적용 시간 계산
	if( pInfluence->mTime2 != 0 )	
	{
		mTime2 = mInfluenceCreationTime + pInfluence->mTime2;
		mInfluenceValue2 = pInfluence->mInfluenceValue2;
	}

	mAttriButeType = (eATTRIBUTETYPE)pInfluence->mAttriButeType;

	mParentUniqueIdx = 0;
	mCopyRange = 0;
	mCopyCheckTime = 0;
	mCopyApplyType = eAPPLYTYPE_SELF;
	mCopySkillClassIdx = 0;

	return true;
}


void cInfluenceObject::ProcessStart()
{ 
	mInfluenceCreationTime = NETWORK2->GetAccumTime();
	mProcessStart = true; 
}


void cInfluenceObject::ProcessStop()
{ 
	if( mSwitchType == eSWITCHTYPE_NONE )
	{
		unsigned long accum = NETWORK2->GetAccumTime();

		if( accum - mInfluenceCreationTime >= mInfluenceRestTime )
			mInfluenceRestTime = 0;
		else
			mInfluenceRestTime = mInfluenceRestTime - (accum - mInfluenceCreationTime);
	}

	mProcessStart = false; 
}


void cInfluenceObject::SavePlayerInfluence( sInfluence* pInfluence )
{
	sInfluenceScript* pPlayerInfluence = SKILLSCRIPT->GetInfluenceInfo( mInfluenceClassIdx );
	if( !pPlayerInfluence )	
	{ 
		assert(NULL); 
		NETWORK2->PostServerEvent( "db Influence save - GetInfluenceInfo( %d )", mInfluenceClassIdx );
		return; 
	}

	unsigned long currenttime = NETWORK2->GetAccumTime();

	pInfluence->mInfluenceClassIdx = mInfluenceClassIdx;
	pInfluence->mAttacker = mAttacker;
	pInfluence->mIsRealTime = false;

	if( currenttime - mInfluenceCreationTime >= mInfluenceRestTime )
		pInfluence->mRestTime = 0;
	else
		pInfluence->mRestTime =  mInfluenceRestTime - (currenttime-mInfluenceCreationTime);

	if( !pInfluence->mIsRealTime )
	{
		pInfluence->mStartDate.year = 1753;
		pInfluence->mStartDate.month = 1;
		pInfluence->mStartDate.day = 1;
		pInfluence->mStartDate.hour = 0;
		pInfluence->mStartDate.minute = 0;
		pInfluence->mStartDate.second = 0;
		pInfluence->mStartDate.fraction = 0;
		pInfluence->mEndDate.year = 1753;
		pInfluence->mEndDate.month = 1;
		pInfluence->mEndDate.day = 1;
		pInfluence->mEndDate.hour = 0;
		pInfluence->mEndDate.minute = 0;
		pInfluence->mEndDate.second = 0;
		pInfluence->mEndDate.fraction = 0;
	}

	if( pPlayerInfluence->mTime1 != 0.0f )
		pInfluence->mTime1 = mTime1 - currenttime; 
	else					
		pInfluence->mTime1 = 0; 

	if( pPlayerInfluence->mTime2 != 0.0f )
		pInfluence->mTime2 = mTime2 - currenttime; 
	else					
		pInfluence->mTime2 = 0; 

	pInfluence->mInfluenceValue1 = mInfluenceValue1;
	pInfluence->mInfluenceValue2 = mInfluenceValue2;

	pInfluence->mAttriButeType = (unsigned char)mAttriButeType;
}



bool cInfluenceObject::Process( unsigned long /*elapsedTime*/, unsigned long accumTime )
{
	if( mIsDelReady	== true )
		return true;

	if( !mProcessStart ) 
		return true; 

	cBaseObject* pTarget = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
	if( pTarget == NULL || ( pTarget->GetStateDie() == true && mDieDelete == true ) )
		return false;

	sInfluenceScript* pInfluence = SKILLSCRIPT->GetInfluenceInfo( mInfluenceClassIdx );
	if( pInfluence == NULL )
		return false;

	unsigned long scriptTime1 = pInfluence->mTime1;
	unsigned long scriptTime2 = pInfluence->mTime2;

	if( mTime1 != 0 )
	{
		if( mTime1 <= accumTime )
		{
			mTime1 = mTime1 + scriptTime1;

			/// 지속 효과 처리
			DotInfluence( (eSTATUS_PLUS)pInfluence->mStatusPlusIdx1, mInfluenceValue1 );
		}
	}


	if( mTime2 != 0 )
	{
		if( mTime2 <= accumTime )
		{
			mTime2 = mTime2 + scriptTime2;

			/// 지속 효과 처리
			DotInfluence( (eSTATUS_PLUS)pInfluence->mStatusPlusIdx2, mInfluenceValue2 );
		}
	}

	/// 효과 생존시간 끝난 경우
	if( mSwitchType == eSWITCHTYPE_NONE && mInfluenceCreationTime + mInfluenceRestTime <= accumTime  )
		return false;

	/// 효과가 오라 인경우 범위안에 들어온 타겟에게 효과 복사
	if( mSwitchType == eSWITCHTYPE_PARENT )
	{
		if( mCopyCheckTime <= accumTime )
		{
			CopyAuraInfluence();
			mCopyCheckTime = accumTime + AURA_CHECK_TIME;
		}
	}
	else if ( mSwitchType == eSWITCHTYPE_CHILD )
	{
		/// 토템생성/오라효과생성 구분
		if( mIsTotem == true )
		{
			/// 부모효과유무와 거리 체크
			if( mCopyCheckTime <= accumTime )
			{
				cBaseObject* pTarget = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
				if( pTarget == NULL )
				{
					CheckTotemInfluence();
					return false;
				}

				if( CheckTotemInfluence() == true )
					return false;

				mCopyCheckTime = accumTime + AURA_CHECK_TIME;
			}
		}
		else
		{
			/// 부모효과유무와 거리 체크
			if( mCopyCheckTime <= accumTime )
			{
				cBaseObject* pTarget = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
				if( pTarget == NULL || pTarget->GetStateDie() == true )
				{
					/// 효과 제거
					DeleteChildAuraInfluence();
					return false;
				}

				if( DeleteChildAuraInfluence() == true )
					return false;

				mCopyCheckTime = accumTime + AURA_CHECK_TIME;
			}
		}
	}

	return true;
}


bool cInfluenceObject::IsTotemEqual( unsigned long uniqueIdx )
{
	if( mIsTotem == true && mParentUniqueIdx == uniqueIdx )
		return true;

	return false;
}

void cInfluenceObject::DotInfluence( eSTATUS_PLUS statusPlusIdx, long influenceValue )
{

	cBaseObject* pTargetObject = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
	if( pTargetObject == NULL || pTargetObject->GetStateDie() == true )
		return;

	long value = 0;

	switch( statusPlusIdx )
	{
	case eSTATUSPLUS_DOT_HPCHANGE_PLUS:
	case eSTATUSPLUS_DOT_HPCHANGE_CALC_PLUS:
		value = influenceValue;
		break;
	case eSTATUSPLUS_DOT_MPCHANGE_PLUS:
	case eSTATUSPLUS_DOT_MPCHANGE_CALC_PLUS:
		value = influenceValue;
		break;
	case eSTATUSPLUS_DOT_HPCHANGE_PER:
		value = FloatToInt( (float)pTargetObject->GetMaxHP() * influenceValue * 0.01f );
		break;
	case eSTATUSPLUS_DOT_MPCHANGE_PER:
		value = FloatToInt( (float)pTargetObject->GetMaxMP() * influenceValue * 0.01f );
		break;
	}

	switch( statusPlusIdx )
	{
	case eSTATUSPLUS_DOT_HPCHANGE_PER:
	case eSTATUSPLUS_DOT_HPCHANGE_PLUS:
		{
			bool die = false;
			unsigned long applyDamage = value;

			/// 입력값이 0보다 크니깐 heal처리
			if( value > 0 )
				pTargetObject->HPHeal( value, false, mAttacker.index, mDistressPoint, eTAKEDAMAGETYPE_HEAL );
			else
			{
				/// 입력값이 0보다 작으면 데미지 처리
				unsigned long damage = abs(value);

				/// 데미지 흡수
				unsigned long absorbPhyPer = pTargetObject->GetStateOddity( eODDITYTYPE_DAMAGE_ABSORB_PHY );
				unsigned long absorbMagPer = pTargetObject->GetStateOddity( eODDITYTYPE_DAMAGE_ABSORB_MAG );

				if( mAttriButeType == eATTRIBUTETYPE_PHYSICAL && absorbPhyPer != 0 )
				{
					if( absorbPhyPer < 0 )		absorbPhyPer = 0;
					if( absorbPhyPer > 100 )	absorbPhyPer = 100;
					damage = FloatToInt( damage * ( 100 - absorbPhyPer ) * 0.01f );
				}
				else if( mAttriButeType == eATTRIBUTETYPE_MAGIC && absorbMagPer != 0 )
				{
					if( absorbMagPer < 0 )		absorbMagPer = 0;
					if( absorbMagPer > 100 )	absorbMagPer = 100;
					damage = FloatToInt( damage * ( 100 - absorbMagPer ) * 0.01f );
				}

				if( damage == 0 )
					damage = 1;

				/// 무적 처리
				if( mAttriButeType == eATTRIBUTETYPE_PHYSICAL && pTargetObject->GetStateOddity( eODDITYTYPE_INVINCIBILITY_PHY ) != 0 )
					damage = 0;
				else if( mAttriButeType == eATTRIBUTETYPE_MAGIC && pTargetObject->GetStateOddity( eODDITYTYPE_INVINCIBILITY_MAG ) != 0 )
					damage = 0;

				/// 데미지 반사
				unsigned long reflectionPhyPer = pTargetObject->GetStateOddity( eODDITYTYPE_DAMAGE_REFLECTION_PHY );
				unsigned long reflectionMagPer = pTargetObject->GetStateOddity( eODDITYTYPE_DAMAGE_REFLECTION_MAG );
				unsigned long reflection = 0;
				if( mAttriButeType == eATTRIBUTETYPE_PHYSICAL && reflectionPhyPer != 0 )
				{
					if( reflectionPhyPer < 0 )		reflectionPhyPer = 0;
					if( reflectionPhyPer > 100 )	reflectionPhyPer = 100;
					reflection = FloatToInt( damage * reflectionPhyPer * 0.01f );
					damage = damage - reflection;
				}
				else if( mAttriButeType == eATTRIBUTETYPE_MAGIC && reflectionMagPer != 0 )
				{
					if( reflectionMagPer < 0 )		reflectionMagPer = 0;
					if( reflectionMagPer > 100 )	reflectionMagPer = 100;
					reflection = FloatToInt( damage * reflectionMagPer * 0.01f );
					damage = damage - reflection;
				}

				/// 결투 데미지 체크시 결투 종료면 hpdamage 내부적으로 처리
				if( DUELMANAGER->DuelLastAttack( mAttacker, mTarget, damage, false, &applyDamage ) == false )
					applyDamage = pTargetObject->HPDamage( damage, &die, false );

				/// 받은 데미지 처리
				pTargetObject->AddTakeDamage( mAttacker, applyDamage, mDistressPoint, eTAKEDAMAGETYPE_DAMAGE );	

				/// 공격자 hp/mp 처리
				cBaseObject* pAttacker = OBJECTMANAGER->GetObject( mAttacker.type, mAttacker.index );
				if( pAttacker != NULL )
				{
					/// 데미지 반사로 넘어온 데미지값을 먼저 기록
					long attackerDamage = reflection;
					unsigned long attackerApplyDamage = 0;

					unsigned long attkAbsorbHPPer = pAttacker->GetStateOddity( eODDITYTYPE_HP_ABSORB );	/// 공격자 HP흡수 비율
					unsigned long attkAbsorbMPPer = pAttacker->GetStateOddity( eODDITYTYPE_MP_ABSORB ); /// 공격자 MP흡수 비율

					/// 공격자 데미지 hp흡수
					if( attkAbsorbHPPer != 0 )
					{
						if( attkAbsorbHPPer < 0 )	attkAbsorbHPPer = 0;
						if( attkAbsorbHPPer > 100 )	attkAbsorbHPPer = 100;
						unsigned long attkAbsorbHP = FloatToInt( applyDamage * attkAbsorbHPPer * 0.01f );
						/// hp흡수량만큼 데미지 수치 감소
						attackerDamage = attackerDamage - attkAbsorbHP;

					}

					/// 공격자 데미지 mp흡수
					if( attkAbsorbMPPer != 0 )
					{
						if( attkAbsorbMPPer < 0 )	attkAbsorbMPPer = 0;
						if( attkAbsorbMPPer > 100 )	attkAbsorbMPPer = 100;
						unsigned long attkAbsorbMP = FloatToInt( applyDamage * attkAbsorbMPPer * 0.01f );

						pAttacker->MPHeal( attkAbsorbMP, false );

						MSG_SYN_SKILL_INFLUENCE_MPCHANGE msg; 
						msg.Category = NM_SKILL;
						msg.Protocol = NM_SKILL_INFLUENCE_MPCHAGNE_SYN;
						msg.mInfluenceIdx = mUniqueIdx;
						msg.mTarget = mAttacker;
						msg.mChangeValue = value;
						msg.mObjectMP = pAttacker->GetMP();
						msg.mObjectMaxMP = pAttacker->GetMaxMP();

						NETWORK2->QuickSend( pTargetObject, (char*)&msg, sizeof(msg) );
					}

					/// 공격자의 계산된 HP 처리
					if( attackerDamage > 0 )
					{
						/// 결투 데미지 체크시 결투 종료면 hpdamage 내부적으로 처리
						if( DUELMANAGER->DuelLastAttack( mTarget, mAttacker, attackerDamage, eDAMAGE_NORMAL, &attackerApplyDamage ) == false )
							attackerApplyDamage = pAttacker->HPDamage( attackerDamage, &die, false, eDAMAGE_NORMAL );

						/// 받은 데미지 처리
						pAttacker->AddTakeDamage( mTarget, attackerDamage, mDistressPoint, eTAKEDAMAGETYPE_DAMAGE );

						MSG_SYN_SKILL_INFLUENCE_HPCHANGE msg; 
						msg.Category = NM_SKILL;
						msg.Protocol = NM_SKILL_INFLUENCE_HPCHAGNE_SYN;
						msg.mInfluenceIdx = mUniqueIdx;
						msg.mTarget = mAttacker;
						msg.mChangeValue = value;
						msg.mObjectHP = pAttacker->GetHP();
						msg.mObjectMaxHP = pAttacker->GetMaxHP();
						msg.mDie = die;

						NETWORK2->QuickSend( pTargetObject, (char*)&msg, sizeof(msg) );
					}
					else if( attackerDamage < 0 )		/// 데미지 반사임
					{
						pAttacker->HPHeal( -attackerDamage, false, 0, 0, eTAKEDAMAGETYPE_NONE );

						MSG_SYN_SKILL_INFLUENCE_HPCHANGE msg; 
						msg.Category = NM_SKILL;
						msg.Protocol = NM_SKILL_INFLUENCE_HPCHAGNE_SYN;
						msg.mInfluenceIdx = mUniqueIdx;
						msg.mTarget = mAttacker;
						msg.mChangeValue = value;
						msg.mObjectHP = pAttacker->GetHP();
						msg.mObjectMaxHP = pAttacker->GetMaxHP();
						msg.mDie = die;

						NETWORK2->QuickSend( pTargetObject, (char*)&msg, sizeof(msg) );
					}
				}
			}

			/// 효과 적용 타겟의 HP 처리
			MSG_SYN_SKILL_INFLUENCE_HPCHANGE msg; 
			msg.Category = NM_SKILL;
			msg.Protocol = NM_SKILL_INFLUENCE_HPCHAGNE_SYN;
			msg.mInfluenceIdx = mUniqueIdx;
			msg.mTarget = mTarget;
			msg.mChangeValue = applyDamage;
			msg.mObjectHP = pTargetObject->GetHP();
			msg.mObjectMaxHP = pTargetObject->GetMaxHP();
			msg.mDie = die;

			NETWORK2->QuickSend( pTargetObject, (char*)&msg, sizeof(msg) );

		}break;
	case eSTATUSPLUS_DOT_MPCHANGE_PER:
	case eSTATUSPLUS_DOT_MPCHANGE_PLUS:	/// MP회복
		{

			if( value > 0 )
				pTargetObject->MPHeal( value, false );
			else
				pTargetObject->MPDamage( abs(value), false );

			MSG_SYN_SKILL_INFLUENCE_MPCHANGE msg; 
			msg.Category = NM_SKILL;
			msg.Protocol = NM_SKILL_INFLUENCE_MPCHAGNE_SYN;
			msg.mInfluenceIdx = mUniqueIdx;
			msg.mTarget = mTarget;
			msg.mChangeValue = value;
			msg.mObjectMP = pTargetObject->GetMP();
			msg.mObjectMaxMP = pTargetObject->GetMaxMP();

			NETWORK2->QuickSend( pTargetObject, (char*)&msg, sizeof(msg) );
		}break;
	}
}


/// 오라인 효과에서 범위 안에 해당되는 object에게 오라를 복사해줌
void cInfluenceObject::CopyAuraInfluence()
{
	/// 오라의 효과가 범위거리가 없으면 안된다.
	if( mCopyRange == 0.0f )
		return;

	if( mTarget.type == eOBJECTTYPE_PLAYER )
	{
		/// 오라 효과의 부모객체
		cPlayer* pParentObejct = OBJECTMANAGER->GetPlayer( mTarget.index );
		if( pParentObejct == NULL )
			return;

		/// 부모객체의 위치와 타겟의 위치
		NiPoint3 parentPos( pParentObejct->GetXPos(), pParentObejct->GetYPos(), pParentObejct->Height() );
		mRangeCheck.SetRadius( mCopyRange );

		switch( mCopyApplyType )
		{
		case eAPPLYTYPE_PARTY:
			{
				/// 파티 정보를 읽어옴
				cParty* pParty = PARTYMAN->GetParty( ((cPlayer*)pParentObejct)->GetPartyIndex() );
				if( pParty == NULL )	/// 파티가 없을수도 있다
					return;

				unsigned long* userArr = pParty->GetUserArr();
				unsigned int partyCount = pParty->GetCount();

				for( unsigned int i = 0 ; i < partyCount ; ++i )
				{
					/// 자신은 통과
					if( userArr[i] == pParentObejct->GetObjectID() )
						continue;

					/// 파티원을 읽어옴
					cPlayer* pChild = OBJECTMANAGER->GetPlayer( userArr[i] );
					if( pChild == NULL )
						continue;

					if( pChild->GetGameIn() == false )
						continue;

					/// 거리안에 들어오는 경우
					NiPoint3 childPos( pChild->GetXPos(), pChild->GetYPos(), pChild->Height() );
					if( mRangeCheck.IsRange( childPos, parentPos ) )
					{
						/// 같은 오라 효과가 복사되는것 방지
						if( pChild->IsParentEqual( mUniqueIdx ) == true )
							continue;	

						auraTemp aura;
						aura.target = pChild->GetObject();
						aura.influenceClassIdx = mInfluenceClassIdx;
						aura.attacker = mTarget;
						aura.skillClassIdx = 0;
						aura.msgSend = true;
						aura.parentUniqueIdx = mUniqueIdx;

						SKILLMANAGER->AddAuraChild( aura );
					}
				}
			}
			break;
		case eAPPLYTYPE_BUDDY:
			{
				cPlayer* pChild = GRIDMANAGER->FindFirstPlayer( pParentObejct );
				while( pChild != NULL )
				{

					/// 자신은 통과
					if( pChild->GetObjectID() == mTarget.index && pChild->GetObjectType() == mTarget.type )
					{
						pChild = GRIDMANAGER->FindNextPlayer();
						continue;
					}

					NiPoint3 childPos( pChild->GetXPos(), pChild->GetYPos(), pChild->Height() );
					if( mRangeCheck.IsRange( childPos, parentPos ) )
					{
						/// 같은 오라 효과가 복사되는것 방지
						if( pChild->IsParentEqual( mUniqueIdx ) == true )
						{
							pChild = GRIDMANAGER->FindNextPlayer();
							continue;					
						}

						auraTemp aura;
						aura.target = pChild->GetObject();
						aura.influenceClassIdx = mInfluenceClassIdx;
						aura.attacker = mTarget;
						aura.skillClassIdx = 0;
						aura.msgSend = true;
						aura.parentUniqueIdx = mUniqueIdx;

						SKILLMANAGER->AddAuraChild( aura );
					}	
					pChild = GRIDMANAGER->FindNextPlayer();
				}
			}
			break;
		case eAPPLYTYPE_SELF:
			break;
		default:
			NETWORK2->PostServerEvent("cSkillManager::CopyAuraInfluence mAuraCopyType[%d,%d,%d,%d] ERROR ", 
				mCopyApplyType, pParentObejct->GetObjectID(), pParentObejct->GetState(), pParentObejct->GetStateStop() );
		}
	}
}


bool cInfluenceObject::DeleteChildAuraInfluence()
{

	cInfluenceObject* pInfluenceObject = SKILLMANAGER->GetInfluence( mParentUniqueIdx );
	if( pInfluenceObject == NULL )
		return true;

	cBaseObject* pParent = OBJECTMANAGER->GetObject( mAttacker.type, mAttacker.index );
	if( pParent == NULL || pParent->GetStateDie() == true )
		return true;

	cBaseObject* pChild = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
	if( pChild == NULL || pChild->GetStateDie() == true )
		return true;

	if( pParent->GetMapNumber() != pChild->GetMapNumber() )
		return true;

	NiPoint3 parentPos( pParent->GetXPos(), pParent->GetYPos(), pParent->Height() );
	NiPoint3 childPos( pChild->GetXPos(), pChild->GetYPos(), pChild->Height() );

	cRangeCheck rangeCheck( pInfluenceObject->GetRange() );
	return rangeCheck.IsNotRange( parentPos, childPos );
}


bool cInfluenceObject::CheckTotemInfluence()
{
	/// 부모 토템 객체 확인
	cTotem* pTotemObject = OBJECTMANAGER->GetTotem( mParentUniqueIdx );
	if( pTotemObject == NULL )
		return true;

	cBaseObject* pTarget = OBJECTMANAGER->GetObject( mTarget.type, mTarget.index );
	if( pTarget == NULL )
	{
		pTotemObject->EraseTarget( mTarget );	/// 부모 토템에서 타겟 목록 제거
		return true;
	}

	/// 부모 와 효과(타겟) 거리 계산
	NiPoint3 parentPos( pTotemObject->GetXPos(), pTotemObject->GetYPos(), pTotemObject->Height() );
	NiPoint3 childPos( pTarget->GetXPos(), pTarget->GetYPos(), pTarget->Height() );

	cRangeCheck rangeCheck( pTotemObject->GetRange() );
	if( rangeCheck.IsNotRange( parentPos, childPos ) == true )
	{
		pTotemObject->EraseTarget( mTarget );	/// 부모 토템에서 타겟 목록 제거
		return true;
	}

	return false;
}


void cInfluenceObject::TotemSetEraseTarget()
{
	/// 부모 토템 객체 확인
	cTotem* pTotemObject = OBJECTMANAGER->GetTotem( mParentUniqueIdx );
	if( pTotemObject != NULL )
		pTotemObject->EraseTarget( mTarget );
}
