#include "StdAfx.h"

#define AI_MONSTER_SKILL_UPDATE

 //怪物的技能的列表
void CAnimalAI::initialize(PAICONFIG pAiconfig)
{
	m_pAiConfig = pAiconfig;
	CSkillSubSystem & skillSystem = m_pSelf->GetSkillSystem();
	unsigned int nID = m_pSelf->GetProperty<unsigned int>(PROP_ENTITY_ID);
	PMONSTERCONFIG pMonsterConfig = GetLogicServer()->GetDataProvider()->GetMonsterConfig().GetMonsterData(nID);
	m_wMinSkillDis = 1;//这个初始化怪物技能里最大的攻击距离
	if(pMonsterConfig)
	{
		if(!m_pSelf->IsHero())
		{
			for(INT_PTR i=0; i < pMonsterConfig->skills.count ; ++i )
			{
				PMONSTERSKILL  pConfig = & pMonsterConfig->skills[i];
				if( skillSystem.LearnSkill(pConfig->wSkillID,pConfig->bSkillLevel) == tpNoError)
				{

					CSkillSubSystem::PSKILLDATA pSkill= skillSystem.GetSkillInfoPtr(pConfig->wSkillID);
					if(pSkill )
					{
						pSkill->bEvent = pConfig->bEvent ; //将这个保存起来，用于一些特殊场合的事件触发技能
					}

					if(!pSkill->bIsPassive && !pSkill->bIsClose && pConfig->bEvent == mSkillEventCommon)
					{
						INT_PTR nDis =skillSystem.GetSpellTargetDistance(pConfig->wSkillID,pConfig->bSkillLevel);
						if(nDis  >0)
						{
							if(nDis > m_wMinSkillDis && m_pSelf->GetType() != enPet)
							{
								m_wMinSkillDis =(WORD) nDis;
							}
						}
					}

				}
			}
		}
	}

	RefreshSkillDis();
	EnterInitAI();
}

void CAnimalAI::EnterInitAI()
{
	// 清空移动栈
	m_pSelf->GetMoveSystem()->ClearMotionStack();
	if(m_pSelf->IsMonster())
	{
		if(m_pAiConfig->patrolRadius > 0) // 怪物巡逻
		{
			m_pSelf->GetMoveSystem()->MovePatrol(m_pAiConfig->patrolRadius,m_pAiConfig->nStopMinTime,m_pAiConfig->nStopMaxTime);
		}
	}
	
	SetReSelTargetRate(m_pAiConfig->hitSetTargetRate);

	SetNextCheckEnemyTimer();
}

void  CAnimalAI::UpdateAI(TICKCOUNT nCurrentTick)
{
    DECLARE_TIME_PROF("CAnimalAI::UpdateAI");

	//如果在战斗状态
	if(m_pSelf->HasState(esStateDeath)) return;

	// 回归状态也不用更新ai
	if (m_pSelf->HasState(esStateReturnHome)) return;	

	// 战斗状态
	if(m_pSelf->HasState(esStateBattle) )
	{	
		//如果目标不存在的话,这里要进行目标的选择
		CEntity * pEntity = GetEntityFromHandle(m_pSelf->GetTarget()); //获得目标的指针

		//如果目标已经删除或者已经不在一个场景
		if (NULL== pEntity || !pEntity->IsInited() || /*!m_pSelf->CanSee(pEntity) ||*/ pEntity->GetPosInfo().nSceneId != m_pSelf->GetPosInfo().nSceneId) 
		{
			if(m_btAiType == atAiTypeAggressor)
			{
				// 这里主动怪目标死亡之后要切换目标，否则目标死亡之后一直锁定老的死亡目标，不会攻击新玩家
				if (!CheckEnemy())	//找不到目标则回归
					EnterEvadeMode();
			}
			else
			{			
				EnterEvadeMode();	
			}
			return;
		}

		INT_PTR nEntityType = m_pSelf->GetType();	
		CMovementSystem::MotionType nMotionType = m_pSelf->GetMoveSystem()->GetMotionType();
		//如果当前正在追逐就返回
		if (nMotionType == CMovementSystem::mtMotionTypeChase || nMotionType == CMovementSystem::mtMotionTypeIdle)
		{
			if(nEntityType == enMonster)  // 对于普通怪，检测怪物离出生点位置；对于跟随怪，需要检测和跟随者的距离！
			{
				INT_PTR nPosx,nPosY;	
				int nCurrentPosX,  nCurrentPosY;
				m_pSelf->GetPosition(nCurrentPosX,nCurrentPosY);
				// if (m_bInFollowingStats)
				// {
				// 	// 检测玩家和归属者的距离
				// 	CMonster *pMonster = (CMonster *)m_pSelf;
				// 	CActor *pOwner = (CActor *)GetEntityFromHandle(pMonster->GetOwner());
				// 	if (pOwner)
				// 	{
				// 		int nOwnerX, nOwnerY;
				// 		pOwner->GetPosition(nOwnerX, nOwnerY);
				// 		INT_PTR nSuare = (nOwnerX - nCurrentPosX) * (nOwnerX - nCurrentPosX) + (nOwnerY - nCurrentPosY) *(nOwnerY - nCurrentPosY);
				// 		if (nSuare > 400)  // 超过20格
				// 		{							
				// 			EnterEvadeMode();
				// 			return;
				// 		}
				// 	}
				// }
				// else
				{
					if (!m_pSelf->GetAttriFlag().noReturnHome)
					{
						if (nEntityType != enHero && m_pAiConfig->leftHomeMaxDistanceSquare > 0)
						{
							((CMonster*)m_pSelf)->GetBornPoint(nPosx,nPosY);					
							INT_PTR nSuare = (nPosx - nCurrentPosX) * (nPosx - nCurrentPosX) + 
								(nPosY -nCurrentPosY ) *(nPosY -nCurrentPosY );
							if(nSuare >=( m_pAiConfig->leftHomeMaxDistanceSquare  ))
							{
								EnterEvadeMode();
								return;
							}
						}
					}
					
				}				
			}
			//return;
			if (nEntityType == enPet && nMotionType == CMovementSystem::mtMotionTypeChase)
			{
				if(((CPetAi*)this)->IsInAvoidMap(pEntity->GetHandle())) 
				{
					EnterEvadeMode();
				}
			}
		}
		
		int nSelfPosX,nSelfPosY,nTargetPosX,nTargetPosY, nDisX,nDisY;
		m_pSelf->GetPosition(nSelfPosX,nSelfPosY);
		pEntity->GetPosition(nTargetPosX,nTargetPosY);
		nDisX = nSelfPosX - nTargetPosX;
		nDisY = nSelfPosY - nTargetPosY;
		//目标和自己的距离
		INT_PTR nSuareDis = nDisX * nDisX + nDisY * nDisY;
		
		//如果距离比最大的追逐距离要大了，就回归
		if(nSuareDis >= ( m_pAiConfig->pursuitDistance * m_pAiConfig->pursuitDistance))
		{
			EnterEvadeMode();
			return;
		}
		//这里要增加回归的判断
		if( pEntity->IsDeath() || m_pSelf->CanSee(pEntity) ==false)
		{
			if(m_btAiType == atAiTypeAggressor)
			{
				// 这里主动怪目标死亡之后要切换目标，否则目标死亡之后一直锁定老的死亡目标，不会攻击新玩家
				//CheckEnemy();
				//if (GetEntityFromHandle(m_pSelf->GetTarget())) // 如果没有目标，回归
				if (!CheckEnemy())	//找不到目标则回归
					EnterEvadeMode();
			}
			else
			{			
				EnterEvadeMode();	
			}
			
			return;
		}
		
		if (m_1sCheckEnemyInCombat.Check(nCurrentTick))
		{
			SetNextCheckEnemyTimer();
			//OutputMsg(rmNormal, _T("检测: (CurTime=%u)"), nCurrentTick);
			
			if (CheckEnemy())	// 切换目标
			{
				// if (CEntity * pNew = GetEntityFromHandle(m_pSelf->GetTarget()))
				// 	OutputMsg(rmNormal, _T("切换目标: (name:%s)(CurTime=%u)"), pNew->GetEntityName(),nCurrentTick);
				// else OutputMsg(rmNormal, _T("切换目标: (CurTime=%u)"), nCurrentTick);
				return;
			}
		}
		int nDisTance = __max( abs(nDisX),abs(nDisY) ) ;
		if(  nDisTance  <= m_wMinSkillDis ) //如果到达了攻击范围
		{
			/*DECLARE_TIME_PROF("UpdateAI::LaunchSkill");*/
			// if (!(CAnimal*)m_pSelf->CanEnterState(esStateSing)) //当前状态能否释放技能
			// 	return ;
			m_pSelf->GetMoveSystem()->ClearMotionStack();
			if(((CAnimal*)m_pSelf)->CheckCommonOpTick(nCurrentTick) && m_skillTimer.CheckAndSet(nCurrentTick, true) ) //如果能够使用技能了
			{
				m_pSelf->Face2Target(pEntity);
				CSkillSubSystem & skillSystem =  m_pSelf->GetSkillSystem();
				const CVector<CSkillSubSystem::SKILLDATA> & skills= skillSystem.GetSkills();
				bool hasAttack= false; 
				//英雄技能的处理
				/*if(m_pSelf->GetType() == enHero)
				{
				    INT_PTR nCount = skills.count();
					if(m_nSkillIdx  >= nCount)
					{
						m_nSkillIdx = 0;
					}
					if(nCount > 0)
					{
						CSkillSubSystem::SKILLDATA *pSkill = &skills[m_nSkillIdx];
						if(pSkill->bEvent == mSkillEventCommon)
						{
							if(!pSkill->bIsClose && !pSkill->bIsPassive)
							{
								if(skillSystem.LaunchSkill(pSkill->nSkillID,nTargetPosX,nTargetPosY) == tpNoError)
								{
									hasAttack =true; //已经攻击了
									((CAnimal*)m_pSelf)->SetCommonOpNextTime(m_pSelf->GetAttackInterval(),false,false);
									m_nSkillIdx++;
									return;
								}
							}else
							{
								m_nSkillIdx++;
							}
						}else
						{
							m_nSkillIdx++;
						}
						//如果正常技能索引不能释放，则选择能释放的技能释放
						for(INT_PTR i=0; i< skills.count();i++)
						{
							CSkillSubSystem::SKILLDATA *pSkill = &skills[i];
							if(pSkill->bIsClose)
							{
								continue;
							}
							if(pSkill->bIsPassive)
							{
								continue;
							}
							if(skillSystem.LaunchSkill(pSkill->nSkillID,nTargetPosX,nTargetPosY) == tpNoError)
							{
								((CAnimal*)m_pSelf)->SetCommonOpNextTime(m_pSelf->GetAttackInterval(),false,false);
								hasAttack =true; 
								break;
							}
						}
					}
				}
				else*/
				{
					for(INT_PTR i=0; i< skills.count();i++)
					{
						CSkillSubSystem::SKILLDATA *pSkill = &skills[i];
						if(pSkill->bEvent == mSkillEventCommon)
						{
							//如果关闭的了
							if(pSkill->bIsClose)
							{
								continue;
							}

							//被动不使用
							if(pSkill->bIsPassive)
							{
								continue;
							}

							if( !skillSystem.LaunchSkill(pSkill->nSkillID,nTargetPosX,nTargetPosY) )
							{
								//OutputMsg(rmNormal, _T("Monster LaunchSkill: %d, curTime:%u"), skills[i].nSkillID, GetGlobalLogicEngine()->getMiniDateTime());
								//攻击速度取决于攻击速度
								((CAnimal*)m_pSelf)->SetCommonOpNextTime(m_pSelf->GetAttackInterval(),false,false);
								hasAttack =true; //已经攻击了
								continue;
							}
						}
					}
				}

				if( ! hasAttack )  //没有释放技能
				{
					//如果不能进行肉搏的话,就不执行
					if( ! m_pSelf->GetAttriFlag().DenyUseNearAttack)
					{
						if(nDisTance >1)
						{
							m_pSelf->GetMoveSystem()->ClearMotionStack();
							m_pSelf->GetMoveSystem()->MoveChase((CAnimal*)pEntity,1,m_pAiConfig->pursuitDistance); 
						}
						else
						{
							INT_PTR nInterval =m_pSelf->GetAttackInterval() ;
							if( !skillSystem.NearAttack(pEntity->GetHandle(),0,0) && m_pSelf->GetType()!= enHero)
							{
								nInterval += m_pSelf->GetProperty< int>(PROP_CREATURE_ATTACK_SPEED); //添加攻击间隔
							}
							((CAnimal*)m_pSelf)->SetCommonOpNextTime(nInterval,false,false);
							//OutputMsg(rmNormal, _T("攻击: 【%s】 CurTime=%u "), m_pSelf->GetEntityName(), nCurrentTick);
						}
						
					}
					
				}
				
			}	
		}
		else 
		{
			//m_pSelf->GetMoveSystem()->ClearMotionStack();
			m_pSelf->GetMoveSystem()->MoveChase((CAnimal*)pEntity,m_wMinSkillDis,m_pAiConfig->pursuitDistance); 
		}
	}
	// 非战斗状态
	else
	{
		DECLARE_TIME_PROF("UpdateAI::CheckEnemy");
		if( m_1sCheckEnemyInCombat.CheckAndSet(nCurrentTick, true) )
		{
			if(m_pSelf->GetAttriFlag().IdleUseSkill)
			{
				CSkillSubSystem & skillSystem =  m_pSelf->GetSkillSystem();
				const CVector<CSkillSubSystem::SKILLDATA> & skills= skillSystem.GetSkills();
				bool hasAttack= false; 

				for(INT_PTR i=0; i< skills.count();i++)
				{
					CSkillSubSystem::SKILLDATA *pSkill = &skills[i];
					if(pSkill->bEvent == mSkillEventIdle)
					{
						//如果关闭的了
						if(pSkill->bIsClose)
						{
							continue;
						}

						//被动不使用
						if(pSkill->bIsPassive)
						{
							continue;
						}

						if( !skillSystem.LaunchSkill(pSkill->nSkillID,0,0))
						{
							//OutputMsg(rmNormal, _T("Monster LaunchSkill: %d, curTime:%u"), skills[i].nSkillID, GetGlobalLogicEngine()->getMiniDateTime());
							//攻击速度取决于攻击速度
							((CAnimal*)m_pSelf)->SetCommonOpNextTime(m_pSelf->GetAttackInterval(),false,false);
	                        continue;
						}
					}
				}
			}
			CheckEnemy();

		}
		
	}	
}


void CAnimalAI::HandleSkillCDWhenCombatStart()
{
	// 处理进入战斗立即CD技能
	if(!m_pSelf->IsMonster() && !m_pSelf->IsHero() ) return ; 
	if (!m_pSelf->HasState(esStateBattle))
	{
	    m_nSkillIdx  = 0;
		TICKCOUNT nCurrTime = GetGlobalLogicEngine()->getTickCount();
		if (m_pAiConfig)
		{
			CSkillSubSystem &skillSystem =  m_pSelf->GetSkillSystem();
			const CVector<CSkillSubSystem::SKILLDATA> &skills= skillSystem.GetSkills();

			unsigned int nID = m_pSelf->GetProperty<unsigned int>(PROP_ENTITY_ID);
			PMONSTERCONFIG pMonsterConfig = GetLogicServer()->GetDataProvider()->GetMonsterConfig().GetMonsterData(nID);
			if (!pMonsterConfig) return;
			
			
			for (INT_PTR i = 0; i < pMonsterConfig->skills.count; i++)
			{
				MONSTERSKILL *pAISkillData = pMonsterConfig->skills.GetDataPtr(i);
				
				//只有普通的技能才这样处理，像死亡触发的技能不能这样使用
				if (pAISkillData->bAutoCDWhenEnterCombat && pAISkillData->bEvent == mSkillEventCommon)
				{
					// 技能进入CD					
					for (INT_PTR j = 0; j < skills.count(); j++)
					{
						CSkillSubSystem::SKILLDATA &skillData = skills[j];
						//英雄出战技能进入CD
						/*if(m_pSelf->IsHero())
						{
						    if (skillData.nSkillID == pAISkillData->wSkillID)
							{
								const SKILLONELEVEL *pLevel = GetLogicServer()->GetDataProvider()->GetSkillProvider()->GetSkillLevelData(skillData.nSkillID, skillData.nLevel);
								if (pLevel)
								{
									skillData.tick = nCurrTime +  pLevel->nCooldownTimes;
								}
							}
						}else*/ if (skillData.nSkillID == pAISkillData->wSkillID && skillData.nLevel == pAISkillData->bSkillLevel)
						{
							const SKILLONELEVEL *pLevel = GetLogicServer()->GetDataProvider()->GetSkillProvider()->GetSkillLevelData(skillData.nSkillID, skillData.nLevel);
							if (pLevel)
							{
								skillData.tick = nCurrTime + pLevel->nCooldownTimes;
							}
						}
					}
				}
			}
		}
	}
}

void CAnimalAI::RefreshSkillDis()
{
	if(m_pSelf ==NULL )
	{
		OutputMsg(rmTip,"RefreshSkillDis m_pSelf has not inited");
		return;
	}

	if (m_pSelf->GetType() == enPet) return;
	

	CSkillSubSystem & skillSystem = m_pSelf->GetSkillSystem();

	//这个初始化怪物技能里最大的攻击距离
	m_wMinSkillDis = 1;

	const CVector<CSkillSubSystem::SKILLDATA> & skills= skillSystem.GetSkills();
	bool hasAttack= false; 

	for(INT_PTR i=0; i< skills.count();i++)
	{
		CSkillSubSystem::SKILLDATA *pSkill = &skills[i];

		if (pSkill->bIsClose) continue; //关闭的技能不栓书

		if (pSkill->bIsPassive) continue;	//被动不处理

		INT_PTR nDis =skillSystem.GetSpellTargetDistance(pSkill->nSkillID,pSkill->nLevel);
		if(nDis > 0)
		{
			if(nDis > m_wMinSkillDis)
			{
				m_wMinSkillDis =(WORD) nDis;
			}
		}
	}
}

void CAnimalAI::AttackStart(CAnimal * pTarget)
{
	if(pTarget ==NULL || pTarget->IsInited() ==false)return; //开始攻击
	bool bFoundNewTarget = true;
	
	//if (!m_pSelf->HasState(esStateBattle))
	//	bFoundNewTarget = true;

#ifdef AI_MONSTER_SKILL_UPDATE
	HandleSkillCDWhenCombatStart();	
#endif
  
	CMovementSystem::MotionType nCurrType = m_pSelf->GetMoveSystem()->GetMotionType();
	if (nCurrType == CMovementSystem::mtMotionTypeChase)
	{			
		m_pSelf->GetMoveSystem()->PopCurrentMotionState();
	}

	const EntityHandle& targetHandle = m_pSelf->GetTarget(); //目标的handle

	CEntity *pCurTarget =GetEntityFromHandle( targetHandle );
	if( pCurTarget && !pCurTarget->IsDeath() )
	{
		if( targetHandle == pTarget->GetHandle() )
		{
			bFoundNewTarget = false;
		}
	}

	m_pSelf->AddState(esStateBattle); //设置战斗状态
	if (m_pSelf->GetType() == enPet && ((CPet*)m_pSelf)->GetLiveTime() == 0)
	{
		if (m_pSelf->GetMoveSystem()->GetMotionType() == CMovementSystem::mtMotionTypeFollow)
		{
			m_pSelf->GetMoveSystem()->PopCurrentMotionState();
		}
	}else if(m_pSelf->GetType() == enHero)
	{
		if (m_pSelf->GetMoveSystem()->GetMotionType() == CMovementSystem::mtMotionTypeFollow)
		{
			m_pSelf->GetMoveSystem()->PopCurrentMotionState();
		}
	}

	if(bFoundNewTarget)
	{		
		// 逃跑 | 回归的时候不切换目标
		
		if (nCurrType == CMovementSystem::mtMotionTypeFleeing || nCurrType == CMovementSystem::mtMotionTypeReturnHome)
		{			
			return;
		}
		m_pSelf->SetTarget( pTarget->GetHandle() ); //选定这个玩家为目标
		
		INT_PTR nDir = m_pSelf->GetTargetDir(pTarget);
		m_pSelf->SetDir(nDir); //转向朝向玩家

		// 如果原来在追逐，停止掉。否则可能会跑到新目标后，又跑向老的目标 （如果当前是乱走，那么此流程会有问题）

		if (m_pSelf->GetType() != enPet)
		{
			m_pSelf->GetMoveSystem()->ClearMotionStack();
			m_pSelf->GetMoveSystem()->MoveChase(pTarget, m_wMinSkillDis, m_pAiConfig->pursuitDistance); 	
		}
	}
	
	//if(!targetHandle.IsNull())
	//{
		INT_PTR nTargetType = pTarget->GetType();
		if( nTargetType== enActor) //如果攻击的目标是宠物，将开始攻击
		{
			((CActor*)pTarget)->GetPetSystem().OnAttacked(m_pSelf);
			((CActor*)pTarget)->GetHeroSystem().OnAttacked(m_pSelf);
		}
		else if(nTargetType == enPet)
		{
			((CPet*)pTarget)->GetAI()->AttackedBy(m_pSelf);
		}
		else if(nTargetType == enHero)
		{
			((CHero*)pTarget)->GetAI()->AttackedBy(m_pSelf);
		}
	//}
	
		
	//发现目标的说话
	// if (bFoundNewTarget && m_pSelf->IsMonster())
	// {
	// 	CMonster *pMonsterPtr = ((CMonster *)m_pSelf);
	// 	pMonsterPtr->MonsterSay(mstFoundTarget);
	// 	const PMONSTERCONFIG pMonster= GetLogicServer()->GetDataProvider()->GetMonsterConfig().GetMonsterData(m_pSelf->GetId());
	// 	if( pMonster !=NULL )
	// 	{
	// 		int nId = pMonster->bTargetMusicId;
	// 		BYTE nRate = pMonster->bTargetMusicRate;
	// 		if(nId >0  && nRate >0)
	// 		{
	// 			if(nRate >= wrand(101))
	// 			{
	// 				char buff[512];
	// 				CDataPacket pack(buff,sizeof(buff));
	// 				pack << (BYTE) enDefaultEntitySystemID;
	// 				pack << (BYTE) sFoundTarget;
	// 				pack << (Uint64) m_pSelf->GetHandle() <<nId ;
	// 				pMonsterPtr->GetObserverSystem()->BroadCast(pack.getMemoryPtr(),pack.getPosition(),false);
	// 			}
	// 		}
	// 	}
	// }
}

 void CAnimalAI::AttackStop(CAnimal * pTarget)
{
	EnterEvadeMode();
}

void CAnimalAI::SetNextCheckEnemyTimer()
{
	if (m_pAiConfig->nCheckEnemyIntervalInCombat <= 0)
		m_1sCheckEnemyInCombat.SetNextHitTimeFromNow(1000000000);
	else
		m_1sCheckEnemyInCombat.SetNextHitTimeFromNow(m_pAiConfig->nCheckEnemyIntervalInCombat);
}

bool  CAnimalAI::NeedOntimeCheck(TICKCOUNT nCurrentTick)
{
	return true;
}

//开始回归
void CAnimalAI::EnterEvadeMode()
{
	if( m_pSelf->HasState(esStateDeath) ) return; //死了不回归
	if( m_pSelf->HasState(esStateReturnHome) ) return; //已经在回归状态了
	
	m_pSelf->RemoveState(esStateBattle); //删除战斗模式		
	CMovementSystem*  pMyMoveSystem(m_pSelf->GetMoveSystem());
	// if (m_bInFollowingStats)	// 跟随状态，不回归
	// {
	// 	if( pMyMoveSystem->GetMotionType() ==  CMovementSystem::mtMotionTypeChase)
	// 	{
	// 		pMyMoveSystem->PopCurrentMotionState(); //删除当前的追逐
	// 	}
	// 	if( pMyMoveSystem->GetMotionType() ==  CMovementSystem::mtMotionTypeIdle)
	// 	{
	// 		pMyMoveSystem->PopCurrentMotionState(); //删除当前的追逐
	// 	}
	// 	return;
	// }

	bool canMove =m_pSelf->CanEnterState(esStateMove);
	bool boNoReturnHome = m_pSelf->GetAttriFlag().noReturnHome;
	if(canMove && !boNoReturnHome)
	{
		m_pSelf->AddState(esStateReturnHome);
	}
	
	if(m_pSelf->GetType() == enMonster )
	{

		if (boNoReturnHome)
		{
			m_pSelf->GetMoveSystem()->ClearMotionStack();
			if(m_pAiConfig->patrolRadius > 0) // 怪物巡逻
			{
				m_pSelf->GetMoveSystem()->MoveNoReturnHome(m_pAiConfig->patrolRadius,m_pAiConfig->nStopMinTime,m_pAiConfig->nStopMaxTime);
			}
		}
		else
		{
			if( pMyMoveSystem->GetMotionType() ==  CMovementSystem::mtMotionTypeChase)
			{
				pMyMoveSystem->PopCurrentMotionState(); //删除当前的追逐

			}
			if(canMove && pMyMoveSystem->GetMotionType() ==  CMovementSystem::mtMotionTypeIdle)
			{
				pMyMoveSystem->PopCurrentMotionState(); //删除当前的追逐
			}
		}


		//怪物在回归的时候需要会一下血
		if(m_pAiConfig->returnHomeRenewRate >0 )
		{
			unsigned int nHpValue = m_pSelf->GetProperty<unsigned int>(PROP_CREATURE_HP);
			unsigned int nMpValue = m_pSelf->GetProperty<unsigned int>(PROP_CREATURE_MP);
			nHpValue = __max(nHpValue, m_pSelf->GetProperty<unsigned int>(PROP_CREATURE_MAXHP)* m_pAiConfig->returnHomeRenewRate /100 );
			nMpValue = __max(nMpValue, m_pSelf->GetProperty<unsigned int>(PROP_CREATURE_MAXMP)* m_pAiConfig->returnHomeRenewRate /100 );
			m_pSelf->SetProperty<unsigned int>(PROP_CREATURE_HP,nHpValue);
			m_pSelf->SetProperty<unsigned int>(PROP_CREATURE_MP,nMpValue);
		}
		if(canMove)
		{
			if (m_pSelf->GetAttriFlag().AttackKiller && m_pSelf->GetAttriFlag().DenyMove)
			{
				PMONSTERCONFIG pConfig  = GetLogicServer()->GetDataProvider()->GetMonsterConfig().GetMonsterData(m_pSelf->GetProperty<unsigned int>(PROP_ENTITY_ID));
				if (pConfig)
				{
					INT_PTR nDir = (INT_PTR)(pConfig->btDir != 255? pConfig->btDir : -1);
					INT_PTR nBornPosX, nBornPosY;
					int nPosX,nPosY;
					m_pSelf->GetPosition(nPosX,nPosY);
					((CMonster*)m_pSelf)->GetBornPoint(nBornPosX,nBornPosY);

					if (nPosX != nBornPosX && nBornPosY != nPosY)
					{
						CFuBen* hFb = m_pSelf->GetFuBen();
						GetGlobalLogicEngine()->GetFuBenMgr()->EnterFuBen(m_pSelf,hFb,m_pSelf->GetSceneID(),nBornPosX,nBornPosY);
					}
					m_pSelf->SetDir(nDir);
					m_pSelf->RemoveState(esStateReturnHome);
				}

			}
			else
			{
				if (!boNoReturnHome)
				{
					pMyMoveSystem->MoveTargetedHome(); //是怪物的话要归位
				}
				
			}
		}
		
		m_pSelf->SetTarget(NULL);
		m_pSelf->SetAttackerHandler(0);
		((CMonster *)m_pSelf)->SetVestEntity(EntityHandle());	// 怪物回归清归属
		if (((CMonster *)m_pSelf)->GetAttriFlag().boShowVestEntityName)
		{
			((CMonster *)m_pSelf)->SetVestEntityName("");

		}
	}
}

void CAnimalAI::AttackedBy(CAnimal * pAttacker, bool boInherit)
{
	if (m_pSelf->IsMonster())
		((CMonster *)m_pSelf)->MonsterSay(mstAttacked);
	if (m_pSelf->GetType() == enPet )// ||  m_pSelf->GetType() == enHero)
	{
		if (m_pSelf->GetAttriFlag().PetNoAttact)
		{
			return;
		}
		if ( !pAttacker || pAttacker->IsDeath() )
		{
			return;
		}
		INT_PTR  nDisSquare = m_pSelf->GetEntityDistanceSquare( pAttacker ); //获取距离的平方
		if ( nDisSquare >= (m_pAiConfig->pursuitDistance * m_pAiConfig->pursuitDistance) )
		{
			if (m_pSelf->GetMoveSystem()->GetMotionType() == CMovementSystem::mtMotionTypeChase)
			{
				m_pSelf->GetMoveSystem()->PopCurrentMotionState();
			}
			CActor* pActor = NULL;
			//if(m_pSelf->GetType() == enPet)
			//{
			    pActor =  ((CPet*)m_pSelf)->GetMaster();
			//}else
			//{
			//    pActor =  ((CHero*)m_pSelf)->GetMaster();
			//}
			if ( pActor )
			{
				if (m_pSelf->GetMoveSystem()->GetMotionType() != CMovementSystem::mtMotionTypeFollow)
				{
					m_pSelf->GetMoveSystem()->MoveFollow(pActor);
				}
			}
			return;
		}
	}

	//怪物在回归状态攻击不还手
	if(m_pSelf->HasState(esStateBattle)) //已经在战斗中就不处理
	{
		if (NeedReSelTarget())
			ChangeTarget(pAttacker);
		return;
	}
	
	if(! m_pSelf->HasState(esStateReturnHome))
	{
		AttackStart(pAttacker); //被攻击需要
	}

	if(m_pSelf->GetAttriFlag().BeAttackNeedUseSkill)		//被攻击需要释放技能
	{
		CSkillSubSystem & skillSystem =  m_pSelf->GetSkillSystem();
		const CVector<CSkillSubSystem::SKILLDATA> & skills= skillSystem.GetSkills();

		//这里加这个是为了一个技能
		for(INT_PTR i=0; i< skills.count();i++)
		{
			if(skills[i].bEvent == mSkilleventBeAttacked)
			{
				skillSystem.LaunchSkill(skills[i].nSkillID);
			}
		}
	}
}

bool CAnimalAI::NeedReSelTarget()
{
	if (m_wReSelTargetRate == 0)
		return false;

	unsigned long rn = wrand(100);
	if (rn <= m_wReSelTargetRate)
		return true;

	return false;
}

void CAnimalAI::ChangeTarget(CAnimal *pTarget)
{
	if (!pTarget)  return;
	AttackStart(pTarget);
}

bool CAnimalAI::CheckEnemy()
{	
	if (m_pSelf->IsMonster())
		((CMonster *)m_pSelf)->MonsterSay(mstIdle);

	return false;
}

void CAnimalAI::KillBy(CAnimal  *pAttacker) 
{
	CSkillSubSystem & skillSystem =  m_pSelf->GetSkillSystem();
	const CVector<CSkillSubSystem::SKILLDATA> & skills= skillSystem.GetSkills();

	//这里加这个是为了一个技能
	if(pAttacker)
	{
		EntityHandle handle =  pAttacker->GetHandle() ;
		CEntity *pTarget = GetEntityFromHandle (handle);
		if ( pTarget !=  pAttacker)
		{
			m_pSelf->SetTarget(handle );
		}
	}
	// for(INT_PTR i=0; i< skills.count();i++)
	// {
	// 	if(skills[i].bEvent == mSkillEventDeath)
	// 	{
	// 		skillSystem.LaunchSkill(skills[i].nSkillID,0,0,true,skills[i].nLevel,true);
	// 	}
	// }
}

void CAnimalAI::EntityDestroy() 
{
}