786 lines
No EOL
23 KiB
C++
786 lines
No EOL
23 KiB
C++
|
||
#include "stdafx.h"
|
||
#include "MAAiSkill.h"
|
||
#include "DnMonsterActor.h"
|
||
#include "DnSkill.h"
|
||
#include "DnBlow.h"
|
||
#include "MAAiChecker.h"
|
||
#include "MAAiScript.h"
|
||
#include "MAScanner.h"
|
||
#include "DnStateBlow.h"
|
||
#if defined( PRE_FIX_67719 )
|
||
#include "DNAggroSystem.h"
|
||
#endif
|
||
|
||
|
||
#if defined(PRE_ADD_64990)
|
||
void MonsterSkillAI::CheckSkillTable(lua_State* pLua, vector<string>& skillTableName)
|
||
{
|
||
string tableName = "g_Lua_Skill";
|
||
lua_tinker::table legacySkillTable = lua_tinker::get<lua_tinker::table>(pLua, tableName.c_str());
|
||
if( legacySkillTable.m_obj->m_pointer )
|
||
skillTableName.push_back(tableName);
|
||
else
|
||
skillTableName.push_back("");
|
||
|
||
tableName = "g_Lua_Skill_PvE";
|
||
lua_tinker::table SkillTable_PVE = lua_tinker::get<lua_tinker::table>(pLua, tableName.c_str());
|
||
if( SkillTable_PVE.m_obj->m_pointer )
|
||
skillTableName.push_back(tableName);
|
||
else
|
||
skillTableName.push_back("");
|
||
|
||
|
||
tableName = "g_Lua_Skill_PvP";
|
||
lua_tinker::table SkillTable_PVP = lua_tinker::get<lua_tinker::table>(pLua, tableName.c_str());
|
||
if( SkillTable_PVP.m_obj->m_pointer )
|
||
skillTableName.push_back(tableName);
|
||
else
|
||
skillTableName.push_back("");
|
||
}
|
||
|
||
bool MonsterSkillAI::LoadSkillTable(lua_State* pLua, OUT std::vector<MonsterSkillTable>& _SkillTable, string& tableName)
|
||
{
|
||
// ½ºÅ³ Å×À̺íÀÌ ÀÖ´Ù¸é.
|
||
lua_tinker::table SkillTable = lua_tinker::get<lua_tinker::table>(pLua, tableName.c_str());
|
||
{
|
||
bool bHave = false;
|
||
lua_tinker::table t = SkillTable.get<lua_tinker::table>(1);
|
||
int __nSkillIndex = t.get<int>("skill_index");
|
||
|
||
if ( __nSkillIndex == 0 )
|
||
{
|
||
bHave = false;
|
||
}
|
||
else
|
||
{
|
||
bHave = true;
|
||
}
|
||
|
||
if ( bHave )
|
||
{
|
||
for ( int j = 1 ; j <= SkillTable.getSize() ; j++ )
|
||
{
|
||
lua_tinker::table LocalT = SkillTable.get<lua_tinker::table>(j);
|
||
|
||
int nSkillIndex= LocalT.get<int>("skill_index");
|
||
if ( nSkillIndex == 0 )
|
||
return false;
|
||
|
||
MonsterSkillTable _skilltable;
|
||
|
||
_skilltable.nSkillIndex = nSkillIndex;
|
||
_skilltable.iLuaSkillIndex = (j-1);
|
||
_skilltable.nCooltime = LocalT.get<int>("cooltime");
|
||
_skilltable.nRangeMin = LocalT.get<int>("rangemin");
|
||
_skilltable.nRangeMax = LocalT.get<int>("rangemax");
|
||
_skilltable.nTargetType = LocalT.get<int>("target");
|
||
_skilltable.nCancelLook = LocalT.get<int>("cancellook");
|
||
_skilltable.iPriority = LocalT.get<int>("priority");
|
||
#if defined( PRE_FIX_67719 )
|
||
_skilltable.fRandomTarget = LocalT.get<float>("randomtarget");
|
||
const char* pszRandomTarget = LocalT.get<const char*>("randomtarget");
|
||
if( pszRandomTarget )
|
||
{
|
||
std::string strString(pszRandomTarget);
|
||
std::vector<std::string> vSplit;
|
||
|
||
boost::algorithm::split( vSplit, strString, boost::algorithm::is_any_of(",") );
|
||
|
||
if( 1 < vSplit.size() )
|
||
{
|
||
_skilltable.fRandomTarget = (float)atof(vSplit[0].c_str());
|
||
_skilltable.nIgnoreAggroTarget = atoi(vSplit[1].c_str());
|
||
}
|
||
}
|
||
#endif
|
||
#if defined( PRE_FIX_68096 )
|
||
if( LocalT.get<const char*>("globalcooltime") )
|
||
{
|
||
_skilltable.iGlobalCoolTimeIndex[0] = LocalT.get<int>("globalcooltime")-1;
|
||
_ASSERT( _skilltable.iGlobalCoolTimeIndex[0] >= 0 );
|
||
}
|
||
|
||
for( int i=1 ; i<ActionTableCommon::eCommon::MaxGlobalCoolTime ; ++i )
|
||
{
|
||
char szBuf[MAX_PATH];
|
||
sprintf( szBuf, "globalcooltime%d", i+1 );
|
||
_skilltable.iGlobalCoolTimeIndex[i] = LocalT.get<int>(szBuf)-1;
|
||
if(_skilltable.iGlobalCoolTimeIndex[i] == -1)
|
||
break;
|
||
}
|
||
#else
|
||
if( LocalT.get<const char*>("globalcooltime") )
|
||
{
|
||
_skilltable.iGlobalCoolTimeIndex = LocalT.get<int>("globalcooltime")-1;
|
||
_ASSERT( _skilltable.iGlobalCoolTimeIndex >= 0 );
|
||
}
|
||
#endif
|
||
|
||
_skilltable.iNextLuaSkillIndex = -1;
|
||
if( LocalT.get<const char*>("next_lua_skill_index") )
|
||
_skilltable.iNextLuaSkillIndex = LocalT.get<int>("next_lua_skill_index");
|
||
|
||
#if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.nMultipleTarget = 0;
|
||
#else
|
||
_skilltable.bMultipleTarget = false;
|
||
#endif
|
||
_skilltable.iMaxMultipleTargetCount = 0;
|
||
_skilltable.bIsExceptCannonPlayer = false;
|
||
|
||
const char* pAnyMultipleTarget = LocalT.get<const char*>("anymultipletarget");
|
||
if( pAnyMultipleTarget )
|
||
_skilltable.bIsAnyMultipleTarget = true;
|
||
|
||
const char* pTemp = LocalT.get<const char*>( _skilltable.bIsAnyMultipleTarget ? "anymultipletarget" : "multipletarget" );
|
||
if( pTemp )
|
||
{
|
||
std::string strString( pTemp );
|
||
std::vector<std::string> vSplit;
|
||
boost::algorithm::split( vSplit, strString, boost::algorithm::is_any_of(",") );
|
||
|
||
#if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.nMultipleTarget = boost::lexical_cast<int>(vSplit[0]);
|
||
|
||
if( vSplit.size() > 1 )
|
||
_skilltable.iMaxMultipleTargetCount = boost::lexical_cast<int>(vSplit[1]);
|
||
|
||
if( vSplit.size() > 2 )
|
||
{
|
||
if( stricmp( vSplit[2].c_str(), "exceptcannon" ) == 0 )
|
||
_skilltable.bIsExceptCannonPlayer = true;
|
||
}
|
||
|
||
if (vSplit.size() > 3)
|
||
_skilltable.nSummonerTarget = boost::lexical_cast<int>(vSplit[3]);
|
||
|
||
#else // #if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.bMultipleTarget = boost::lexical_cast<int>(vSplit[0]) ? true : false;
|
||
|
||
if( vSplit.size() == 2 )
|
||
{
|
||
_skilltable.iMaxMultipleTargetCount = boost::lexical_cast<int>(vSplit[1]);
|
||
}
|
||
else if( vSplit.size() == 3 )
|
||
{
|
||
if( stricmp( vSplit[2].c_str(), "exceptcannon" ) == 0 )
|
||
_skilltable.bIsExceptCannonPlayer = true;
|
||
}
|
||
#endif // #if defined (PRE_MOD_AIMULTITARGET)
|
||
}
|
||
|
||
// LoadChekcer
|
||
_skilltable.pMAAiCheckerManager = new CMAAiSkillCheckerManager();
|
||
if( !_skilltable.pMAAiCheckerManager->bLoadChecker( LocalT ) )
|
||
{
|
||
delete _skilltable.pMAAiCheckerManager;
|
||
return false;
|
||
}
|
||
|
||
_SkillTable.push_back(_skilltable);
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
#endif // PRE_ADD_64990
|
||
|
||
bool MonsterSkillAI::LoadSkillTable(lua_State* pLua, OUT std::vector<MonsterSkillTable>& _SkillTable)
|
||
{
|
||
// bool bHave = false;
|
||
|
||
// ½ºÅ³ Å×À̺íÀÌ ÀÖ´Ù¸é.
|
||
lua_tinker::table SkillTable = lua_tinker::get<lua_tinker::table>(pLua, "g_Lua_Skill");
|
||
{
|
||
bool bHave = false;
|
||
lua_tinker::table t = SkillTable.get<lua_tinker::table>(1);
|
||
int __nSkillIndex = t.get<int>("skill_index");
|
||
|
||
if ( __nSkillIndex == 0 )
|
||
{
|
||
bHave = false;
|
||
}
|
||
else
|
||
{
|
||
bHave = true;
|
||
}
|
||
|
||
if ( bHave )
|
||
{
|
||
for ( int j = 1 ; j <= SkillTable.getSize() ; j++ )
|
||
{
|
||
lua_tinker::table LocalT = SkillTable.get<lua_tinker::table>(j);
|
||
|
||
int nSkillIndex= LocalT.get<int>("skill_index");
|
||
if ( nSkillIndex == 0 )
|
||
return false;
|
||
|
||
MonsterSkillTable _skilltable;
|
||
|
||
_skilltable.nSkillIndex = nSkillIndex;
|
||
_skilltable.iLuaSkillIndex = (j-1);
|
||
_skilltable.nCooltime = LocalT.get<int>("cooltime");
|
||
_skilltable.nRangeMin = LocalT.get<int>("rangemin");
|
||
_skilltable.nRangeMax = LocalT.get<int>("rangemax");
|
||
_skilltable.nTargetType = LocalT.get<int>("target");
|
||
_skilltable.nCancelLook = LocalT.get<int>("cancellook");
|
||
_skilltable.iPriority = LocalT.get<int>("priority");
|
||
#if defined( PRE_FIX_67719 )
|
||
_skilltable.fRandomTarget = LocalT.get<float>("randomtarget");
|
||
#endif
|
||
|
||
#if defined( PRE_FIX_68096 )
|
||
if( LocalT.get<const char*>("globalcooltime") )
|
||
{
|
||
_skilltable.iGlobalCoolTimeIndex[0] = LocalT.get<int>("globalcooltime")-1;
|
||
_ASSERT( _skilltable.iGlobalCoolTimeIndex[0] >= 0 );
|
||
}
|
||
|
||
for( int i=1 ; i<ActionTableCommon::eCommon::MaxGlobalCoolTime ; ++i )
|
||
{
|
||
char szBuf[MAX_PATH];
|
||
sprintf( szBuf, "globalcooltime%d", i+1 );
|
||
_skilltable.iGlobalCoolTimeIndex[i] = LocalT.get<int>(szBuf)-1;
|
||
if(_skilltable.iGlobalCoolTimeIndex[i] == -1)
|
||
break;
|
||
}
|
||
#else
|
||
if( LocalT.get<const char*>("globalcooltime") )
|
||
{
|
||
_skilltable.iGlobalCoolTimeIndex = LocalT.get<int>("globalcooltime")-1;
|
||
_ASSERT( _skilltable.iGlobalCoolTimeIndex >= 0 );
|
||
}
|
||
#endif
|
||
|
||
_skilltable.iNextLuaSkillIndex = -1;
|
||
if( LocalT.get<const char*>("next_lua_skill_index") )
|
||
_skilltable.iNextLuaSkillIndex = LocalT.get<int>("next_lua_skill_index");
|
||
|
||
#if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.nMultipleTarget = 0;
|
||
#else
|
||
_skilltable.bMultipleTarget = false;
|
||
#endif
|
||
_skilltable.iMaxMultipleTargetCount = 0;
|
||
_skilltable.bIsExceptCannonPlayer = false;
|
||
|
||
const char* pAnyMultipleTarget = LocalT.get<const char*>("anymultipletarget");
|
||
if( pAnyMultipleTarget )
|
||
_skilltable.bIsAnyMultipleTarget = true;
|
||
|
||
const char* pTemp = LocalT.get<const char*>( _skilltable.bIsAnyMultipleTarget ? "anymultipletarget" : "multipletarget" );
|
||
if( pTemp )
|
||
{
|
||
std::string strString( pTemp );
|
||
std::vector<std::string> vSplit;
|
||
boost::algorithm::split( vSplit, strString, boost::algorithm::is_any_of(",") );
|
||
|
||
#if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.nMultipleTarget = boost::lexical_cast<int>(vSplit[0]);
|
||
|
||
if( vSplit.size() > 1 )
|
||
_skilltable.iMaxMultipleTargetCount = boost::lexical_cast<int>(vSplit[1]);
|
||
|
||
if( vSplit.size() > 2 )
|
||
{
|
||
if( stricmp( vSplit[2].c_str(), "exceptcannon" ) == 0 )
|
||
_skilltable.bIsExceptCannonPlayer = true;
|
||
}
|
||
|
||
if (vSplit.size() > 3)
|
||
_skilltable.nSummonerTarget = boost::lexical_cast<int>(vSplit[3]);
|
||
|
||
#else // #if defined (PRE_MOD_AIMULTITARGET)
|
||
_skilltable.bMultipleTarget = boost::lexical_cast<int>(vSplit[0]) ? true : false;
|
||
|
||
if( vSplit.size() == 2 )
|
||
{
|
||
_skilltable.iMaxMultipleTargetCount = boost::lexical_cast<int>(vSplit[1]);
|
||
}
|
||
else if( vSplit.size() == 3 )
|
||
{
|
||
if( stricmp( vSplit[2].c_str(), "exceptcannon" ) == 0 )
|
||
_skilltable.bIsExceptCannonPlayer = true;
|
||
}
|
||
#endif // #if defined (PRE_MOD_AIMULTITARGET)
|
||
}
|
||
|
||
// LoadChekcer
|
||
_skilltable.pMAAiCheckerManager = new CMAAiSkillCheckerManager();
|
||
if( !_skilltable.pMAAiCheckerManager->bLoadChecker( LocalT ) )
|
||
{
|
||
delete _skilltable.pMAAiCheckerManager;
|
||
return false;
|
||
}
|
||
|
||
_SkillTable.push_back(_skilltable);
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void MonsterSkillAI::Initialize(std::vector<MonsterSkillTable>* pSkilltable, DnActorHandle hActor)
|
||
{
|
||
m_pSkillTable = pSkilltable;
|
||
m_hActor = hActor;
|
||
if( m_hActor )
|
||
m_pMonsterActor = static_cast<CDnMonsterActor*>(m_hActor.GetPointer());
|
||
m_CoolTime.Clear();
|
||
|
||
m_mSkillTable.clear();
|
||
for( UINT i=0 ; i<m_pSkillTable->size() ; ++i )
|
||
{
|
||
MonsterSkillTable& table = m_pSkillTable->at(i);
|
||
m_mSkillTable.insert( std::make_pair(table.nSkillIndex,i) );
|
||
}
|
||
|
||
DN_ASSERT( m_pMonsterActor != NULL, "m_pMonsterActor == NULL ÀÌ µÉ ¼ö ¾øÀ½!!!" );
|
||
}
|
||
|
||
void MonsterSkillAI::Process( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
}
|
||
|
||
bool MonsterSkillAI::ScanActor(float fMinDist, float fMaxDist, int nTargetType, OUT DNVector(DnActorHandle)& ActorList)
|
||
{
|
||
switch( nTargetType )
|
||
{
|
||
case MonsterSkillTable::SAMETEAM: // °°ÀºÆÀ
|
||
{
|
||
GetMAScanner().Scan( MAScanner::eType::MonsterSkillSameTeam, m_hActor, fMinDist, fMaxDist, ActorList );
|
||
break;
|
||
}
|
||
case MonsterSkillTable::OPPONENTTEAM: // »ó´ëÆÀ
|
||
{
|
||
GetMAScanner().Scan( MAScanner::eType::MonsterSkillOpponentTeam, m_hActor, fMinDist, fMaxDist, ActorList );
|
||
break;
|
||
}
|
||
case MonsterSkillTable::SAMETEAM_EXPECTME: // ³ª¸¦ Á¦¿ÜÇÑ °°ÀºÆÀ
|
||
{
|
||
GetMAScanner().Scan( MAScanner::eType::MonsterSkillSameTeamExpectMe, m_hActor, fMinDist, fMaxDist, ActorList );
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
_DANGER_POINT();
|
||
break;
|
||
}
|
||
}
|
||
|
||
return !ActorList.empty();
|
||
}
|
||
|
||
void MonsterSkillAI::AddWaitOrderCount( DnActorHandle hActor, int iSkillID )
|
||
{
|
||
if( !hActor || !hActor->IsMonsterActor() )
|
||
return;
|
||
CDnMonsterActor* pMonster = static_cast<CDnMonsterActor*>(hActor.GetPointer());
|
||
pMonster->AddWaitOrderCount( iSkillID );
|
||
}
|
||
|
||
void MonsterSkillAI::DelWaitOrderCount( DnActorHandle hActor, int iSkillID )
|
||
{
|
||
if( !hActor || !hActor->IsMonsterActor() )
|
||
return;
|
||
CDnMonsterActor* pMonster = static_cast<CDnMonsterActor*>(hActor.GetPointer());
|
||
pMonster->DelWaitOrderCount( iSkillID );
|
||
}
|
||
|
||
bool MonsterSkillAI::UseSkill( int iArrayIndex/*=-1*/ )
|
||
{
|
||
m_iNextLuaSkillIndex = -1;
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// ÇöÀç MP¼Ò¸ð ½ºÅ³ »ç¿ëºÒ°¡·Î Àû¿ëµÇ¾î ÀÖ´Â ½ºÅ³ È¿°ú¿¡ Ãß°¡·Î ¸ó½ºÅÍ¿¡°Ô ´Ù¸¥ È¿°ú¸¦ Àû¿ë ºÎŹµå¸³´Ï´Ù.
|
||
|
||
// ¸ó½ºÅÍ¿¡°Ô Àû¿ëµÇ´Â È¿°ú
|
||
// ÇØ´ç ½Ã°£µ¿¾È ¾×¼ÇÅø¿¡¼ STATE°ªÀÌ AttackÀ¸·Î µÇ¾î ÀÖ´Â ¾×¼ÇÀ» Á¦ÇÑÇÑ´Ù.
|
||
// ½ºÅ³À» »ç¿ëÇÏ´Â °æ¿ì¿£ CDnMonsterActor::CmdAction() ¸»°í ÀÌÂÊÀ¸·Î È£ÃâµÇ°í ½ºÅ³ ³»ºÎ¿¡¼±
|
||
// SetActionQueue() ·Î ¾×¼ÇÀ» ¼ÂÆÃÇϹǷΠCDnMonsterActor::CmdAction() °ú ÀÌ°÷µµ ¸·¾Æ¾ß ÇÕ´Ï´Ù.
|
||
// ·çƾ ´Ù½Ã Ãß°¡ ÇÕ´Ï´Ù. ¤Ð¤Ð -Çѱâ.
|
||
if( m_hActor && m_hActor->GetStateBlow() )
|
||
{
|
||
if( m_hActor->GetStateBlow()->IsApplied( STATE_BLOW::BLOW_078 ) )
|
||
return false;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
DWORD dwTime = timeGetTime();
|
||
|
||
DNVector(_UsableSkill) UsableSkill;
|
||
|
||
for ( int i = 0 ; i < (int)m_pSkillTable->size() ; i++ )
|
||
{
|
||
if( iArrayIndex >= 0 )
|
||
{
|
||
if( i != iArrayIndex )
|
||
continue;
|
||
}
|
||
|
||
MonsterSkillTable& table = m_pSkillTable->at(i);
|
||
|
||
// ½ºÅ³ÀÌ ÀÖ´ÂÁö üũ
|
||
DnSkillHandle hSkill = m_hActor->FindSkill(table.nSkillIndex);
|
||
if ( !hSkill )
|
||
continue;
|
||
|
||
// ½ºÅ³ÀÌ »ç¿ë°¡´ÉÇÑÁö.
|
||
if ( hSkill->GetCoolTime() > 0.0f )
|
||
continue;
|
||
|
||
// ¾ÆÁ÷ ÄðŸÀÓÀÌ ³²¾Ò´Ù¸é
|
||
if( m_CoolTime.Update( table.nSkillIndex, dwTime ) )
|
||
{
|
||
//g_Log.LogA( "SKILL:%d ÄðŸÀÓÁßÀÔ´Ï´Ù.\r\n", table.nSkillIndex );
|
||
continue;
|
||
}
|
||
|
||
/*
|
||
ArrayIndex °¡ ÇÒ´çµÈ ½ºÅ³Àº rate üũ¸¦ ÇÏÁö ¾Ê´Â´Ù.
|
||
*/
|
||
bool bIgnoreRate = false;
|
||
bool bAnnounceSkill = table.pMAAiCheckerManager->bIsAnnounceSkill();
|
||
if( iArrayIndex >= 0 || bAnnounceSkill == true )
|
||
bIgnoreRate = true;
|
||
table.pMAAiCheckerManager->IgnoreRateChecker( bIgnoreRate );
|
||
|
||
if( !_bIsActorChecker(table) )
|
||
continue;
|
||
|
||
if( m_hActor->IsLimitAction( hSkill ) )
|
||
continue;
|
||
|
||
DnActorHandle hTargetActor;
|
||
if ( TargetCheck(i, hSkill, hTargetActor) == false )
|
||
{
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
_UsableSkill _us;
|
||
_us.nTableIdx = i ;
|
||
_us.nSkillID = table.nSkillIndex;
|
||
_us.hTargetActor = hTargetActor;
|
||
UsableSkill.push_back(_us);
|
||
|
||
if( bAnnounceSkill )
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( UsableSkill.empty() )
|
||
{
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
int iPriorityIdx = -1;
|
||
int iPriorityVal = 0;
|
||
for( UINT i=0 ; i<UsableSkill.size() ; ++i )
|
||
{
|
||
const MonsterSkillTable& table = m_pSkillTable->at(UsableSkill[i].nTableIdx);
|
||
if( table.iPriority > 0 && iPriorityVal < table.iPriority )
|
||
{
|
||
iPriorityIdx = i;
|
||
iPriorityVal = table.iPriority;
|
||
}
|
||
}
|
||
|
||
_UsableSkill us;
|
||
if( iPriorityIdx >= 0 )
|
||
{
|
||
us = UsableSkill[iPriorityIdx];
|
||
}
|
||
else
|
||
{
|
||
us = UsableSkill[_rand(m_hActor->GetRoom())%UsableSkill.size()];
|
||
}
|
||
|
||
MonsterSkillTable& table = m_pSkillTable->at(us.nTableIdx);
|
||
if ( table.nCancelLook == 1 )
|
||
{
|
||
//if ( m_hActor->GetLookTarget() )
|
||
{
|
||
m_hActor->ResetMove();
|
||
m_hActor->ResetLook();
|
||
m_hActor->CmdLook(CDnActor::Identity(), false);
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if( m_pMonsterActor->GetAggroTarget() != us.hTargetActor
|
||
#ifdef PRE_ADD_AURA_FOR_MONSTER
|
||
&& table.nTargetType != MonsterSkillTable::_TargetType::SAMETEAM // °°ÀºÆí¿¡°Ô ¾²´Â ½ºÅ³Àº ¾î±×·Î¸¦ ¹Ù²ÙÁö¾Ê´Â´Ù. Ex> ¿À¶óÇü ½ºÅ³.
|
||
#endif
|
||
)
|
||
{
|
||
m_pMonsterActor->GetAIBase()->ChangeTarget( us.hTargetActor );
|
||
}
|
||
|
||
/*
|
||
if ( m_hActor->GetLookTarget() != us.hTargetActor )
|
||
{
|
||
m_hActor->CmdLook(us.hTargetActor);
|
||
|
||
// ¾Æ±º¿¡°Ô »ç¿ëÇÏ´Â ½ºÅ³ÀÎ °æ¿ì Ÿ°ÙÀ» ¼³Á¤ÇØÁØ´Ù.
|
||
if( m_hActor->GetTeam() == us.hTargetActor->GetTeam() )
|
||
{
|
||
CDnMonsterActor* pMonster = static_cast<CDnMonsterActor*>(m_hActor.GetPointer());
|
||
pMonster->GetAIBase()->ChangeTarget( us.hTargetActor );
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
#if defined(PRE_FIX_64312)
|
||
if (table.pMAAiCheckerManager)
|
||
{
|
||
std::vector<CMAAiActorChecker*>& checkerList = table.pMAAiCheckerManager->GetActorCheckerList();
|
||
|
||
std::vector<CMAAiActorChecker*>::iterator iter = checkerList.begin();
|
||
std::vector<CMAAiActorChecker*>::iterator endIter = checkerList.end();
|
||
|
||
int nMasterSkillID = -1;
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
CMAAiActorChecker* pChecker = *iter;
|
||
if (pChecker)
|
||
{
|
||
CMAAiActorSkillToggleChecker* pSkillToggleChecker = dynamic_cast<CMAAiActorSkillToggleChecker*>(pChecker);
|
||
if (pSkillToggleChecker)
|
||
{
|
||
nMasterSkillID = pSkillToggleChecker->GetSkillID();
|
||
}
|
||
else
|
||
{
|
||
CMAAiActorPassiveSkillChecker* pPassiveSkillChecker = dynamic_cast<CMAAiActorPassiveSkillChecker*>(pChecker);
|
||
if (pPassiveSkillChecker)
|
||
{
|
||
nMasterSkillID = pPassiveSkillChecker->GetSkillID();
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
if (nMasterSkillID != -1)
|
||
{
|
||
DnSkillHandle hMonsterSkill = m_hActor->FindSkill(us.nSkillID);
|
||
DnSkillHandle hMasterBaseSkill;
|
||
DnSkillHandle hMonsterExSkill;
|
||
|
||
DnActorHandle hMasterActor = m_pMonsterActor->GetSummonerPlayerActor();
|
||
if (hMasterActor)
|
||
hMasterBaseSkill = hMasterActor->FindSkill(nMasterSkillID);
|
||
|
||
if (hMasterBaseSkill)
|
||
hMonsterExSkill = hMasterBaseSkill->GetSummonMonsterEnchangeSkill();
|
||
|
||
if (hMonsterSkill && hMonsterExSkill)
|
||
{
|
||
//Ŭ¶óÀ̾ðÆ®·Î ÆÐŶ º¸³»¼ ½ºÅ³ Àû¿ë..
|
||
m_pMonsterActor->SendApplySummonMonsterExSkill(hMonsterSkill->GetClassID(), hMonsterSkill->GetLevel(), hMonsterSkill->GetSelectedLevelDataType(),
|
||
hMasterActor->GetUniqueID(), hMasterBaseSkill->GetClassID());
|
||
hMonsterSkill->ApplySummonMonsterEnchantSkill(hMonsterExSkill);
|
||
}
|
||
}
|
||
}
|
||
#endif // PRE_FIX_64312
|
||
|
||
CDnSkill::UsingResult eResult = m_hActor->UseSkill(us.nSkillID,true,false,m_pSkillTable->at(us.nTableIdx).iLuaSkillIndex );
|
||
if ( CDnSkill::UsingResult::Success == eResult )
|
||
{
|
||
DelWaitOrderCount( m_hActor, us.nSkillID );
|
||
m_CoolTime.AddCoolTime( table.nSkillIndex, dwTime+table.nCooltime );
|
||
#if defined( PRE_FIX_68096 )
|
||
for( int i=0 ; i<ActionTableCommon::eCommon::MaxGlobalCoolTime ; ++i )
|
||
{
|
||
if( table.iGlobalCoolTimeIndex[i] >= 0 )
|
||
{
|
||
if( table.iGlobalCoolTimeIndex[i] < static_cast<int>(static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->GetScriptData().m_AIGlobalCoolTime.size()) )
|
||
static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->m_GlobalCoolTime.AddCoolTime( table.iGlobalCoolTimeIndex[i], dwTime+static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->GetScriptData().m_AIGlobalCoolTime[table.iGlobalCoolTimeIndex[i]].dwCoolTime );
|
||
else
|
||
_ASSERT(0);
|
||
}
|
||
}
|
||
#else
|
||
if( table.iGlobalCoolTimeIndex >= 0 )
|
||
{
|
||
if( table.iGlobalCoolTimeIndex < static_cast<int>(static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->GetScriptData().m_AIGlobalCoolTime.size()) )
|
||
static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->m_GlobalCoolTime.AddCoolTime( table.iGlobalCoolTimeIndex, dwTime+static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase())->GetScriptData().m_AIGlobalCoolTime[table.iGlobalCoolTimeIndex].dwCoolTime );
|
||
else
|
||
_ASSERT(0);
|
||
}
|
||
#endif
|
||
|
||
//g_Log.LogA( "SKILL:%d »ç¿ë!!!\r\n", table.nSkillIndex );
|
||
|
||
MAAiScript* pMAAiScript = static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase());
|
||
|
||
DN_ASSERT( pMAAiScript != NULL, "pMAAiScript == NULL" );
|
||
DN_ASSERT( m_pSkillTable->size() > static_cast<size_t>(us.nTableIdx), "m_pSkillTable.size() > us.nTableIdx" );
|
||
|
||
pMAAiScript->m_cMultipleTarget.SetMultipleTargetSkill( &m_pSkillTable->at(us.nTableIdx) );
|
||
// ´ÙÀ½½ÇÇàÇÒ ½ºÅ³ À妽º ±â¾ï
|
||
m_iNextLuaSkillIndex = m_pSkillTable->at(us.nTableIdx).iNextLuaSkillIndex;
|
||
|
||
#if defined( PRE_ADD_ACADEMIC )
|
||
DnSkillHandle hSkill = m_hActor->FindSkill(us.nSkillID);
|
||
// Ç÷¹À̾îMP ¼Ò¸ð
|
||
if( hSkill && hSkill->GetSummonerDecreaseSP() && m_hActor->IsMonsterActor() )
|
||
{
|
||
CDnMonsterActor* pMonster = static_cast<CDnMonsterActor*>(m_hActor.GetPointer());
|
||
DnActorHandle hSummoner = pMonster->GetSummonerPlayerActor();
|
||
if( hSummoner )
|
||
{
|
||
int iSP = hSummoner->GetSP()-hSkill->GetSummonerDecreaseSP();
|
||
if( iSP < 0 )
|
||
iSP = 0;
|
||
hSummoner->CmdRefreshHPSP( hSummoner->GetHP(), iSP );
|
||
}
|
||
}
|
||
#endif // #if defined( PRE_ADD_ACADEMIC )
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool MonsterSkillAI::_bIsActorChecker( const MonsterSkillTable& table )
|
||
{
|
||
return table.pMAAiCheckerManager->bIsActorChecker( m_hActor, table.iLuaSkillIndex );
|
||
}
|
||
|
||
void MonsterSkillAI::_bIsTargetActorChecker( MonsterSkillTable& table, DNVector(DnActorHandle)& SelectedList )
|
||
{
|
||
for( DNVector(DnActorHandle)::iterator itor=SelectedList.begin() ; itor!=SelectedList.end() ; )
|
||
{
|
||
bool bErase = true;
|
||
if( table.pMAAiCheckerManager->bIsTargetActorChecker( m_hActor, *itor ) )
|
||
bErase = false;
|
||
|
||
if( bErase == true )
|
||
itor = SelectedList.erase( itor );
|
||
else
|
||
++itor;
|
||
}
|
||
}
|
||
|
||
bool MonsterSkillAI::TargetCheck(int nSkillTableID, DnSkillHandle hSkill, OUT DnActorHandle& hTargetActor)
|
||
{
|
||
if ( !m_pSkillTable || nSkillTableID >= (int)m_pSkillTable->size() )
|
||
return false;
|
||
|
||
hTargetActor = CDnActor::Identity();
|
||
MonsterSkillTable& table = m_pSkillTable->at(nSkillTableID);
|
||
|
||
DNVector(DnActorHandle) ScanList;
|
||
|
||
// SelfPercent
|
||
switch(table.nTargetType)
|
||
{
|
||
case MonsterSkillTable::SELF:
|
||
{
|
||
hTargetActor = m_hActor;
|
||
return true;
|
||
}
|
||
case MonsterSkillTable::OPPONENTTEAM:
|
||
{
|
||
hTargetActor = m_pMonsterActor->GetAggroTarget();
|
||
if( !hTargetActor )
|
||
return false;
|
||
#if defined( PRE_FIX_67719 )
|
||
if( table.fRandomTarget > 0.f )
|
||
{
|
||
if( !_SelectRandomTarget( table ) && table.nIgnoreAggroTarget == 1 )
|
||
return false;
|
||
else
|
||
hTargetActor = m_pMonsterActor->GetAggroTarget();
|
||
if( !hTargetActor )
|
||
return false;
|
||
}
|
||
#endif
|
||
// °Å¸® üũ
|
||
if( !MAAiScript::bIsTargetDistance( m_hActor, hTargetActor, table.nRangeMin, table.nRangeMax ) )
|
||
return false;
|
||
|
||
ScanList.push_back( hTargetActor );
|
||
break;
|
||
}
|
||
case MonsterSkillTable::SAMETEAM:
|
||
{
|
||
ScanActor((float)table.nRangeMin, (float)table.nRangeMax, table.nTargetType, ScanList );
|
||
break;
|
||
}
|
||
case MonsterSkillTable::SAMETEAM_EXPECTME:
|
||
{
|
||
ScanActor((float)table.nRangeMin, (float)table.nRangeMax, table.nTargetType, ScanList );
|
||
break;
|
||
}
|
||
}
|
||
|
||
// TargetActor üũ
|
||
_bIsTargetActorChecker( table, ScanList );
|
||
|
||
if( !ScanList.empty() )
|
||
{
|
||
hTargetActor = ScanList[_rand(m_hActor->GetRoom())%ScanList.size()];
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
#if defined( PRE_FIX_67719 )
|
||
bool MonsterSkillAI::_SelectRandomTarget( MonsterSkillTable& table )
|
||
{
|
||
if( table.fRandomTarget == 0.f )
|
||
return false;
|
||
|
||
if(!m_pMonsterActor)
|
||
return false;
|
||
|
||
DNVector(DnActorHandle) vTarget;
|
||
MAAiScript* pMAAiScript = static_cast<MAAiScript*>(m_pMonsterActor->GetAIBase());
|
||
|
||
if(!pMAAiScript)
|
||
return false;
|
||
|
||
pMAAiScript->GetTargetDistance( table.nRangeMin, table.nRangeMax, vTarget );
|
||
if( vTarget.empty() )
|
||
return false;
|
||
|
||
DnActorHandle hPrevTarget = pMAAiScript->GetTarget();
|
||
|
||
size_t uiRand = _rand(m_hActor->GetRoom())%vTarget.size();
|
||
|
||
if( !table.pMAAiCheckerManager->bIsTargetActorChecker( m_hActor, vTarget[uiRand] ) )
|
||
return false;
|
||
|
||
pMAAiScript->ChangeTarget( vTarget[uiRand] );
|
||
|
||
if( table.fRandomTarget > 0.f )
|
||
{
|
||
CDNAggroSystem* pAggroSystem = m_hActor->GetAggroSystem();
|
||
CDNAggroSystem::AggroStruct* pPrevStruct = pAggroSystem->GetAggroStruct( hPrevTarget );
|
||
if( pPrevStruct )
|
||
{
|
||
CDNAggroSystem::AggroStruct* pStruct = pAggroSystem->GetAggroStruct( vTarget[uiRand] );
|
||
if( pStruct )
|
||
{
|
||
pStruct->iAggro = static_cast<int>(pPrevStruct->iAggro * table.fRandomTarget);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
#endif |