3629 lines
No EOL
106 KiB
C++
3629 lines
No EOL
106 KiB
C++
#include "StdAfx.h"
|
||
#include "MASkillUser.h"
|
||
#include "DnSkill.h"
|
||
#include "IDnSkillUsableChecker.h"
|
||
#include "IDnSkillProcessor.h"
|
||
#include "InputReceiver.h"
|
||
#include "DnProjectile.h"
|
||
#include "DnPlayerActor.h"
|
||
#include "DnChangeProjectileProcessor.h"
|
||
#include "DnChangeActionStrProcessor.h"
|
||
#include "DnBlow.h"
|
||
#include "DnSkillTask.h"
|
||
#include "DnStateBlow.h"
|
||
#ifndef _GAMESERVER
|
||
#include "DnCantUseActiveSkillBlow.h"
|
||
#include "DnWorld.h"
|
||
#include "TaskManager.h"
|
||
#include "DnItemTask.h"
|
||
#include "DnInterface.h"
|
||
#else
|
||
#include "DNUserSession.h"
|
||
#include "DnApplySEWhenTargetNormalHitProcessor.h"
|
||
#endif
|
||
|
||
#if defined(_GAMESERVER)
|
||
#include "DnProbabilityChecker.h"
|
||
#endif
|
||
|
||
#include "DnCreateBlow.h"
|
||
|
||
#include "SmartPtrDef.h"
|
||
|
||
#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
|
||
#include "TotalLevelSkillSystem.h"
|
||
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
MASkillUser::MASkillUser()
|
||
//: m_vSkillTargetPos( 0.f, 0.f, 0.f )
|
||
{
|
||
m_LocalTime = 0;
|
||
|
||
m_pActor = NULL;
|
||
m_bIsValidActor = true;
|
||
|
||
//m_fAdjustCoolTime = 1.0f;
|
||
#ifdef _GAMESERVER
|
||
m_bIgnoreCoolTime = false;
|
||
#else
|
||
m_bSkillExecutedThisFrame = false;
|
||
#endif
|
||
|
||
m_fCoolTimeDeltaAdjustValue = 1.0f;
|
||
|
||
//ZeroMemory( m_aEternityItemApplyStat, sizeof(m_aEternityItemApplyStat) );
|
||
}
|
||
|
||
MASkillUser::~MASkillUser()
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ ) {
|
||
if( m_vbSelfAllocList[i] == true ) SAFE_RELEASE_SPTR( m_vlhSkillList[i] );
|
||
}
|
||
SAFE_DELETE_VEC( m_vlhSkillList );
|
||
SAFE_DELETE_VEC( m_vbSelfAllocList );
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
S_SKILL_OBJECT& SkillObject = m_vlSkillObjects.at( i );
|
||
if( true == SkillObject.bSelfAlloc )
|
||
SAFE_RELEASE_SPTR( SkillObject.hSkill );
|
||
}
|
||
SAFE_DELETE_VEC( m_vlSkillObjects );
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
#if defined(_GAMESERVER)
|
||
m_PrefixSkillCoolTimeManager.InitList();
|
||
|
||
//¹æ¾î¿ë ½ºÅ³ ÃʱâÈ
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemDefenceSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator endIter = m_prefixSystemDefenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
SAFE_RELEASE_SPTR(iter->second.hSkill);
|
||
}
|
||
SAFE_DELETE_MAP(m_prefixSystemDefenceSkills);
|
||
|
||
//°ø°Ý¿ë ½ºÅ³ ÃʱâÈ
|
||
iter = m_prefixSystemOffenceSkills.begin();
|
||
endIter = m_prefixSystemOffenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
SAFE_RELEASE_SPTR(iter->second.hSkill);
|
||
}
|
||
SAFE_DELETE_MAP(m_prefixSystemOffenceSkills);
|
||
#endif // _GAMESERVER
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
#if defined(_GAMESERVER)
|
||
{
|
||
//Á¢µÎ»ç ¹æ¾î¿ë ½ºÅ³
|
||
PREFIX_SKILL_INFO::iterator iter = m_PrefixDefenceSkills.begin();
|
||
PREFIX_SKILL_INFO::iterator endIter = m_PrefixDefenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
if(iter->second)
|
||
SAFE_DELETE(iter->second);
|
||
}
|
||
m_PrefixDefenceSkills.clear();
|
||
|
||
//Á¢µÎ»ç °ø°Ý¿ë ½ºÅ³
|
||
iter = m_PrefixOffenceSkills.begin();
|
||
endIter = m_PrefixOffenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
if(iter->second)
|
||
SAFE_DELETE(iter->second);
|
||
}
|
||
m_PrefixOffenceSkills.clear();
|
||
|
||
//»ç¿ëÁßÀÎ Á¢µÎ»ç °ø°Ý¿ë ½ºÅ³ ¸®½ºÆ®
|
||
m_ProcessPrefixOffenceSkills.clear();
|
||
}
|
||
#endif // _GAMESERVER
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
}
|
||
|
||
bool MASkillUser::IsValidActor()
|
||
{
|
||
if( m_pActor ) return true;
|
||
else {
|
||
if( !m_bIsValidActor ) return false;
|
||
m_pActor = dynamic_cast<CDnActor*>(this);
|
||
if( !m_pActor ) m_bIsValidActor = false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void MASkillUser::OnAddSkill( DnSkillHandle hSkill, bool isInitialize/* = false*/ )
|
||
{
|
||
// Æнúê ÀÌ¸é¼ ¹öÇÁ°í »óÅÂÈ¿°ú Self ·Î ºÙ¾îÀÖ´Â ½ºÅ³Àº °ð¹Ù·Î Àû¿ë½ÃÄÑ ÁÜ..
|
||
if( !IsValidActor() ) return;
|
||
bool bPassiveBuff = false;
|
||
|
||
bPassiveBuff = ApplyPassiveSkill( hSkill, isInitialize );
|
||
#ifdef _GAMESERVER
|
||
if( CDnSkill::AutoPassive == hSkill->GetSkillType() )
|
||
m_listAutoPassiveSkills.push_back( hSkill );
|
||
#else
|
||
const set<string>& setUseAction = hSkill->GetUseActionSet();
|
||
set<string>::const_iterator iter = setUseAction.begin();
|
||
for( iter; iter != setUseAction.end(); ++iter )
|
||
m_setUseActionNames.insert( *iter );
|
||
#endif
|
||
|
||
if( bPassiveBuff )
|
||
m_vlhSelfPassiveBlowSkill.push_back( hSkill );
|
||
}
|
||
|
||
bool MASkillUser::AddSkill( int nSkillTableID, int nLevel/* = 1*/, int iSkillLevelApplyType/* = CDnSkill::PVE*/ )
|
||
{
|
||
if( IsExistSkill( nSkillTableID, nLevel ) )
|
||
return false;
|
||
|
||
if( !IsValidActor() )
|
||
return false;
|
||
|
||
#ifdef _GAMESERVER
|
||
if( m_pActor == NULL || m_pActor->GetRoom() == NULL )
|
||
return false;
|
||
#endif
|
||
|
||
//·¹º§¾÷ Á¤º¸°¡ ÀÖÀ¸¸é Ãß°¡ ÇÑ´Ù.
|
||
int nLevelUp = GetSkillLevelUpValue(nSkillTableID);
|
||
nLevel += nLevelUp;
|
||
|
||
DnSkillHandle hSkill = CDnSkill::CreateSkill( m_pActor->GetMySmartPtr(), nSkillTableID, nLevel );
|
||
|
||
//·¹º§¾÷À» ½Ãµµ Çߴµ¥ ½ºÅ³ »ý¼ºÀÌ ¾ÈµÆ´Ù¸é
|
||
if (nLevelUp != 0 && !hSkill)
|
||
{
|
||
OutputDebug("½ºÅ³ (%d) ·¹º§ (%d) »ý¼º ½ÇÆÐ.. ½ºÅ³ ·¹º§ Å×À̺í È®ÀÎ ¿ä¸Á!!!!!!\n", nSkillTableID, nLevel);
|
||
_ASSERT( hSkill && "½ºÅ³ ·¹º§¾÷ ½Ãµµ ½ÇÆÐ.. ·¹º§ Å×À̺í È®ÀÎ" );
|
||
|
||
//´Ù½Ã ¿ø·¡ ·¹º§·Î »ý¼º ½Ãµµ..
|
||
nLevel -= nLevelUp;
|
||
hSkill = CDnSkill::CreateSkill(m_pActor->GetMySmartPtr(), nSkillTableID, nLevel);
|
||
|
||
nLevelUp = 0;
|
||
}
|
||
|
||
if( !hSkill )
|
||
return false;
|
||
|
||
//Ãß°¡µÈ ·¹º§¾÷ Á¤º¸¸¦ ¼³Á¤ ÇÑ´Ù.
|
||
hSkill->SetLevelUpValue(nLevelUp);
|
||
|
||
// ½ºÅ³·¹º§ Å×À̺í Àû¿ëŸÀÔ ¼ÂÆÃ
|
||
if( m_pActor->IsPlayerActor() )
|
||
hSkill->SelectLevelDataType( iSkillLevelApplyType );
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
m_vlhSkillList.push_back( hSkill );
|
||
m_vbSelfAllocList.push_back( true );
|
||
#else
|
||
m_vlSkillObjects.push_back( S_SKILL_OBJECT(hSkill, true) );
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
// Åä±Û, ¿À¶ó ½ºÅ³Àº µû·Î ¸®½ºÆ®¿¡ ´ã¾ÆµÒ
|
||
CDnSkill::DurationTypeEnum eDurationType = hSkill->GetDurationType();
|
||
switch(eDurationType)
|
||
{
|
||
case CDnSkill::ActiveToggle:
|
||
case CDnSkill::TimeToggle:
|
||
case CDnSkill::ActiveToggleForSummon:
|
||
m_vlhToggleSkills.push_back(hSkill);
|
||
case CDnSkill::Aura:
|
||
m_vlhAuraSkills.push_back(hSkill);
|
||
}
|
||
|
||
if( hSkill->GetActor() )
|
||
hSkill->SetHasActor( m_pActor->GetMySmartPtr() );
|
||
|
||
OnAddSkill( hSkill );
|
||
return true;
|
||
}
|
||
|
||
#if defined(PRE_FIX_62052)
|
||
void MASkillUser::ApplyGlobalSkillCoolTime(DnSkillHandle hSkill)
|
||
{
|
||
int nGlobalSkillGroupID = hSkill ? hSkill->GetGlobalSkillGroupID() : 0;
|
||
//GlobalSkillGroupID°¡ ¼³Á¤µÈ ½ºÅ³ÀÌ Ãß°¡ µÉ¶§ ±âÁ¸¿¡ °°Àº ID¸¦ »ç¿ëÇÏ´À ½ºÅ³ÀÇ ÄðŸÀÓÀ» Ãß°¡ µÇ´Â ½ºÅ³¿¡µµ ¼³Á¤ ÇØÁØ´Ù.
|
||
|
||
if (nGlobalSkillGroupID != 0)
|
||
{
|
||
for( DWORD i = 0; i < GetSkillCount(); ++i )
|
||
{
|
||
// m_vlGroupedSkillIDs ÀÇ °ªµéÀº Å×ÀÌºí¿¡¼ ±×³É ²ôÁý¾î ³½ °ÍÀ̱⠶§¹®¿¡
|
||
// ½ÇÁ¦ ½ºÅ³À» ½ÀµæÇß´ÂÁö ¿©ºÎ°¡ È®ÀεǾî¾ß ÇÑ´Ù.
|
||
DnSkillHandle hExistSkill = GetSkillFromIndex( i );
|
||
float fElapsedDelayTime = hExistSkill->GetElapsedDelayTime();
|
||
|
||
if( hExistSkill &&
|
||
hExistSkill->GetGlobalSkillGroupID() == nGlobalSkillGroupID &&
|
||
fElapsedDelayTime > 0.0f)
|
||
{
|
||
DnSkillHandle hOrigSkill = FindSkill(hExistSkill->GetAnotherGlobalSkillID());
|
||
|
||
hSkill->OnAnotherGlobalSkillBeginCoolTime( hOrigSkill );
|
||
hSkill->SetElapsedDelayTime(fElapsedDelayTime);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif // PRE_FIX_62052
|
||
|
||
bool MASkillUser::AddSkill( DnSkillHandle hSkill )
|
||
{
|
||
#ifdef _GAMESERVER
|
||
// °×¼¹ö¿¡¼´Â ¸ó½ºÅÍ¿¡¼¸¸ ½ºÅ³ °´Ã¼·Î Á÷Á¢ addskill ÇÕ´Ï´Ù.
|
||
// Ç÷¹ÀÌ¾î ¾×ÅÍ¿¡°Ô´Â ½ºÅ³ Æ®¸® °ü¸®°¡ Áß°£¿¡ µé¾î°¡±â ¶§¹®¿¡ ¼¹ö¿¡¼ °¡»óÇÔ¼ö·Î
|
||
// playeractor °¡ ¿À¹ö¶óÀ̵åÇÏ¿© »ç¿ëÇÏÁö ¾Ê´Â ÀÌ ÇÔ¼ö »ç¿ëÇÏ¸é ¾ÈµË´Ï´Ù.
|
||
// ÃßÈÄ¿¡ »ç¿ëÇÏ°Ô µÈ´Ù¸é ±â¾ïÇϱâ À§Çؼ assert °É¾î³õ½À´Ï´Ù.
|
||
//_ASSERT( IsValidActor() );
|
||
//_ASSERT( m_pActor->IsMonsterActor() );
|
||
#endif
|
||
|
||
if( IsExistSkill( hSkill->GetClassID(), hSkill->GetLevel() ) ) return false;
|
||
|
||
#if defined(PRE_FIX_62052)
|
||
ApplyGlobalSkillCoolTime(hSkill);
|
||
#endif // PRE_FIX_62052
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
m_vlhSkillList.push_back( hSkill );
|
||
m_vbSelfAllocList.push_back( false );
|
||
#else
|
||
m_vlSkillObjects.push_back( S_SKILL_OBJECT(hSkill, false) );
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
// Åä±Û, ¿À¶ó ½ºÅ³Àº µû·Î ¸®½ºÆ®¿¡ ´ã¾ÆµÒ
|
||
CDnSkill::DurationTypeEnum eDurationType = hSkill->GetDurationType();
|
||
switch(eDurationType)
|
||
{
|
||
case CDnSkill::ActiveToggle:
|
||
case CDnSkill::TimeToggle:
|
||
case CDnSkill::ActiveToggleForSummon:
|
||
m_vlhToggleSkills.push_back(hSkill);
|
||
case CDnSkill::Aura:
|
||
m_vlhAuraSkills.push_back(hSkill);
|
||
}
|
||
|
||
OnAddSkill( hSkill );
|
||
|
||
return true;
|
||
}
|
||
|
||
bool MASkillUser::bIsPassiveSkill( DnBlowHandle hBlow )
|
||
{
|
||
int iNumSkill = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at( iSkill );
|
||
_ASSERT( CDnSkill::Passive == hSkill->GetSkillType() );
|
||
const CDnSkill::SkillInfo* pSkillInfo = hBlow->GetParentSkillInfo();
|
||
if( pSkillInfo && (pSkillInfo->iSkillID == hSkill->GetClassID()) )
|
||
return true;
|
||
|
||
//if( CDnSkill::Passive == hSkill->GetSkillType() )
|
||
//{
|
||
// int iNumStateEffect = hSkill->GetStateEffectCount();
|
||
// for( int i = 0; i < iNumStateEffect; ++i )
|
||
// {
|
||
// CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( i );
|
||
// if( CDnSkill::StateEffectApplyType::ApplySelf == pSE->ApplyType )
|
||
// {
|
||
// if( CDnSkill::DurationTypeEnum::Buff == hSkill->GetDurationType() )
|
||
// {
|
||
// if( hBlow->GetBlowIndex() == pSE->nID )
|
||
// return true;
|
||
// }
|
||
// }
|
||
// }
|
||
//}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool MASkillUser::ApplyPassiveSkill( DnSkillHandle hSkill, bool isInitialize/* = false*/ )
|
||
{
|
||
bool bPassiveBuf = false;
|
||
|
||
// #24143 ÀÚ±âÀÚ½ÅÀÇ ½ºÅ³µéÀ» ÃʱâÈÇÒ¶© CDnSkillTask ÂÊ¿¡¼ ½ÇÁ¦ ȹµæÇÑ ½ºÅ³¸®½ºÆ®¸¦ ±âÁØÀ¸·Î AddSkill() ÇÔ¼ö¸¦
|
||
// È£ÃâÇØÁֱ⠶§¹®¿¡ ¹®Á¦ ¾øÁö¸¸ ´Ù¸¥ Ç÷¹À̾îÀÇ °æ¿ì¿£ ±×³É ¼¹ö¿¡¼ ¹Ð¾îÁÖ´Â ½ºÅ³¸®½ºÆ®(¸®¼ÂµÈ ·¹º§ 0Â¥¸® ½ºÅ³ Æ÷ÇÔ)
|
||
// ±×´ë·Î AddSkill() ÇÔ¼ö¸¦ È£ÃâÇØÁֱ⠶§¹®¿¡ ¸®¼ÂµÈ ÆÐ½Ãºê ½ºÅ³µµ Àû¿ë½ÃÄÑÁà¹ö¸®´Â ¹®Á¦°¡ ÀÖ´Ù.
|
||
// µû¶ó¼ ¿©±â¼ ȹµæ »óÅ°¡ ¾Æ´Ï¸é ÆÐ½Ãºê ¹öÇÁ ½ºÅ³À» ¹ßµ¿½ÃÄÑÁÖÁö ¾Êµµ·Ï ÇÑ´Ù. (hp/mp ÃÖ´ëÄ¡ Áõ°¡ ½ºÅ³µîµî..)
|
||
// °ÔÀÓ¼¹öÂÊ¿¡¼´Â Ŭ¶óÀ̾ðÆ®¿Í ´Ù¸£°Ô °¢ CDnPlayerActor °´Ã¼µéÀÌ ½ÇÁ¦ º¸À¯ÇÑ ½ºÅ³¸¸ °®°í ÀÖ´Ù.
|
||
// Ŭ¶óÀ̾ðÆ®ÂÊ¿¡¼´Â LocalPlayerActor ÀÎ °æ¿ì¿¡ ¸®¼ÂµÈ ½ºÅ³ÀÇ Á¤º¸µµ ÇÊ¿äÇϹǷΠPlayerActor ¸¦ µû·Î ±¸ºÐ ¾ÈÇÏ°í ½ºÅ³¸®½ºÆ® ¸ðµÎ ³Ö¾îÁØ´Ù..
|
||
#ifndef _GAMESERVER
|
||
if( false == hSkill->IsAcquired() )
|
||
return false;
|
||
#endif // #ifndef _GAMESERVER
|
||
|
||
if( CDnSkill::Passive == hSkill->GetSkillType() )
|
||
{
|
||
|
||
#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
|
||
bool isTotalLevelSkill = false;
|
||
if (m_pActor && m_pActor->IsPlayerActor())
|
||
{
|
||
CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(m_pActor);
|
||
CDnTotalLevelSkillSystem* pTotalLevelSystem = pPlayerActor ? pPlayerActor->GetTotalLevelSkillSystem() : NULL;
|
||
|
||
if (pTotalLevelSystem)
|
||
isTotalLevelSkill = pTotalLevelSystem->IsTotalLevelSkill(hSkill->GetClassID());
|
||
}
|
||
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
|
||
|
||
int iNumStateEffect = hSkill->GetStateEffectCount();
|
||
for( int i = 0; i < iNumStateEffect; ++i )
|
||
{
|
||
CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( i );
|
||
if( CDnSkill::StateEffectApplyType::ApplySelf == pSE->ApplyType )
|
||
{
|
||
if( CDnSkill::DurationTypeEnum::Buff == hSkill->GetDurationType() )
|
||
{
|
||
bPassiveBuf = true;
|
||
if( hSkill->IsSatisfyWeapon() )
|
||
{
|
||
int iBlowID = -1;
|
||
DnBlowHandle hBlow;
|
||
|
||
#ifdef _GAMESERVER
|
||
if(m_pActor)
|
||
{
|
||
iBlowID = m_pActor->CDnActor::CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pSE->nID, -1, pSE->szValue.c_str(), true ); // Duration TimeÀÌ -1 ÀÌ¸é ¹«ÇÑ Àû¿ëÀÓ
|
||
OnApplyPassiveSkillBlow( iBlowID );
|
||
|
||
hBlow = m_pActor->GetStateBlowFromID(iBlowID);
|
||
}
|
||
#else
|
||
if(m_pActor)
|
||
hBlow = m_pActor->CDnActor::CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pSE->nID, -1, pSE->szValue.c_str(), true ); // Duration TimeÀÌ -1 ÀÌ¸é ¹«ÇÑ Àû¿ëÀÓ
|
||
#endif
|
||
|
||
#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
|
||
if (isTotalLevelSkill == true && isInitialize == true && hBlow)
|
||
hBlow->FromSourceItem();
|
||
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
|
||
|
||
hSkill->SetAppliedPassiveBlows( true );
|
||
|
||
#ifndef _FINAL_BUILD
|
||
char szTemp[256] = { 0, };
|
||
WideCharToMultiByte( CP_ACP, 0, hSkill->GetName(), -1, szTemp, _countof(szTemp), NULL, NULL );
|
||
OutputDebug( "[ÆÐ½Ãºê ¹öÇÁ ½ºÅ³ Àû¿ëµÊ: %d] \"%s\" »óÅÂÈ¿°úIndex: %d, Value:%s\n", hSkill->GetClassID(), szTemp, pSE->nID, pSE->szValue.c_str() );
|
||
#endif // #ifndef _FINAL_BUILD
|
||
}
|
||
#ifndef _FINAL_BUILD
|
||
else
|
||
{
|
||
char szTemp[256] = { 0, };
|
||
WideCharToMultiByte( CP_ACP, 0, hSkill->GetName(), -1, szTemp, _countof(szTemp), NULL, NULL );
|
||
OutputDebug( "[ÆÐ½Ãºê ¹öÇÁ ½ºÅ³ Àû¿ë¾ÈµÊ: %d] \"%s\" ½ºÅ³¿¡ ÁöÁ¤µÈ ÇÊ¿ä ¹«±â ŸÀÔÀÌ ¸ÂÁö ¾Ê½À´Ï´Ù.\n", hSkill->GetClassID(), szTemp );
|
||
}
|
||
#endif // #ifndef _FINAL_BUILD
|
||
}
|
||
#ifndef _FINAL_BUILD
|
||
else
|
||
{
|
||
char szTemp[256] = { 0, };
|
||
WideCharToMultiByte( CP_ACP, 0, hSkill->GetName(), -1, szTemp, _countof(szTemp), NULL, NULL );
|
||
OutputDebug( "[½ºÅ³ µ¥ÀÌÅÍ È®ÀÎ ¿ä¸Á: %d] \"%s\" ÆÐ½Ãºê ¹öÇÁ ½ºÅ³·Î »ý°¢µÇ³ª Buff ·Î ¼³Á¤µÇ¾îÀÖÁö ¾Ê¾Æ¼ Àû¿ë ¾ÈµÊ\n", hSkill->GetClassID(), szTemp );
|
||
}
|
||
#endif // #ifndef _FINAL_BUILD
|
||
}
|
||
}
|
||
}
|
||
|
||
return bPassiveBuf;
|
||
}
|
||
|
||
void MASkillUser::ApplyPassiveSkills( void )
|
||
{
|
||
if( !IsValidActor() ) return;
|
||
|
||
int iNumSkill = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at( iSkill );
|
||
ApplyPassiveSkill(hSkill);
|
||
}
|
||
}
|
||
|
||
void MASkillUser::OnRemoveSkill( DnSkillHandle hSkill )
|
||
{
|
||
#ifndef _GAMESERVER
|
||
const set<string>& setUseAction = hSkill->GetUseActionSet();
|
||
set<string>::const_iterator iter = setUseAction.begin();
|
||
for( iter; iter != setUseAction.end(); ++iter )
|
||
m_setUseActionNames.erase( *iter );
|
||
#endif
|
||
}
|
||
|
||
bool MASkillUser::RemoveSkillAll()
|
||
{
|
||
if( !IsValidActor() )
|
||
return false;
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int nSkillSize = (int)m_vlhSkillList.size();
|
||
|
||
for( int i=0 ; i<nSkillSize ; i++ )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.back();
|
||
if( !hSkill )
|
||
continue;
|
||
|
||
bool bRet = RemoveSkill( hSkill->GetClassID() );
|
||
_ASSERT( bRet );
|
||
}
|
||
#else
|
||
|
||
int nSkillSize = (int)m_vlSkillObjects.size();
|
||
|
||
for( int i=0 ; i<nSkillSize ; i++ )
|
||
{
|
||
S_SKILL_OBJECT& SkillObject = m_vlSkillObjects.back();
|
||
DnSkillHandle hSkill = SkillObject.hSkill;
|
||
if( !hSkill )
|
||
continue;
|
||
|
||
bool bRet = RemoveSkill( hSkill->GetClassID() );
|
||
_ASSERT( bRet );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
return true;
|
||
}
|
||
|
||
bool MASkillUser::EndStateEffectSkill(int nSkillTableID)
|
||
{
|
||
DNVector(DnBlowHandle) vlBlows;
|
||
m_pActor->GetAllAppliedStateBlow(vlBlows);
|
||
|
||
for (int i = 0; i < (int)vlBlows.size(); ++i)
|
||
{
|
||
DnBlowHandle hBlow = vlBlows.at(i);
|
||
const CDnSkill::SkillInfo * skillInfo = hBlow->GetParentSkillInfo();
|
||
if (skillInfo->iSkillID == nSkillTableID)
|
||
{
|
||
hBlow->OnEnd(0, 0);
|
||
m_pActor->OnEndStateBlow(hBlow);
|
||
m_pActor->RemoveStateBlowFromID(hBlow->GetBlowID()); //? need test.
|
||
}
|
||
}
|
||
/*
|
||
DnSkillHandle hSkill = FindSkill(nSkillTableID);
|
||
if (m_pActor && m_pActor->GetStateBlow())
|
||
{
|
||
std::vector<int> vecRemoveBlowID;
|
||
DNVector(DnBlowHandle) vlBlows;
|
||
m_pActor->GetAllAppliedStateBlowBySkillID(nSkillTableID, vlBlows);
|
||
|
||
int iStateEffectCount = hSkill->GetStateEffectCount();
|
||
for (int iStateEffect = 0; iStateEffect < iStateEffectCount; ++iStateEffect)
|
||
{
|
||
const CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex(iStateEffect);
|
||
if (pSE && CDnSkill::StateEffectApplyType::ApplySelf == pSE->ApplyType)
|
||
{
|
||
for (DWORD BLOW_COUNT = 0; BLOW_COUNT < vlBlows.size(); BLOW_COUNT++)
|
||
{
|
||
if (vlBlows[BLOW_COUNT] && (vlBlows[BLOW_COUNT]->GetBlowIndex() == (STATE_BLOW::emBLOW_INDEX)pSE->nID))
|
||
{
|
||
vecRemoveBlowID.push_back(vlBlows[BLOW_COUNT]->GetBlowID());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for (DWORD Index = 0; Index < vecRemoveBlowID.size(); Index++)
|
||
{
|
||
m_pActor->GetStateBlow()->RemoveImediatlyStateEffectFromID(vecRemoveBlowID[Index]);
|
||
}
|
||
}
|
||
*/
|
||
return true;
|
||
}
|
||
|
||
bool MASkillUser::RemoveSkill( int nSkillTableID )
|
||
{
|
||
if( !IsValidActor() ) return false;
|
||
|
||
int iNumPassiveBlowSkill = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for( int iPassiveBlowSkill = 0; iPassiveBlowSkill < iNumPassiveBlowSkill; ++iPassiveBlowSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at( iPassiveBlowSkill );
|
||
if( hSkill && hSkill->GetClassID() == nSkillTableID )
|
||
{
|
||
if( m_pActor && m_pActor->GetStateBlow() )
|
||
{
|
||
std::vector<int> vecRemoveBlowID;
|
||
DNVector(DnBlowHandle) vlBlows;
|
||
m_pActor->GetAllAppliedStateBlowBySkillID( nSkillTableID , vlBlows );
|
||
|
||
int iStateEffectCount = hSkill->GetStateEffectCount();
|
||
for( int iStateEffect = 0; iStateEffect < iStateEffectCount; ++iStateEffect )
|
||
{
|
||
const CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( iStateEffect );
|
||
if( pSE && CDnSkill::StateEffectApplyType::ApplySelf == pSE->ApplyType )
|
||
{
|
||
for( DWORD BLOW_COUNT=0; BLOW_COUNT < vlBlows.size(); BLOW_COUNT++ )
|
||
{
|
||
if( vlBlows[BLOW_COUNT] && ( vlBlows[BLOW_COUNT]->GetBlowIndex() == (STATE_BLOW::emBLOW_INDEX)pSE->nID ) )
|
||
{
|
||
vecRemoveBlowID.push_back( vlBlows[BLOW_COUNT]->GetBlowID() );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for( DWORD Index=0; Index<vecRemoveBlowID.size(); Index++)
|
||
{
|
||
m_pActor->GetStateBlow()->RemoveImediatlyStateEffectFromID( vecRemoveBlowID[Index] );
|
||
}
|
||
}
|
||
|
||
// 2009.03.16 ±è¹ä
|
||
m_vlhSelfPassiveBlowSkill.erase( m_vlhSelfPassiveBlowSkill.begin()+iPassiveBlowSkill );
|
||
break;
|
||
}
|
||
}
|
||
|
||
#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
|
||
//ÅëÇÕ·¹º§ ½ºÅ³ÀÎ °æ¿ì ¾Æ·§ÂÊ ·çƾÀ» Å» ÇÊ¿ä°¡ ¾øÀ½...
|
||
if (m_pActor && m_pActor->IsPlayerActor())
|
||
{
|
||
CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(m_pActor);
|
||
CDnTotalLevelSkillSystem *pTotalLevelSystem = pPlayerActor ? pPlayerActor->GetTotalLevelSkillSystem(): NULL;
|
||
|
||
if (pTotalLevelSystem && pTotalLevelSystem->IsTotalLevelSkill(nSkillTableID))
|
||
return true;
|
||
}
|
||
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
|
||
|
||
#ifdef _GAMESERVER
|
||
list<DnSkillHandle>::iterator iter = m_listAutoPassiveSkills.begin();
|
||
for( iter; m_listAutoPassiveSkills.end() != iter; ++iter )
|
||
{
|
||
if( (*iter)->GetClassID() == nSkillTableID )
|
||
{
|
||
m_listAutoPassiveSkills.erase( iter );
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ ) {
|
||
if( m_vlhSkillList[i]->GetClassID() == nSkillTableID ) {
|
||
|
||
// Åä±ÛÀ̳ª ¿À¶ó ½ºÅ³À̶ó¸é º°µµÀÇ ¸®½ºÆ®¿¡¼ »èÁ¦
|
||
DnSkillHandle hSkill = m_vlhSkillList.at(i);
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
S_SKILL_OBJECT& SkillObject = m_vlSkillObjects.at( i );
|
||
if( SkillObject.hSkill && SkillObject.hSkill->GetClassID() == nSkillTableID )
|
||
{
|
||
// Åä±ÛÀ̳ª ¿À¶ó ½ºÅ³À̶ó¸é º°µµÀÇ ¸®½ºÆ®¿¡¼ »èÁ¦
|
||
DnSkillHandle hSkill = SkillObject.hSkill;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
if( CDnSkill::ActiveToggle == hSkill->GetDurationType() ||
|
||
CDnSkill::TimeToggle == hSkill->GetDurationType() ||
|
||
CDnSkill::ActiveToggleForSummon == hSkill->GetDurationType()
|
||
)
|
||
{
|
||
DNVector(DnSkillHandle)::iterator Localiter = find( m_vlhToggleSkills.begin(), m_vlhToggleSkills.end(), hSkill );
|
||
m_vlhToggleSkills.erase( Localiter );
|
||
}
|
||
else
|
||
if( CDnSkill::Aura == hSkill->GetDurationType() )
|
||
{
|
||
if (m_hAuraSkill && m_hAuraSkill->GetClassID() == nSkillTableID && m_hAuraSkill->IsAuraOn())
|
||
{
|
||
if (m_hAuraSkill == m_hProcessSkill)
|
||
m_hProcessSkill.Identity();
|
||
|
||
m_hAuraSkill->EnableAura( false );
|
||
OnSkillAura(m_hAuraSkill, false);
|
||
m_hAuraSkill.Identity();
|
||
}
|
||
|
||
DNVector(DnSkillHandle)::iterator Localiter = find( m_vlhAuraSkills.begin(), m_vlhAuraSkills.end(), hSkill );
|
||
m_vlhAuraSkills.erase( Localiter );
|
||
}
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
OnRemoveSkill( m_vlhSkillList[i] );
|
||
if( m_vbSelfAllocList[i] == true ) SAFE_RELEASE_SPTR( m_vlhSkillList[i] );
|
||
|
||
m_vlhSkillList.erase( m_vlhSkillList.begin() + i );
|
||
m_vbSelfAllocList.erase( m_vbSelfAllocList.begin() + i );
|
||
#else
|
||
OnRemoveSkill( SkillObject.hSkill );
|
||
if( SkillObject.bSelfAlloc )
|
||
SAFE_RELEASE_SPTR( SkillObject.hSkill );
|
||
m_vlSkillObjects.erase( m_vlSkillObjects.begin()+i );
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
return true;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#ifndef _GAMESERVER
|
||
bool MASkillUser::ReplacementSkill( int nSkillTableID, int nLevel )
|
||
{
|
||
if( !IsValidActor() ) return false;
|
||
|
||
DnSkillHandle hSkill = CDnSkill::CreateSkill( m_pActor->GetMySmartPtr(), nSkillTableID, nLevel );
|
||
if( !hSkill ) return false;
|
||
|
||
return ReplacementSkill( hSkill );
|
||
}
|
||
|
||
|
||
bool MASkillUser::ReplacementSkill( DnSkillHandle hNewSkill )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iSkillID = hNewSkill->GetClassID();
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ )
|
||
{
|
||
if( m_vlhSkillList[ i ]->GetClassID() == iSkillID )
|
||
{
|
||
// ÆÐ½Ãºê ºí·Î¿ì ½ºÅ³Àΰ¡. ±×·¸´Ù¸é ±âÁ¸ »óÅÂÈ¿°ú ¸ðµÎ ¾ø¾Ö°í »õ·Î Àû¿ë½ÃÄÑ ÁØ´Ù.
|
||
DNVector(DnSkillHandle)::iterator iter = find( m_vlhSelfPassiveBlowSkill.begin(), m_vlhSelfPassiveBlowSkill.end(), m_vlhSkillList[ i ] );
|
||
if( m_vlhSelfPassiveBlowSkill.end() != iter )
|
||
{
|
||
// Àû¿ëµÇ¾î ÀÖ´Â »óÅÂÈ¿°ú¸¦ Á¦°ÅÇÑ´Ù.
|
||
// ºÎ¸ð½ºÅ³ÀÌ ÀÏÄ¡ÇÏ´Â »óÅÂÈ¿°ú¸¦ ã¾Æ³»¼ »èÁ¦ÇÑ´Ù.
|
||
if( !IsValidActor() ) continue;
|
||
|
||
// HP, SP ¿Ã·ÁÁÖ´Â ÆÐ½Ãºê ½ºÅ³Àº »èÁ¦µÇ¸é ¿ø·¡ ½ºÅ³ ¾ø´Â »óÅÂÀÇ ¼ø¼ö HP SP ·Î ÇöÀç HP/SP°¡
|
||
// Ŭ¸®ÇÎ µÇ°Ô ¶§¹®¿¡ ¹Ì¸® ¹Þ¾Æµ×´Ù°¡ ¼ÂÆÃÇØÁØ´Ù..
|
||
INT64 iHP = m_pActor->GetHP();
|
||
int iSP = m_pActor->GetSP();
|
||
|
||
DNVector(DnBlowHandle) vlhAppliedSE;
|
||
DNVector(DnBlowHandle) vlhSEToRemove;
|
||
m_pActor->GetAllAppliedStateBlow( vlhAppliedSE );
|
||
int iNumAppliedSE = (int)vlhAppliedSE.size();
|
||
for( int iSE = 0; iSE < iNumAppliedSE; ++iSE )
|
||
{
|
||
DnBlowHandle hAppliedBlow = vlhAppliedSE.at( iSE );
|
||
const CDnSkill::SkillInfo* pSkillInfo = hAppliedBlow->GetParentSkillInfo();
|
||
if( pSkillInfo->iSkillID == (*iter)->GetClassID() )
|
||
vlhSEToRemove.push_back( hAppliedBlow );
|
||
}
|
||
|
||
int iNumSEToRemove = (int)vlhSEToRemove.size();
|
||
for( int iSE = 0; iSE < iNumSEToRemove; ++iSE )
|
||
{
|
||
DnBlowHandle hBlow = vlhSEToRemove.at(iSE);
|
||
int iID = hBlow->GetBlowID();
|
||
OutputDebug( "[ÆÐ½Ãºê ¹öÇÁ ½ºÅ³ »èÁ¦µÊ: %d] %s »óÅÂÈ¿°úIndex: %d, Value:%s\n",
|
||
(*iter)->GetClassID(), (*iter)->GetName(), hBlow->GetBlowIndex(), hBlow->GetValue() );
|
||
m_pActor->RemoveStateBlowFromID( iID );
|
||
}
|
||
|
||
m_vlhSelfPassiveBlowSkill.erase( iter );
|
||
|
||
ApplyPassiveSkill( hNewSkill );
|
||
m_vlhSelfPassiveBlowSkill.push_back( hNewSkill );
|
||
|
||
m_pActor->SetHP( iHP );
|
||
m_pActor->SetSP( iSP );
|
||
}
|
||
|
||
if (m_hAuraSkill && m_hAuraSkill->GetClassID() == iSkillID && m_hAuraSkill->IsAuraOn())
|
||
{
|
||
if (m_hAuraSkill == m_hProcessSkill)
|
||
m_hProcessSkill.Identity();
|
||
|
||
m_hAuraSkill->EnableAura( false );
|
||
OnSkillAura(m_hAuraSkill, false);
|
||
m_hAuraSkill.Identity();
|
||
}
|
||
|
||
if( m_vbSelfAllocList[ i ] )
|
||
{
|
||
// ÀÚ½ÅÀÌ »ý¼ºÇÑ ½ºÅ³Àº ÀÚ½ÅÀÌ Áö¿ö¾ß ÇϹǷÎ.
|
||
DnSkillHandle hSkillToRelease = m_vlhSkillList[ i ];
|
||
|
||
// ¿À¶ó, Åä±Û ½ºÅ³ ¸®½ºÆ®¿¡¼µµ °Ë»öÇؼ ´ëü ½ÃÅ´
|
||
DNVector(DnSkillHandle)::iterator iterToggle = find( m_vlhToggleSkills.begin(), m_vlhToggleSkills.end(), hSkillToRelease );
|
||
if( m_vlhToggleSkills.end() != iterToggle )
|
||
*iterToggle = hNewSkill;
|
||
|
||
DNVector(DnSkillHandle)::iterator iterAura = find( m_vlhAuraSkills.begin(), m_vlhAuraSkills.end(), hSkillToRelease );
|
||
if( m_vlhAuraSkills.end() != iterAura )
|
||
*iterAura = hNewSkill;
|
||
|
||
OnRemoveSkill( hSkillToRelease );
|
||
SAFE_RELEASE_SPTR( hSkillToRelease );
|
||
|
||
}
|
||
else
|
||
{
|
||
// ½ºÅ³ ŽºÅ©¿¡¼ »ý¼ºÇÑ ½ºÅ³ °´Ã¼´Â ¿©±â¼ Áö¿ìÁö ¾Ê´Â´Ù.
|
||
DnSkillHandle hPrevLevelSkill = m_vlhSkillList[ i ];
|
||
|
||
// ¿À¶ó, Åä±Û ½ºÅ³ ¸®½ºÆ®¿¡¼µµ °Ë»öÇؼ ´ëü ½ÃÅ´
|
||
DNVector(DnSkillHandle)::iterator iterToggle = find( m_vlhToggleSkills.begin(), m_vlhToggleSkills.end(), hPrevLevelSkill );
|
||
if( m_vlhToggleSkills.end() != iterToggle )
|
||
*iterToggle = hNewSkill;
|
||
|
||
DNVector(DnSkillHandle)::iterator iterAura = find( m_vlhAuraSkills.begin(), m_vlhAuraSkills.end(), hPrevLevelSkill );
|
||
if( m_vlhAuraSkills.end() != iterAura )
|
||
*iterAura = hNewSkill;
|
||
}
|
||
|
||
OnReplacementSkill( m_vlhSkillList[ i ], hNewSkill );
|
||
m_vlhSkillList[ i ] = hNewSkill;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
#else
|
||
int iSkillID = hNewSkill->GetClassID();
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); i++ )
|
||
{
|
||
S_SKILL_OBJECT& SkillObject = m_vlSkillObjects.at( i );
|
||
DnSkillHandle hSkill = SkillObject.hSkill;
|
||
if( hSkill->GetClassID() == iSkillID )
|
||
{
|
||
// ÆÐ½Ãºê ºí·Î¿ì ½ºÅ³Àΰ¡. ±×·¸´Ù¸é ±âÁ¸ »óÅÂÈ¿°ú ¸ðµÎ ¾ø¾Ö°í »õ·Î Àû¿ë½ÃÄÑ ÁØ´Ù.
|
||
DNVector(DnSkillHandle)::iterator iter = find( m_vlhSelfPassiveBlowSkill.begin(), m_vlhSelfPassiveBlowSkill.end(), hSkill );
|
||
if( m_vlhSelfPassiveBlowSkill.end() != iter )
|
||
{
|
||
// Àû¿ëµÇ¾î ÀÖ´Â »óÅÂÈ¿°ú¸¦ Á¦°ÅÇÑ´Ù.
|
||
// ºÎ¸ð½ºÅ³ÀÌ ÀÏÄ¡ÇÏ´Â »óÅÂÈ¿°ú¸¦ ã¾Æ³»¼ »èÁ¦ÇÑ´Ù.
|
||
if( !IsValidActor() ) continue;
|
||
|
||
// HP, SP ¿Ã·ÁÁÖ´Â ÆÐ½Ãºê ½ºÅ³Àº »èÁ¦µÇ¸é ¿ø·¡ ½ºÅ³ ¾ø´Â »óÅÂÀÇ ¼ø¼ö HP SP ·Î ÇöÀç HP/SP°¡
|
||
// Ŭ¸®ÇÎ µÇ°Ô ¶§¹®¿¡ ¹Ì¸® ¹Þ¾Æµ×´Ù°¡ ¼ÂÆÃÇØÁØ´Ù..
|
||
INT64 iHP = m_pActor->GetHP();
|
||
int iSP = m_pActor->GetSP();
|
||
|
||
DNVector(DnBlowHandle) vlhAppliedSE;
|
||
DNVector(DnBlowHandle) vlhSEToRemove;
|
||
m_pActor->GetAllAppliedStateBlow( vlhAppliedSE );
|
||
int iNumAppliedSE = (int)vlhAppliedSE.size();
|
||
for( int iSE = 0; iSE < iNumAppliedSE; ++iSE )
|
||
{
|
||
DnBlowHandle hAppliedBlow = vlhAppliedSE.at( iSE );
|
||
const CDnSkill::SkillInfo* pSkillInfo = hAppliedBlow->GetParentSkillInfo();
|
||
if( pSkillInfo->iSkillID == (*iter)->GetClassID() )
|
||
vlhSEToRemove.push_back( hAppliedBlow );
|
||
}
|
||
|
||
int iNumSEToRemove = (int)vlhSEToRemove.size();
|
||
for( int iSE = 0; iSE < iNumSEToRemove; ++iSE )
|
||
{
|
||
DnBlowHandle hBlow = vlhSEToRemove.at(iSE);
|
||
int iID = hBlow->GetBlowID();
|
||
OutputDebug( "[ÆÐ½Ãºê ¹öÇÁ ½ºÅ³ »èÁ¦µÊ: %d] %s »óÅÂÈ¿°úIndex: %d, Value:%s\n",
|
||
(*iter)->GetClassID(), (*iter)->GetName(), hBlow->GetBlowIndex(), hBlow->GetValue() );
|
||
m_pActor->RemoveStateBlowFromID( iID );
|
||
}
|
||
|
||
m_vlhSelfPassiveBlowSkill.erase( iter );
|
||
|
||
ApplyPassiveSkill( hNewSkill );
|
||
m_vlhSelfPassiveBlowSkill.push_back( hNewSkill );
|
||
|
||
m_pActor->SetHP( iHP );
|
||
m_pActor->SetSP( iSP );
|
||
}
|
||
|
||
if (m_hAuraSkill && m_hAuraSkill->GetClassID() == iSkillID && m_hAuraSkill->IsAuraOn())
|
||
{
|
||
if (m_hAuraSkill == m_hProcessSkill)
|
||
m_hProcessSkill.Identity();
|
||
|
||
m_hAuraSkill->EnableAura( false );
|
||
OnSkillAura(m_hAuraSkill, false);
|
||
m_hAuraSkill.Identity();
|
||
}
|
||
|
||
if( true == SkillObject.bSelfAlloc )
|
||
{
|
||
// ÀÚ½ÅÀÌ »ý¼ºÇÑ ½ºÅ³Àº ÀÚ½ÅÀÌ Áö¿ö¾ß ÇϹǷÎ.
|
||
DnSkillHandle hSkillToRelease = hSkill;
|
||
|
||
// ¿À¶ó, Åä±Û ½ºÅ³ ¸®½ºÆ®¿¡¼µµ °Ë»öÇؼ ´ëü ½ÃÅ´
|
||
DNVector(DnSkillHandle)::iterator iterToggle = find( m_vlhToggleSkills.begin(), m_vlhToggleSkills.end(), hSkillToRelease );
|
||
if( m_vlhToggleSkills.end() != iterToggle )
|
||
*iterToggle = hNewSkill;
|
||
|
||
DNVector(DnSkillHandle)::iterator iterAura = find( m_vlhAuraSkills.begin(), m_vlhAuraSkills.end(), hSkillToRelease );
|
||
if( m_vlhAuraSkills.end() != iterAura )
|
||
*iterAura = hNewSkill;
|
||
|
||
OnRemoveSkill( hSkillToRelease );
|
||
SAFE_RELEASE_SPTR( hSkillToRelease );
|
||
|
||
}
|
||
else
|
||
{
|
||
// ½ºÅ³ ŽºÅ©¿¡¼ »ý¼ºÇÑ ½ºÅ³ °´Ã¼´Â ¿©±â¼ Áö¿ìÁö ¾Ê´Â´Ù.
|
||
DnSkillHandle hPrevLevelSkill = hSkill;
|
||
|
||
// ¿À¶ó, Åä±Û ½ºÅ³ ¸®½ºÆ®¿¡¼µµ °Ë»öÇؼ ´ëü ½ÃÅ´
|
||
DNVector(DnSkillHandle)::iterator iterToggle = find( m_vlhToggleSkills.begin(), m_vlhToggleSkills.end(), hPrevLevelSkill );
|
||
if( m_vlhToggleSkills.end() != iterToggle )
|
||
*iterToggle = hNewSkill;
|
||
|
||
DNVector(DnSkillHandle)::iterator iterAura = find( m_vlhAuraSkills.begin(), m_vlhAuraSkills.end(), hPrevLevelSkill );
|
||
if( m_vlhAuraSkills.end() != iterAura )
|
||
*iterAura = hNewSkill;
|
||
}
|
||
|
||
OnReplacementSkill( hSkill, hNewSkill );
|
||
SkillObject.hSkill = hNewSkill;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
#endif
|
||
|
||
bool MASkillUser::IsExistSkill( int nSkillTableID, int nLevel )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ ) {
|
||
if( m_vlhSkillList[i] && ( m_vlhSkillList[i]->GetClassID() == nSkillTableID ) )
|
||
{
|
||
if( nLevel == -1 ) return true;
|
||
if( m_vlhSkillList[i]->GetLevel() == nLevel ) return true;
|
||
}
|
||
}
|
||
return false;
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
S_SKILL_OBJECT& SkillObject = m_vlSkillObjects.at( i );
|
||
DnSkillHandle hSkill = SkillObject.hSkill;
|
||
if( hSkill)
|
||
{
|
||
if( hSkill->GetClassID() == nSkillTableID )
|
||
{
|
||
if( -1 == nLevel )
|
||
return true;
|
||
|
||
if( hSkill->GetLevel() == nLevel )
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
bool MASkillUser::IsSelfAllocSkill( int nSkillTableID )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ ) {
|
||
if( m_vlhSkillList[i]->GetClassID() == nSkillTableID )
|
||
return m_vbSelfAllocList[i];
|
||
}
|
||
return false;
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
if( m_vlSkillObjects.at( i ).hSkill->GetClassID() == nSkillTableID )
|
||
return m_vlSkillObjects.at( i ).bSelfAlloc;
|
||
}
|
||
return false;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
void MASkillUser::SetSkillLevel( int nSkillTableID, int nValue )
|
||
{
|
||
if( !IsSelfAllocSkill( nSkillTableID ) ) return;
|
||
|
||
DnSkillHandle hSkill = FindSkill( nSkillTableID );
|
||
if( !hSkill ) return;
|
||
if( hSkill->GetLevel() == nValue ) return;
|
||
|
||
float fElapsedDelayTime = hSkill->GetElapsedDelayTime();
|
||
RemoveSkill( nSkillTableID );
|
||
AddSkill( nSkillTableID, nValue );
|
||
hSkill = FindSkill( nSkillTableID );
|
||
hSkill->SetElapsedDelayTime( fElapsedDelayTime );
|
||
}
|
||
|
||
DnSkillHandle MASkillUser::FindSkill( int nSkillTableID )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i=0; i<m_vlhSkillList.size(); i++ )
|
||
{
|
||
if( m_vlhSkillList[i]->GetClassID() == nSkillTableID )
|
||
return m_vlhSkillList[i];
|
||
}
|
||
return CDnSkill::Identity();
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
if( m_vlSkillObjects.at( i ).hSkill &&
|
||
m_vlSkillObjects.at( i ).hSkill->GetClassID() == nSkillTableID )
|
||
return m_vlSkillObjects.at( i ).hSkill;
|
||
}
|
||
|
||
return CDnSkill::Identity();
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
DnSkillHandle MASkillUser::GetProcessSkill()
|
||
{
|
||
return m_hProcessSkill;
|
||
}
|
||
|
||
|
||
CDnSkill::UsingResult MASkillUser::CanExecuteSkill( DnSkillHandle hSkill )
|
||
{
|
||
_ASSERT( hSkill && "MASkillUser::CanExecuteSkill() -> Invalid hSkill" );
|
||
|
||
#ifndef _GAMESERVER
|
||
// °°Àº ÇÁ·¹ÀÓ¿¡ ¾×Ƽºê ½ºÅ³ ¿©·¯°³ »ç¿ë ºÒ°¡.
|
||
if( m_hProcessSkill &&
|
||
m_hProcessSkill->GetSkillType() == CDnSkill::Active &&
|
||
hSkill->GetSkillType() == CDnSkill::Active )
|
||
if( m_bSkillExecutedThisFrame )
|
||
return CDnSkill::UsingResult::Failed;
|
||
#endif
|
||
|
||
|
||
// [2011/02/22 semozz]
|
||
// ¾Ö´Ï¸ÞÀÌ¼Ç Àüȯ °¡´É üũ´Â Ŭ¶óÀ̾ðÆ®¸¸ ÇÏ¸é µÉµí...
|
||
#if !defined(_GAMESERVER)
|
||
if (!hSkill->CheckAnimation())
|
||
return CDnSkill::UsingResult::Failed;
|
||
#endif // _GAMESERVER
|
||
|
||
#if !defined(_GAMESERVER)
|
||
if( hSkill->GetGlyphActiveSkillDisable() )
|
||
return CDnSkill::UsingResult::Failed;
|
||
#endif // _GAMESERVER
|
||
|
||
return hSkill->CanExecute();
|
||
}
|
||
|
||
|
||
#ifdef _GAMESERVER
|
||
bool MASkillUser::ExecuteSkill( DnSkillHandle hSkill, LOCAL_TIME LocalTime, float fDelta )
|
||
#else
|
||
bool MASkillUser::ExecuteSkill( DnSkillHandle hSkill, LOCAL_TIME LocalTime, float fDelta,
|
||
bool bCheckValid /*= true*/, bool bAutoUsedFromServer /*= false*/, bool bSendPacketToServer /*= true */ )
|
||
#endif
|
||
{
|
||
_ASSERT( hSkill && "Invalid hSkill" );
|
||
|
||
if( !IsValidActor() ) return false;
|
||
|
||
if( m_hProcessSkill )
|
||
{
|
||
// #25154 ¿À¶ó ½ºÅ³Àº ¿À¶ó¸¦ ²°À» ¶§ onend µÈ´Ù.
|
||
if( false == m_hProcessSkill->IsAuraOn() )
|
||
m_hProcessSkill->OnEnd( m_LocalTime, 0 );
|
||
|
||
m_hProcessSkill.Identity();
|
||
}
|
||
|
||
m_hProcessSkill = hSkill;
|
||
|
||
switch( m_hProcessSkill->GetDurationType() ) {
|
||
case CDnSkill::Instantly:
|
||
case CDnSkill::Buff:
|
||
case CDnSkill::Debuff:
|
||
case CDnSkill::SummonOnOff:
|
||
case CDnSkill::StanceChange:
|
||
// ¸¶À»¿¡¼´Â SP ¾È ±ïÀ̵µ·Ï
|
||
#ifndef _GAMESERVER
|
||
if( CDnWorld::MapTypeVillage != CDnWorld::GetInstance().GetMapType() )
|
||
#endif
|
||
m_pActor->UseMP( -m_hProcessSkill->GetDecreaseMP() ); // Compile Error. Moved by kalliste
|
||
//m_pActor->SetSP( m_pActor->GetSP() - m_hProcessSkill->GetDecreaseMP() );
|
||
|
||
// Excute ÇÔ¼ö´Â OnBegin À¸·Î À̸§ÀÌ ¹Ù²î¾ú´Ù.
|
||
//m_hProcessSkill->Execute( LocalTime, fDelta );
|
||
m_hProcessSkill->OnBegin( LocalTime, fDelta );
|
||
|
||
// ±Û·Î¹ú ÄðŸÀÓÀÌ ¼³Á¤µÇ¾îÀÖ´Ù¸é °°Àº ±×·ìÀÇ ½ºÅ³µéµµ ÄðŸÀÓ ½ÃÀÛ..
|
||
if( m_hProcessSkill && 0 < m_hProcessSkill->GetGlobalSkillGroupID() )
|
||
{
|
||
for( DWORD i = 0; i < GetSkillCount(); ++i )
|
||
{
|
||
// m_vlGroupedSkillIDs ÀÇ °ªµéÀº Å×ÀÌºí¿¡¼ ±×³É ²ôÁý¾î ³½ °ÍÀ̱⠶§¹®¿¡
|
||
// ½ÇÁ¦ ½ºÅ³À» ½ÀµæÇß´ÂÁö ¿©ºÎ°¡ È®ÀεǾî¾ß ÇÑ´Ù.
|
||
DnSkillHandle hExistSkill = GetSkillFromIndex( i );
|
||
if( hExistSkill &&
|
||
hExistSkill != m_hProcessSkill &&
|
||
hExistSkill->GetGlobalSkillGroupID() == m_hProcessSkill->GetGlobalSkillGroupID() )
|
||
{
|
||
// ±Û·Î¹ú ÄðŸÀÓÀ¸·Î °°ÀÌ µµ´Â ½ºÅ³µéÀº »ç¿ëµÈ ½ºÅ³ÀÇ ÄðŸÀÓÀ¸·Î ¹Ù²ãÁØ´Ù.
|
||
hExistSkill->ResetCoolTime();
|
||
hExistSkill->OnAnotherGlobalSkillBeginCoolTime( hSkill );
|
||
hExistSkill->OnBeginCoolTime();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case CDnSkill::TimeToggle:
|
||
case CDnSkill::ActiveToggle:
|
||
case CDnSkill::ActiveToggleForSummon:
|
||
{
|
||
bool bToggleEnable = !hSkill->IsToggleOn();
|
||
hSkill->EnableToggle(bToggleEnable);
|
||
OnSkillToggle(hSkill, bToggleEnable);
|
||
|
||
#ifdef _GAMESERVER
|
||
// NOTE: Åä±ÛÀÌ ÄÑÁú ´ç½ÃÀÇ °ø°Ý·ÂÀ» ÀúÀåÇصдÙ. ÃßÈÄ¿¡ °ø°Ý·Â ¸»°í ´Ù¸¥ °ÍµéÀÌ Ãß°¡µÉ ¼öµµ ÀÖ´Ù.
|
||
if( hSkill && hSkill->IsToggleOn() )
|
||
{
|
||
m_ActorStateSnapshotForToggleProjectile.ResetState();
|
||
hSkill->CheckAndAddSelfStateEffect();
|
||
static_cast<CDnActor*>(this)->GetStateBlow()->Process( 0, 0.0f );
|
||
CDnActor* pActor = static_cast<CDnActor*>(this);
|
||
|
||
m_ActorStateSnapshotForToggleProjectile = *(static_cast<CDnState*>(pActor));
|
||
hSkill->CheckAndRemoveInstantApplySelfStateEffect();
|
||
}
|
||
#endif
|
||
}
|
||
break;;
|
||
|
||
case CDnSkill::Aura:
|
||
{
|
||
// ¿À¶ó ½ºÅ³µé³¢¸® Åä±Û¸µ ÇØÁÜ. ´Ù¸¥ ¿À¶ó ½ºÅ³ÀÌ ÄÑÁö¸é ²¨Áö°í, ÇöÀç ½ÃÀüÁßÀÎ ¿À¶ó ½ºÅ³ÀÌ¸é ²¨ÁØ´Ù.
|
||
// ¿À¶ó ½ºÅ³µéÀ» ¸ÕÀú Á¾·á½ÃÅ°°í »õ·Î ÄÑÁö´Â ¿À¶ó¸¦ ½ÇÇàÇØ¾ß »õ·Î ½ÇÇàµÉ ¿À¶ó¿¡¼ self blow Å¥¿¡ ½×ÀÎ °ÍµéÀÌ
|
||
// Ŭ¸®¾î µÇÁö ¾Ê°í Á¦´ë·Î Àû¿ëµÈ´Ù.
|
||
bool bProcessingAuraOff = false; // °°Àº ¿À¶ó ½ºÅ³ÀÌ execute µÇ¸é ¿À¶ó°¡ ²¨Áö´Â °ÍÀÓ.
|
||
int iNumAuraSkill = (int)m_vlhAuraSkills.size();
|
||
for( int iAuraSkill = 0; iAuraSkill < iNumAuraSkill; ++iAuraSkill )
|
||
{
|
||
DnSkillHandle hAuraSkill = m_vlhAuraSkills.at( iAuraSkill );
|
||
_ASSERT( hAuraSkill->GetDurationType() == CDnSkill::Aura );
|
||
if( hAuraSkill->IsAuraOn() )
|
||
{
|
||
if( m_hProcessSkill == hAuraSkill )
|
||
bProcessingAuraOff = true;
|
||
|
||
hAuraSkill->EnableAura( false );
|
||
OnSkillAura( hAuraSkill, false );
|
||
break;
|
||
}
|
||
}
|
||
|
||
// ´Ù¸¥ ¿À¶ó½ºÅ³À» »ç¿ëÇؼ ±âÁ¸ÀÇ ¿À¶ó°¡ ²¨Áö°í »õ·Î ¹ßµ¿µÊ.
|
||
if( false == bProcessingAuraOff )
|
||
{
|
||
for( int iAuraSkill = 0; iAuraSkill < iNumAuraSkill; ++iAuraSkill )
|
||
{
|
||
DnSkillHandle hAuraSkill = m_vlhAuraSkills.at( iAuraSkill );
|
||
if( hAuraSkill == m_hProcessSkill )
|
||
{
|
||
m_hProcessSkill->EnableAura( true );
|
||
OnSkillAura( m_hProcessSkill, true );
|
||
break;
|
||
|
||
// Note Çѱâ: m_hProcessSkill ½º¸¶Æ® Æ÷ÀÎÅÍ´Â ¿À¶ó ½ºÅ³ »ç¿ëÇÏ´Â ¾×¼ÇÀÌ Àç»ýµÇ´Â µ¿¾ÈÀº À¯È¿Çؾß
|
||
// °ÔÀÓ ¼¹ö¿¡¼ CDnPlayerActor::CmdStop() ÂÊ¿¡¼ °É·¯Áö±â ¶§¹®¿¡ °× ¼¹ö¿¡¼ ÇØ´ç ¾×¼Ç ½Ã±×³ÎÀÌ ³¡±îÁö
|
||
// 󸮵Ê. µû¶ó¼ CDnActor::OnChangeAction ÂÊ¿¡¼ ProcessSkill À» Identity ½ÃÅ´.
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// ÄÑÁ® ÀÖ´ø ¿À¶ó°¡ ²¨Áü.
|
||
m_hAuraSkill.Identity();
|
||
m_hProcessSkill.Identity();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
#ifndef _GAMESERVER
|
||
m_bSkillExecutedThisFrame = true;
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
void MASkillUser::UseAutoPassiveSkill( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listAutoPassiveSkills.begin();
|
||
for( iter; m_listAutoPassiveSkills.end() != iter; ++iter )
|
||
{
|
||
DnSkillHandle hSkill = *iter;
|
||
if( CDnSkill::UsingResult::Success == CanExecuteSkill( hSkill ) )
|
||
{
|
||
BYTE pBuffer[128] = {0,};
|
||
CPacketCompressStream Stream( pBuffer, 128 );
|
||
int iSkillID = hSkill->GetClassID();
|
||
int iEnchantSkillID = hSkill->GetEnchantedSkillID();
|
||
char cLevel = hSkill->GetLevel();
|
||
EtVector2 vLook, vZVec;
|
||
bool bUseApplySkillItem = false;
|
||
char cUseSignalSkill = -1;
|
||
bool bAutoUseFromServer = true;
|
||
bool abSignalSkillCheck[ 3 ] = { false };
|
||
|
||
vLook = EtVec3toVec2( *m_pActor->GetLookDir() );
|
||
vZVec = EtVec3toVec2( *m_pActor->GetMoveVectorZ() );
|
||
|
||
Stream.Write( &iSkillID, sizeof(int) );
|
||
Stream.Write( &cLevel, sizeof(char) );
|
||
Stream.Write( &bUseApplySkillItem, sizeof(bool) );
|
||
Stream.Write( abSignalSkillCheck, sizeof(abSignalSkillCheck) );
|
||
Stream.Write( &vZVec, sizeof(EtVector2), CPacketCompressStream::VECTOR2_SHORT );
|
||
Stream.Write( &vLook, sizeof(EtVector2), CPacketCompressStream::VECTOR2_SHORT );
|
||
Stream.Write( &bAutoUseFromServer, sizeof(bool) );
|
||
Stream.Write( &iEnchantSkillID, sizeof(int) );
|
||
#ifdef PRE_ADD_POSITION_SYNC_BY_SKILL_USAGE
|
||
Stream.Write( m_pActor->GetPosition(), sizeof(EtVector3), CPacketCompressStream::VECTOR3_BIT );
|
||
#endif
|
||
|
||
m_pActor->Send( eActor::SC_USESKILL, &Stream );
|
||
|
||
ExecuteSkill( hSkill, LocalTime, fDelta );
|
||
|
||
// ¹ßµ¿µÈ ¸®½ºÆ®¿¡ ³Ö¾îµÐ´Ù. process µ¹·Á¾ß Çϱ⠶§¹®¿¡,
|
||
m_listProcessAutoPassiveSkills.push_back( hSkill );
|
||
|
||
// »ç¿ëµÈ ¿ÀÅä ÆÐ½Ãºê ½ºÅ³Àº ¸Ç µÚ¿¡ ºÙÀδÙ. ½ÇÇà ¿ì¼±¼øÀ§¸¦ ³·Ãã.
|
||
m_listAutoPassiveSkills.erase( iter );
|
||
m_listAutoPassiveSkills.push_back( hSkill );
|
||
|
||
// ProcessSkill Àº ¾Æ´Ï¹Ç·Î ÃʱâÈ ½ÃÅ´. ProcessSkill ÀÌ ÀÖÀ¸¸é CmdStop ÀÌ ¸ÔÁö ¾Ê´Â´Ù.
|
||
m_hProcessSkill.Identity();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
bool MASkillUser::IsProcessingAutoPassive( int iSkillID )
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessAutoPassiveSkills.begin();
|
||
for( iter; iter != m_listProcessAutoPassiveSkills.end(); ++iter )
|
||
{
|
||
DnSkillHandle hAutoPassive = *iter;
|
||
if( hAutoPassive->GetClassID() == iSkillID )
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
|
||
|
||
void MASkillUser::EndAutoPassiveSkill( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessAutoPassiveSkills.begin();
|
||
for( iter; iter != m_listProcessAutoPassiveSkills.end(); ++iter )
|
||
{
|
||
DnSkillHandle hAutoPassive = *iter;
|
||
hAutoPassive->OnEnd( LocalTime, fDelta );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
bool MASkillUser::HavePassiveSkill(int iSkillID)
|
||
{
|
||
int iNumSkill = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for (int iSkill = 0; iSkill < iNumSkill; ++iSkill)
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at(iSkill);
|
||
if (iSkillID == hSkill->GetClassID())
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
void MASkillUser::OnSkillProcess( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
if( m_hAuraSkill )
|
||
{
|
||
//°ÔÀÓ ¼¹ö¿¡¼¸¸ ÆÇ´ÜÇؼ ¼¹öÂÊ Á¾·á ½ÃÅ°°í/Ŭ¶óÀ̾ðÆ®·Î ÆÐŶ Àü¼Û...
|
||
#if defined(_GAMESERVER)
|
||
if( m_hAuraSkill->IsFinished() )
|
||
{
|
||
if (m_pActor)
|
||
m_pActor->CmdFinishAuraSkill(m_hAuraSkill->GetClassID());
|
||
|
||
// [2011/03/22 semozz]
|
||
// ÇöÀç ½ºÅ³ÀÌ ¿À¶ó ½ºÅ³°ú °°Àº ½ºÅ³À̸é ÇöÀç ½ºÅ³µµ ÃʱâÈ.
|
||
if (m_hProcessSkill == m_hAuraSkill)
|
||
m_hProcessSkill.Identity();
|
||
|
||
OnSkillAura( m_hAuraSkill, false );
|
||
}
|
||
else
|
||
#endif // _GAMESERVER
|
||
m_hAuraSkill->ProcessExecute( LocalTime, fDelta );
|
||
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
if( m_pActor && m_pActor->IsPlayerActor() )
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessAutoPassiveSkills.begin();
|
||
for( iter; m_listProcessAutoPassiveSkills.end() != iter; )
|
||
{
|
||
DnSkillHandle hSkill = *iter;
|
||
|
||
//½ºÅ³ ÇÚµé À¯È¿¼º üũ Ãß°¡
|
||
if (!hSkill)
|
||
{
|
||
iter = m_listProcessAutoPassiveSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
if( hSkill->IsFinished() )
|
||
{
|
||
iter = m_listProcessAutoPassiveSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
hSkill->ProcessExecute( LocalTime, fDelta );
|
||
++iter;
|
||
}
|
||
}
|
||
}
|
||
|
||
m_PrefixSkillCoolTimeManager.Process(LocalTime, fDelta);
|
||
|
||
iter = m_listProcessPreFixDefenceSkills.begin();
|
||
for( iter; m_listProcessPreFixDefenceSkills.end() != iter; )
|
||
{
|
||
DnSkillHandle hSkill = *iter;
|
||
|
||
//½ºÅ³ ÇÚµé À¯È¿¼º üũ Ãß°¡
|
||
if (!hSkill)
|
||
{
|
||
iter = m_listProcessPreFixDefenceSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
if( hSkill->IsFinished() )
|
||
{
|
||
hSkill->OnEnd( LocalTime, fDelta );
|
||
iter = m_listProcessPreFixDefenceSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
hSkill->ProcessExecute( LocalTime, fDelta );
|
||
++iter;
|
||
}
|
||
}
|
||
}
|
||
|
||
iter = m_listProcessPreFixOffenceSkills.begin();
|
||
for( iter; m_listProcessPreFixOffenceSkills.end() != iter; )
|
||
{
|
||
DnSkillHandle hSkill = *iter;
|
||
if (!hSkill)
|
||
{
|
||
iter = m_listProcessPreFixOffenceSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
if( hSkill->IsFinished() )
|
||
{
|
||
hSkill->OnEnd( LocalTime, fDelta );
|
||
iter = m_listProcessPreFixOffenceSkills.erase( iter );
|
||
}
|
||
else
|
||
{
|
||
hSkill->ProcessExecute( LocalTime, fDelta );
|
||
++iter;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!m_prefixSystemDefenceSkills.empty())
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemDefenceSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator enditer = m_prefixSystemDefenceSkills.end();
|
||
|
||
for (; iter != enditer; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
iter->second.hSkill->Process(LocalTime, fDelta);
|
||
}
|
||
}
|
||
|
||
if (!m_prefixSystemOffenceSkills.empty())
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemOffenceSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator enditer = m_prefixSystemOffenceSkills.end();
|
||
|
||
for (; iter != enditer; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
iter->second.hSkill->Process(LocalTime, fDelta);
|
||
}
|
||
}
|
||
|
||
}
|
||
#else
|
||
m_bSkillExecutedThisFrame = false;
|
||
#endif
|
||
|
||
if( m_hProcessSkill )
|
||
{
|
||
if( m_hProcessSkill->IsFinished() )
|
||
{
|
||
m_hProcessSkill->OnEnd( LocalTime, fDelta );
|
||
m_hProcessSkill.Identity();
|
||
}
|
||
else
|
||
m_hProcessSkill->ProcessExecute( LocalTime, fDelta );
|
||
}
|
||
|
||
// ÄðŸÀÓ °¨¼Ò »óÅÂÈ¿°ú°¡ ÀÖ´Ù¸é µ¨Å¸°ª¿¡ ¿µÇâÀ» ÁÙ °ªÀ» °è»êÇÑ´Ù.
|
||
if( m_pActor && m_pActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_096 ) )
|
||
{
|
||
DNVector(DnBlowHandle) vlhCoolTimeBlows;
|
||
m_pActor->GetStateBlow()->GetStateBlowFromBlowIndex( STATE_BLOW::BLOW_096, vlhCoolTimeBlows );
|
||
|
||
// ÄðŸÀÓ °¨¼Ò »óÅÂÈ¿°ú´Â - ±âÁØÀ̱⶧¹®¿¡ ÁßøµÇ¸é »©ÁØ´Ù.
|
||
float fCoolTimeDeltaAdjust = 1.0f;
|
||
int iNumBlow = (int)vlhCoolTimeBlows.size();
|
||
for( int i = 0; i < iNumBlow; ++i )
|
||
{
|
||
fCoolTimeDeltaAdjust -= (1.0f - vlhCoolTimeBlows.at( i )->GetFloatValue());
|
||
}
|
||
|
||
// #40670 ½ºÇǸ´ ºÎ½ºÆ®µµ ÄðŸÀÓ °¨¼Ò »óÅÂÈ¿°ú¸¦ »ç¿ëÇÏ°Ô µÊ.
|
||
// Áßø½Ã WeightTable ¿¡¼ Á¦ÇÑÀ» ¹Þ°Ô µÈ´Ù.
|
||
float fCoolTimeAccelMax = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::CoolTimeAccellSE_Max );
|
||
if( fCoolTimeDeltaAdjust < 1.0f - fCoolTimeAccelMax )
|
||
fCoolTimeDeltaAdjust = 1.0f - fCoolTimeAccelMax;
|
||
|
||
// 1.0f À» Á¤»ó¼öÄ¡ ±âÁØÀ¸·Î »óÅÂÈ¿°ú ÀÎÀÚ°ªÀ» Àüü ÄðŸÀÓ¿¡ ±×´ë·Î Àû¿ëÇÑ °á°ú°ªÀÌ ÇöÀç ÃÖÁ¾ ÄðŸÀÓ ±âÁØÀ̹ǷÎ
|
||
// ¸Å ÇÁ·¹ÀÓ Ã³¸®ÇØÁÖ´Â µ¨Å¸ °ª¿¡ ºñÀ²ÀÇ ¿ª¼ö¸¦ °öÇÑ´Ù.
|
||
// °á°ú·Î ³ª¿Â °ªÀº °¢ ½ºÅ³¿¡¼ ·çÇÁ¸¦ µ¹ ¶§ ¾×ÅÍ¿¡¼ ¾ò¾î¿Í¼ Á÷Á¢ Àû¿ëÇÑ´Ù. 2415ÀÇ Å¸ÀÓ ¿¢¼¿·¯·¹ÀÌ¼Ç ½ºÅ³¸¸ Á¦¿ÜÇÏ°í.
|
||
m_fCoolTimeDeltaAdjustValue = 1.0f / fCoolTimeDeltaAdjust;
|
||
}
|
||
else
|
||
m_fCoolTimeDeltaAdjustValue = 1.0f;
|
||
|
||
|
||
|
||
#ifdef _GAMESERVER
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
|
||
#ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
// ÄðŸÀÓ Ã³¸®. ÃßÈÄ¿¡ Äð ŸÀÓ »Ó¸¸ ¾Æ´Ï¶ó ±âŸµîµîÀÇ ¿©·¯°¡Áö Áö¼ÓÀûÀÎ Processing À» ÇÏ°Ô µÉ °ÍÀÓ.
|
||
if( m_pActor && m_pActor->IsPlayerActor() /*&& m_pActor->IsAllowCallSkillProcess( fDelta )*/ )
|
||
{
|
||
#endif // #ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
|
||
for( DWORD i = 0; i < m_vlhSkillList.size(); i++ )
|
||
{
|
||
if( m_vlhSkillList.at( i ) )
|
||
m_vlhSkillList[i]->Process( LocalTime, fDelta );
|
||
}
|
||
|
||
#ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
}
|
||
#endif // #ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
|
||
#else
|
||
|
||
#ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
if( m_pActor && m_pActor->IsPlayerActor() /*&& m_pActor->IsAllowCallSkillProcess( fDelta )*/ )
|
||
{
|
||
#endif // #ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
|
||
PROFILE_TIME_TEST_BLOCK_START( "OnSkillProcess() - SkillHandleLoop" );
|
||
// ÄðŸÀÓ Ã³¸®. ÃßÈÄ¿¡ Äð ŸÀÓ »Ó¸¸ ¾Æ´Ï¶ó ±âŸµîµîÀÇ ¿©·¯°¡Áö Áö¼ÓÀûÀÎ Processing À» ÇÏ°Ô µÉ °ÍÀÓ.
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); i++ )
|
||
{
|
||
// Ŭ¶óÀ̾ðÆ®ÀÎ °æ¿ì¿£ ½ºÅ³ °´Ã¼ °ü¸®¸¦ ÇÏ´Â SkillTask °¡ ¸ÕÀú ¼Ò¸êµÇ¾î valid üũ¸¦ ÇØ¾ß ÇÔ.
|
||
if( m_vlSkillObjects.at( i ).hSkill )
|
||
m_vlSkillObjects.at( i ).hSkill->Process( LocalTime, fDelta );
|
||
}
|
||
PROFILE_TIME_TEST_BLOCK_END();
|
||
|
||
#ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
}
|
||
#endif // #ifdef PRE_FIX_GAMESERVER_PERFOMANCE
|
||
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
#else
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( DWORD i = 0; i < m_vlhSkillList.size(); i++ )
|
||
{
|
||
if( m_vlhSkillList.at( i ) )
|
||
m_vlhSkillList[i]->Process( LocalTime, fDelta );
|
||
}
|
||
#else
|
||
// ÄðŸÀÓ Ã³¸®. ÃßÈÄ¿¡ Äð ŸÀÓ »Ó¸¸ ¾Æ´Ï¶ó ±âŸµîµîÀÇ ¿©·¯°¡Áö Áö¼ÓÀûÀÎ Processing À» ÇÏ°Ô µÉ °ÍÀÓ.
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); i++ )
|
||
{
|
||
// Ŭ¶óÀ̾ðÆ®ÀÎ °æ¿ì¿£ ½ºÅ³ °´Ã¼ °ü¸®¸¦ ÇÏ´Â SkillTask °¡ ¸ÕÀú ¼Ò¸êµÇ¾î valid üũ¸¦ ÇØ¾ß ÇÔ.
|
||
if( m_vlSkillObjects.at( i ).hSkill )
|
||
m_vlSkillObjects.at( i ).hSkill->Process( LocalTime, fDelta );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
#endif // #ifdef _GAMESERVER
|
||
|
||
// ¾ÆÀÌÅÛ¿¡ ºÙÀº ½ºÅ³ÀÌ ÀÖ´Ù¸é Process
|
||
if( m_hItemSkill )
|
||
{
|
||
if( m_hItemSkill->IsFinished() )
|
||
{
|
||
m_hItemSkill->OnEnd( LocalTime, fDelta );
|
||
|
||
deque<DnSkillHandle>::iterator iter = find( m_dqhItemSkillList.begin(), m_dqhItemSkillList.end(), m_hItemSkill );
|
||
_ASSERT( m_dqhItemSkillList.end() != iter );
|
||
m_dqhItemSkillList.erase( iter );
|
||
|
||
SAFE_RELEASE_SPTR( m_hItemSkill );
|
||
}
|
||
else
|
||
m_hItemSkill->ProcessExecute( LocalTime, fDelta );
|
||
}
|
||
|
||
for( DWORD i = 0; i < m_dqhItemSkillList.size(); ++i )
|
||
{
|
||
m_dqhItemSkillList.at( i )->Process( LocalTime, fDelta );
|
||
}
|
||
|
||
// Á¾·á ¿¹¾àµÈ ½ºÅ³µé Á¾·á ½ÃÅ´.
|
||
int iNumReservedFinishSkill = (int)m_vlhReservedFinishSkill.size();
|
||
for( int iSkill = 0; iSkill < iNumReservedFinishSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhReservedFinishSkill.at( iSkill );
|
||
if( hSkill == m_hProcessSkill )
|
||
{
|
||
m_hProcessSkill->OnEnd( LocalTime, fDelta );
|
||
m_hProcessSkill.Identity();
|
||
}
|
||
else
|
||
if( hSkill == m_hToggleSkill )
|
||
{
|
||
_ASSERT( m_hToggleSkill->IsToggleOn() );
|
||
if( m_hToggleSkill->IsToggleOn() )
|
||
OnSkillToggle( m_hToggleSkill, false );
|
||
}
|
||
else
|
||
if( hSkill == m_hAuraSkill )
|
||
{
|
||
_ASSERT( m_hAuraSkill->IsAuraOn() );
|
||
if( m_hAuraSkill->IsAuraOn() )
|
||
OnSkillAura( m_hAuraSkill, false );
|
||
}
|
||
}
|
||
|
||
if( false == m_vlhReservedFinishSkill.empty() )
|
||
m_vlhReservedFinishSkill.clear();
|
||
}
|
||
|
||
|
||
|
||
// ÀÌ ÇÔ¼ö´Â ¸ó½ºÅ͵ç Ç÷¹À̾îµç ¹«±âµç OnSignal ¿¡¼ Projectile ÀÌ °É¸®¸é Ç×»ó È£ÃâµÈ´Ù!!
|
||
void MASkillUser::OnSkillProjectile( CDnProjectile *pProjectile )
|
||
{
|
||
if( !IsValidActor() )
|
||
return;
|
||
|
||
// Projectile ÀÇ °Ñ¸ð½ÀÀ» ½ÇÁ¦·Î ¹Ù²ãÁØ´Ù.
|
||
bool bClientSide = false;
|
||
|
||
#if defined( _GAMESERVER )
|
||
if( m_pActor->GetClassID() <= CDnActor::Reserved6 && m_pActor->IsPlayerActor() && ((CDnPlayerActor*)m_pActor)->IsLocalActor() )
|
||
bClientSide = true;
|
||
#endif // #if defined( _GAMESERVER )
|
||
|
||
if( m_hToggleSkill && m_hToggleSkill->IsToggleOn() )
|
||
{
|
||
// ÇöÀç Åä±Û Enable µÉ »óÅÂÀÎ ½ºÅ³À» ó¸®ÇÏ´Â °ÍÀÓ.
|
||
_ASSERT( m_hToggleSkill->IsToggleOn() );
|
||
|
||
CDnChangeProjectileProcessor* pChangeProj = static_cast<CDnChangeProjectileProcessor*>(m_hToggleSkill->GetProcessor( IDnSkillProcessor::CHANGE_PROJECTILE ));
|
||
if( pChangeProj )
|
||
{
|
||
int iCheckProjectileID = ( bClientSide ) ? pChangeProj->GetSourceWeaponID() : pChangeProj->GetChangeWeaponID();
|
||
if( pProjectile->GetClassID() == iCheckProjectileID )
|
||
{
|
||
if( m_hToggleSkill->GetDurationType() == CDnSkill::ActiveToggle )
|
||
{
|
||
if( !(m_hToggleSkill->GetDecreaseMP() > 0 && m_pActor->GetSP() < m_hToggleSkill->GetDecreaseMP()) )
|
||
{
|
||
// ¸¶À»¿¡¼´Â SP ¾È ±ïÀ̵µ·Ï
|
||
#ifndef _GAMESERVER
|
||
if( CDnWorld::MapTypeVillage != CDnWorld::GetInstance().GetMapType() )
|
||
#endif
|
||
m_pActor->UseMP( -m_hToggleSkill->GetDecreaseMP() );
|
||
//m_pActor->SetSP( m_pActor->GetSP() - m_hToggleSkill->GetDecreaseMP() );
|
||
|
||
if( bClientSide )
|
||
{
|
||
int iWeaponLength = pProjectile->GetWeaponLength() - pProjectile->GetOriginalWeaponLength();
|
||
*(CDnWeapon*)pProjectile = *pChangeProj->GetProjectile();
|
||
pProjectile->SetWeaponLength( iWeaponLength + pProjectile->GetOriginalWeaponLength() );
|
||
}
|
||
|
||
OnSkillToggleProjectile( m_hToggleSkill, pProjectile );
|
||
|
||
if( m_pActor->GetSP() < m_hToggleSkill->GetDecreaseMP() )
|
||
{
|
||
OnSkillToggle( m_hToggleSkill, false );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// ChangeAction À̶ó°í ÁöÈ£¾¾°¡ Ãß°¡ÇÑ °Å ÀÖÀ½
|
||
CDnChangeActionStrProcessor* pChangeAction = static_cast<CDnChangeActionStrProcessor*>(m_hToggleSkill->GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR ));
|
||
if( pChangeAction )
|
||
{
|
||
if( m_hToggleSkill->GetDurationType() == CDnSkill::ActiveToggle )
|
||
{
|
||
if( !(m_hToggleSkill->GetDecreaseMP() > 0 && m_pActor->GetSP() < m_hToggleSkill->GetDecreaseMP()) )
|
||
{
|
||
// ¸¶À»¿¡¼´Â SP ¾È ±ïÀ̵µ·Ï
|
||
#ifndef _GAMESERVER
|
||
if( CDnWorld::MapTypeVillage != CDnWorld::GetInstance().GetMapType() )
|
||
#endif
|
||
m_pActor->UseMP( -m_hToggleSkill->GetDecreaseMP() );
|
||
//m_pActor->SetSP( m_pActor->GetSP() - m_hToggleSkill->GetDecreaseMP() );
|
||
|
||
OnSkillToggleProjectile( m_hToggleSkill, pProjectile );
|
||
|
||
if( m_pActor->GetSP() < m_hToggleSkill->GetDecreaseMP() )
|
||
{
|
||
OnSkillToggle( m_hToggleSkill, false );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
if( pProjectile && !bClientSide )
|
||
{
|
||
// Note Çѱâ: Á÷Á¢ µ¥¹ÌÁö °è»ê¿¡ ÇÊ¿äÇÑ ActorState ¸¦ Projectile ¿¡ ½Ç¾î¼ ³¯¸®´Â ¹æ¹ýÀ¸·Î º¯°æ.
|
||
// Åä±Û ½ºÅ³ÀÌ ¾Æ´Ñ ÇÁ·ÎÁ§Å¸ÀÏÀ» ½î´Â ½ºÅ³ÀÎ °æ¿ì¿£ ¿©±â¼ °ø°Ý·Â Àû¿ë½ÃÄÑÁÜ
|
||
if( !m_hToggleSkill && m_hProcessSkill )
|
||
{
|
||
static_cast<CDnActor*>(this)->GetStateBlow()->Process( 0, 0.0f );
|
||
CDnActor* pActor = static_cast<CDnActor*>(this);
|
||
|
||
// üÀÎ ½ºÅ³ »óÅÂÈ¿°ú¸¦ ¾²´Â ¹ß»çü´Â
|
||
// CDnState º¹»ç°¡ ¸Å¿ì ºó¹øÇÏ°Ô ÀϾ ¼ö ÀÖÀ¸¹Ç·Î shaared_ptr »ç¿ë.
|
||
boost::shared_ptr<CDnState> pActorStateSnapshot = boost::shared_ptr<CDnState>(new CDnState);
|
||
*pActorStateSnapshot = *(static_cast<CDnState*>(pActor));
|
||
|
||
// ½ºÅ³ÀÎ °æ¿ì¿¡¸¸ ¿©±â¼
|
||
pProjectile->FromSkill( true );
|
||
pProjectile->SetShooterStateSnapshot( pActorStateSnapshot );
|
||
|
||
|
||
#if defined(PRE_FIX_65287)
|
||
float fFinalDamageRate = 0.0f;
|
||
if (pActor && pActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_050))
|
||
{
|
||
DNVector(DnBlowHandle) vlhBlows;
|
||
pActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_050, vlhBlows );
|
||
int iNumBlow = (int)vlhBlows.size();
|
||
for( int i = 0; i < iNumBlow; ++i )
|
||
{
|
||
fFinalDamageRate += vlhBlows[i]->GetFloatValue();
|
||
}
|
||
}
|
||
|
||
pProjectile->SetShooterFinalDamageRate(fFinalDamageRate);
|
||
#endif // PRE_FIX_65287
|
||
}
|
||
else if( m_hToggleSkill && m_hToggleSkill->IsToggleOn() )
|
||
{
|
||
// ÇöÀç Åä±Û ½ºÅ³Àº »ç¿ëµÇÁö ¾ÊÁö¸¸ ÃßÈÄ ¾îÂîµÉÁö ¸ô¶ó ÄÚµå ³²°ÜµÒ. 2011.03.15
|
||
// Åä±ÛÀ» ÄÒ ´ç½ÃÀÇ ´É·ÂÄ¡·Î ÇÁ·ÎÁ§Å¸ÀÏ¿¡ ¼ÂÆÃÇØ ÁÜ.
|
||
boost::shared_ptr<CDnState> pActorStatesnapshot = boost::shared_ptr<CDnState>( new CDnState );
|
||
*pActorStatesnapshot = m_ActorStateSnapshotForToggleProjectile;
|
||
|
||
pProjectile->SetShooterStateSnapshot( pActorStatesnapshot );
|
||
pProjectile->FromSkill( true );
|
||
|
||
#if defined(PRE_FIX_65287)
|
||
CDnActor* pActor = static_cast<CDnActor*>(this);
|
||
|
||
float fFinalDamageRate = 0.0f;
|
||
if (pActor && pActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_050))
|
||
{
|
||
DNVector(DnBlowHandle) vlhBlows;
|
||
pActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_050, vlhBlows );
|
||
int iNumBlow = (int)vlhBlows.size();
|
||
for( int i = 0; i < iNumBlow; ++i )
|
||
{
|
||
fFinalDamageRate += vlhBlows[i]->GetFloatValue();
|
||
}
|
||
}
|
||
|
||
pProjectile->SetShooterFinalDamageRate(fFinalDamageRate);
|
||
#endif // PRE_FIX_65287
|
||
}
|
||
else if( m_pActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_121 ) || m_pActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_129 ) )
|
||
{
|
||
// #30362 ½ºÅÄµå ¾×¼Ç º¯°æ »óÅÂÈ¿°ú¿¡¼ ¹ß»çü¸¦ ½î´Â °æ¿ì¿¡µµ ½ºÅ³ ¹ß»çü·Î ó¸® ÇÔ.
|
||
pProjectile->FromSkill( true );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
void MASkillUser::OnSkillToggleProjectile( DnSkillHandle hSkill, CDnProjectile *pProjectile )
|
||
{
|
||
}
|
||
|
||
void MASkillUser::OnSkillToggle( DnSkillHandle hSkill, bool bEnable )
|
||
{
|
||
if( !IsValidActor() ) return;
|
||
|
||
if( bEnable )
|
||
{
|
||
switch( hSkill->GetDurationType() )
|
||
{
|
||
case CDnSkill::ActiveToggle:
|
||
case CDnSkill::ActiveToggleForSummon:
|
||
// ¸¶À»¿¡¼´Â SP ¾È ±ïÀ̵µ·Ï
|
||
#ifndef _GAMESERVER
|
||
if( CDnWorld::MapTypeVillage != CDnWorld::GetInstance().GetMapType() )
|
||
#endif
|
||
// Åä±Û¸µÇÒ¶© ±ïÀÌÁö ¾Ê´Â´Ù. ¾µ ¶§ ±ïÀÓ
|
||
//m_pActor->SetSP( m_pActor->GetSP() - hSkill->GetDecreaseSP() );
|
||
hSkill->OnBegin( m_LocalTime, 0.0f );
|
||
break;
|
||
|
||
case CDnSkill::TimeToggle:
|
||
hSkill->OnBegin( m_LocalTime, 0.0f );
|
||
break;
|
||
}
|
||
|
||
SkillToggle(hSkill, true);
|
||
}
|
||
else
|
||
{
|
||
SkillToggle(hSkill, false);
|
||
|
||
hSkill->OnEnd( m_LocalTime, 0.0f );
|
||
hSkill->EnableToggle( false );
|
||
}
|
||
|
||
//if( bEnable ) {
|
||
// switch( hSkill->GetDurationType() ) {
|
||
// case CDnSkillBase::TimeToggle:
|
||
// pActor->SetSP( pActor->GetSP() - hSkill->GetDecreaseSP() );
|
||
// hSkill->Execute( m_LocalTime, 0.f );
|
||
// break;
|
||
// case CDnSkillBase::ActiveToggle:
|
||
// hSkill->Execute( m_LocalTime, 0.f );
|
||
// break;
|
||
// case CDnSkillBase::Aura:
|
||
// pActor->SetSP( pActor->GetSP() - hSkill->GetDecreaseSP() );
|
||
// hSkill->Execute( m_LocalTime, 0.f );
|
||
// break;
|
||
// }
|
||
//}
|
||
//else {
|
||
// hSkill->Finish( m_LocalTime, 0.f );
|
||
//}
|
||
}
|
||
|
||
|
||
void MASkillUser::OnSkillAura( DnSkillHandle hSkill, bool bEnable )
|
||
{
|
||
if( !IsValidActor() ) return;
|
||
|
||
if( bEnable )
|
||
{
|
||
switch( hSkill->GetDurationType() )
|
||
{
|
||
case CDnSkill::Aura:
|
||
// ¸¶À»¿¡¼´Â SP ¾È ±ïÀ̵µ·Ï
|
||
#ifndef _GAMESERVER
|
||
if( CDnWorld::MapTypeVillage != CDnWorld::GetInstance().GetMapType() )
|
||
#endif
|
||
m_pActor->UseMP( -hSkill->GetDecreaseMP() );
|
||
//m_pActor->SetSP( m_pActor->GetSP() - hSkill->GetDecreaseMP() );
|
||
hSkill->OnBegin( m_LocalTime, 0.0f );
|
||
break;
|
||
}
|
||
|
||
m_hAuraSkill = hSkill;
|
||
}
|
||
else
|
||
{
|
||
hSkill->OnEnd( m_LocalTime, 0.0f );
|
||
hSkill->EnableAura( false );
|
||
|
||
if( m_hAuraSkill == hSkill )
|
||
m_hAuraSkill.Identity();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
void MASkillUser::ResetToggleSkill()
|
||
{
|
||
//if( m_hToggleSkill )
|
||
// m_hToggleSkill.Identity();
|
||
|
||
//int iNumToggle = (int)m_vlhToggleSkills.size();
|
||
//for( int i = 0; i < iNumToggle; ++i )
|
||
//{
|
||
// if( m_vlhToggleSkills.at(i)->IsToggleOn() )
|
||
// OnSkillToggle( m_vlhToggleSkills.at(i), false );
|
||
//}
|
||
}
|
||
|
||
|
||
|
||
void MASkillUser::ResetAuraSkill()
|
||
{
|
||
//if( m_hAuraSkill )
|
||
// m_hAuraSkill.Identity();
|
||
|
||
//int iNumAura = (int)m_vlhAuraSkills.size();
|
||
//for( int i = 0; i < iNumAura; ++i )
|
||
//{
|
||
// if( m_vlhAuraSkills.at(i)->IsAuraOn() )
|
||
// OnSkillAura( m_vlhAuraSkills.at(i), false );
|
||
//}
|
||
}
|
||
|
||
|
||
bool MASkillUser::IsProcessSkill()
|
||
{
|
||
if( !m_hProcessSkill ) return false;
|
||
return !m_hProcessSkill->IsFinished();
|
||
|
||
return true;
|
||
}
|
||
|
||
DWORD MASkillUser::GetSkillCount()
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
return (DWORD)m_vlhSkillList.size();
|
||
#else
|
||
return (DWORD)m_vlSkillObjects.size();
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
DnSkillHandle MASkillUser::GetSkillFromIndex( DWORD dwIndex )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
if( dwIndex < 0 || dwIndex >= m_vlhSkillList.size() ) return CDnSkill::Identity();
|
||
return m_vlhSkillList[dwIndex];
|
||
#else
|
||
if( dwIndex < 0 || dwIndex >= m_vlSkillObjects.size() )
|
||
return CDnSkill::Identity();
|
||
|
||
return m_vlSkillObjects.at( dwIndex ).hSkill;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
CDnSkill::UsingResult MASkillUser::UseSkill( int nSkillTableID, bool bCheckValid, bool bAutoUseFromServer/* = false*/, int nLuaSkillIndex/*=-1*/ )
|
||
{
|
||
CDnSkill::UsingResult eResult = CDnSkill::UsingResult::Failed;
|
||
|
||
DnSkillHandle hSkill = FindSkill( nSkillTableID );
|
||
if( hSkill )
|
||
{
|
||
if( m_pActor && m_pActor->IsPlayerActor() )
|
||
{
|
||
if( hSkill->GetSkillType() == CDnSkill::SkillTypeEnum::EnchantPassive )
|
||
return CDnSkill::UsingResult::Hack;
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
// ¼¹öÀÇ ÄðŸÀÓ ¿ÀÂ÷¸¦ °¨¾ÈÇؼ 0.5ÃÊÀÇ ¿©À¯¸¦ µÎ°í ÀÖÁö¸¸,
|
||
// Á¸À̵¿ÇÒ¶§³ª ±âŸ 0.5ÃÊ ÀÌ»ó Ŭ¶óÀ̾ðÆ®¿Í ¹ú¾îÁö´Â ´Ù¸¥ »õ·Î¿î °æ¿ìµéÀÌ »ý±æ ¼ö ÀÖÀ¸¹Ç·Î
|
||
// ÃÖÁ¾ ½ºÅ³ »ç¿ëÇÑ Å¸ÀÓ ½ºÅÆÇÁ¸¦ Âï¾îµÎ¾î µ¥ÀÌÅÍ¿¡ ÁöÁ¤µÈ ½ºÅ³ÀÇ ÄðŸÀÓº¸Å¸ °£°ÝÀÌ Å©´Ù¸é
|
||
// ¼¹öÀÇ ½ºÅ³ °´Ã¼¿¡ ÀúÀåµÇ¾îÀÖ´Â ÄðŸÀÓÀ» ÃʱâÈ ½ÃÄÑÁÖµµ·Ï ÇÑ´Ù. (#19737)
|
||
hSkill->UpdateSkillCoolTimeExactly();
|
||
#endif
|
||
|
||
eResult = CanExecuteSkill( hSkill );
|
||
if( !bCheckValid || CDnSkill::UsingResult::Success == eResult )
|
||
{
|
||
#if defined(_CLIENT)
|
||
//½ºÅ³ »ç¿ëÀÌ ¼º°øÀÌ¶óµµ ¼Òȯ ¸ó½ºÅÍ°¡ ÀÖ´Ù¸é ¼Òȯ ¸ó½ºÅ͸¦ ¼Òȯ ÇØÁ¦¸¸ ÇÏ°í ½ÇÁ¦ ½ºÅ³ »ç¿ëÀº ¾ÈµÊ..
|
||
if (hSkill->GetDurationType() == CDnSkill::DurationTypeEnum::SummonOnOff)
|
||
{
|
||
if (hSkill->SummonMonsterOff())
|
||
return eResult;
|
||
}
|
||
#endif // _CLIENT
|
||
#ifdef _GAMESERVER
|
||
ExecuteSkill( hSkill, m_LocalTime, 0.f );
|
||
#else
|
||
ExecuteSkill( hSkill, m_LocalTime, 0.f, bCheckValid, bAutoUseFromServer );
|
||
#endif
|
||
}
|
||
#if defined(_CLIENT)
|
||
else
|
||
{
|
||
// ½ºÅ³ »ç¿ëÀÌ ½ÇÆÐ Çß´õ¶óµµ ¼Òȯ ¸ó½ºÅÍ°¡ ÀÖ´Ù¸é ¼Òȯ ¸ó½ºÅÍ ¼Òȯ ÇØÁ¦ ½ÃÅ´.
|
||
if (hSkill->GetDurationType() == CDnSkill::DurationTypeEnum::SummonOnOff)
|
||
hSkill->SummonMonsterOff();
|
||
}
|
||
#endif // _CLIENT
|
||
}
|
||
|
||
return eResult;
|
||
}
|
||
|
||
|
||
|
||
bool MASkillUser::UseItemSkill( int nSkillTableID, int nSkillLevelTableID, CDnItem::ItemSkillApplyType ItemSkillApplyType, int nItemID/* = -1*/ )
|
||
{
|
||
if( !IsValidActor() ) return false;
|
||
bool bResult = true;
|
||
|
||
switch( ItemSkillApplyType )
|
||
{
|
||
case CDnItem::ApplySkill:
|
||
{
|
||
// ¿©±â¼ »ý¼ºµÈ ¾ÆÀÌÅÛ ½ºÅ³Àº OnProcessSkill ÇÔ¼ö¿¡¼ Finish üũ¸¦ ÇÏ¿© ¸®½ºÆ®¿¡¼ ¾Ë¾Æ¼ »èÁ¦ÇØÁØ´Ù.
|
||
DnSkillHandle hSkill = CDnSkill::CreateSkill( m_pActor->GetMySmartPtr(), nSkillTableID, nSkillLevelTableID );
|
||
|
||
if( !hSkill ) {
|
||
bResult = false;
|
||
break;
|
||
}
|
||
|
||
// ¾ÆÀÌÅÛ¿¡ ºÙÀº ½ºÅ³·Î ¼ÂÆÃÇØÁÜ.
|
||
hSkill->AsItemSkill();
|
||
|
||
#if defined(_GAMESERVER)
|
||
hSkill->SetItemID(nItemID);
|
||
#endif // _GAMESERVER
|
||
|
||
m_dqhItemSkillList.push_back( hSkill );
|
||
|
||
ExecuteSkill( hSkill, m_LocalTime, 0.f );
|
||
m_hItemSkill = hSkill;
|
||
}
|
||
break;
|
||
|
||
// »èÁ¦ ¿¹Á¤.
|
||
case CDnItem::ApplyStateBlow:
|
||
{
|
||
//// ¿©±â¿¡ µé¾î¿À´Â Instant ¾ÆÀÌÅÛÀÎ °æ¿ì CDnItemTask ¿¡¼ ¾ÆÀÌÅÛ »ý¼ºÇÏ°í °ð¹Ù·Î »èÁ¦ÇÔ.
|
||
//DnSkillHandle hSkill = CDnSkill::CreateSkill( m_pActor->GetMySmartPtr(), nSkillTableID, nSkillLevelTableID );
|
||
//
|
||
//if( !hSkill )
|
||
// bResult = false;
|
||
|
||
//hSkill->AsItemSkill();
|
||
|
||
//// °Á¦·Î »óÅÂÈ¿°ú µ¿±â¸¦ ¸ÂÃçÁÖ´Â ÇÔ¼ö.
|
||
//hSkill->OnBeginForceSync( m_LocalTime, 0.0f );
|
||
//hSkill->Release();
|
||
}
|
||
break;
|
||
}
|
||
|
||
return bResult;
|
||
}
|
||
|
||
|
||
|
||
void MASkillUser::ResetSkillCoolTime( void )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( iSkill );
|
||
if( hSkill )
|
||
hSkill->ResetCoolTime();
|
||
}
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
if (hSkill)
|
||
hSkill->ResetCoolTime();
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
#if defined(_GAMESERVER)
|
||
m_listProcessPreFixDefenceSkills.clear();
|
||
m_listProcessPreFixOffenceSkills.clear();
|
||
|
||
if (!m_prefixSystemDefenceSkills.empty())
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemDefenceSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator enditer = m_prefixSystemDefenceSkills.end();
|
||
|
||
for (; iter != enditer; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
iter->second.hSkill->ResetCoolTime();
|
||
}
|
||
}
|
||
|
||
if (!m_prefixSystemOffenceSkills.empty())
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemOffenceSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator enditer = m_prefixSystemOffenceSkills.end();
|
||
|
||
for (; iter != enditer; ++iter)
|
||
{
|
||
if (iter->second.hSkill)
|
||
iter->second.hSkill->ResetCoolTime();
|
||
}
|
||
}
|
||
|
||
m_PrefixSkillCoolTimeManager.InitList();
|
||
#endif // _GAMESERVER
|
||
}
|
||
|
||
void MASkillUser::ResetPvPSkillCoolTime()
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( iSkill );
|
||
if( hSkill->GetSkillType() == CDnSkill::SkillTypeEnum::Active )
|
||
{
|
||
hSkill->OnBeginCoolTime();
|
||
}
|
||
}
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
if( hSkill->GetSkillType() == CDnSkill::SkillTypeEnum::Active )
|
||
{
|
||
hSkill->OnBeginCoolTime();
|
||
}
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
void MASkillUser::ResetLadderSkillCoolTime()
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
ResetSkillCoolTime();
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( iSkill );
|
||
hSkill->SetElapsedDelayTime( hSkill->GetDelayTime()/2 );
|
||
}
|
||
#else
|
||
ResetSkillCoolTime();
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
hSkill->SetElapsedDelayTime( hSkill->GetDelayTime()/2 );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
void MASkillUser::IgnoreSkillCoolTime( void )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int iSkill = 0; iSkill < iNumSkill; ++iSkill )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( iSkill );
|
||
hSkill->IgnoreCoolTime();
|
||
}
|
||
|
||
m_bIgnoreCoolTime = true;
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
hSkill->IgnoreCoolTime();
|
||
}
|
||
|
||
m_bIgnoreCoolTime = true;
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
#endif
|
||
|
||
|
||
void MASkillUser::ReserveFinishSkill( DnSkillHandle hSkill )
|
||
{
|
||
if( hSkill )
|
||
{
|
||
m_vlhReservedFinishSkill.push_back( hSkill );
|
||
}
|
||
}
|
||
|
||
|
||
void MASkillUser::CancelUsingSkill( void )
|
||
{
|
||
if( m_hProcessSkill )
|
||
{
|
||
m_hProcessSkill->OnEnd( 0, 0.0f );
|
||
m_hProcessSkill.Identity();
|
||
}
|
||
};
|
||
|
||
|
||
void MASkillUser::OnAttachWeapon( DnWeaponHandle hWeapon, int iChangedWeaponIndex )
|
||
{
|
||
// ÆÐ½Ãºê ½ºÅ³µé Áß¿¡ »ç¿ë°¡´É ¹«±â¸¦ Á¤ÀÇÇÑ °ÍµéÀÌ ÀÖ³ª üũ.
|
||
// ´Ù¸¥ ¹«±â¸¦ Â÷°í ÀÖ¾î¼ ÆÐ½Ãºê »óÅÂÈ¿°úµéÀÌ Àû¿ëµÈ »óÅ°¡ ¾Æ´Ï¶ó¸é È°¼ºÈ ½ÃÄÑÁØ´Ù.
|
||
int iNumSelfBlowPassiveSkills = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for( int i = 0; i < iNumSelfBlowPassiveSkills; ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at( i );
|
||
if( false == hSkill->IsAppliedPassiveBlows() )
|
||
{
|
||
// ³»ºÎ¿¡¼ »ç¿ë°¡´É ¹«±â üũ ÇÔ.
|
||
ApplyPassiveSkill( hSkill );
|
||
}
|
||
}
|
||
|
||
// rangechecker ÀÖ´Â ½ºÅ³µéÀº ¹«±â áÀ» ¶§ ¾÷µ¥ÀÌÆ® ÇØÁØ´Ù.
|
||
#ifndef _GAMESERVER
|
||
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int i = 0; i < iNumSkill; ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( i );
|
||
hSkill->UpdateRangeChecker( hSkill->GetSelectedLevelDataType() );
|
||
}
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
hSkill->UpdateRangeChecker( hSkill->GetSelectedLevelDataType() );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
|
||
#endif
|
||
}
|
||
|
||
void MASkillUser::OnDetachWeapon( DnWeaponHandle hWeapon, int iDetachedWeaponIndex )
|
||
{
|
||
// ÆÐ½Ãºê ½ºÅ³µé Áß¿¡ »ç¿ë°¡´É ¹«±â¸¦ Á¤ÀÇÇÑ °ÍµéÀÌ ÀÖ³ª üũ.
|
||
// ¿ä±¸ÇÏ´Â ¹«±â¿Í ¸ÂÁö ¾Ê´Â´Ù¸é ÆÐ½Ãºê ½ºÅ³¿¡ µþ¸° »óÅÂÈ¿°úµéÀ» Á¦°ÅÇÑ´Ù.
|
||
int iNumSelfBlowPassiveSkills = (int)m_vlhSelfPassiveBlowSkill.size();
|
||
for( int i = 0; i < iNumSelfBlowPassiveSkills; ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSelfPassiveBlowSkill.at( i );
|
||
if( hSkill->IsAppliedPassiveBlows() )
|
||
{
|
||
if( false == hSkill->IsSatisfyWeapon() )
|
||
{
|
||
int iNumStateBlow = hSkill->GetStateEffectCount();
|
||
for( int iBlow = 0; iBlow < iNumStateBlow; ++iBlow )
|
||
{
|
||
const CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( iBlow );
|
||
|
||
DNVector(DnBlowHandle) vlAppliedBlows;
|
||
m_pActor->GatherAppliedStateBlowByBlowIndex( (STATE_BLOW::emBLOW_INDEX)pSE->nID, vlAppliedBlows );
|
||
|
||
int iNumAppliedBlow = (int)vlAppliedBlows.size();
|
||
for( int iAppliedBlow = 0; iAppliedBlow < iNumAppliedBlow; ++iAppliedBlow )
|
||
{
|
||
DnBlowHandle hBlow = vlAppliedBlows.at( iAppliedBlow );
|
||
if( hBlow->GetParentSkillInfo()->iSkillID == hSkill->GetClassID() )
|
||
{
|
||
// Çö½ÃÁ¡¿¡¼ °ð¹Ù·Î »èÁ¦
|
||
//m_pActor->GetStateBlow()->RemoveImediatlyStateEffectFromID( hBlow->GetBlowID() );
|
||
//RebirthBlow¿¡¼ OnBegin¿¡¼ Ÿ°í µé¾î¿Í¼ »èÁ¦°¡ µÇ´Â °æ¿ì°¡ ¹ß»ý.
|
||
//Áï½Ã Áö¿ìÁö ¾Ê°í Áö¿ò ¸®½ºÆ®¿¡ Ãß°¡ Çϵµ·Ï ¼öÁ¤
|
||
m_pActor->GetStateBlow()->RemoveStateBlowFromID(hBlow->GetBlowID());
|
||
}
|
||
}
|
||
}
|
||
|
||
hSkill->SetAppliedPassiveBlows( false );
|
||
}
|
||
}
|
||
}
|
||
|
||
// rangechecker ÀÖ´Â ½ºÅ³µéÀº ¹«±â áÀ» ¶§ ¾÷µ¥ÀÌÆ® ÇØÁØ´Ù.
|
||
#ifndef _GAMESERVER
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
int iNumSkill = (int)m_vlhSkillList.size();
|
||
for( int i = 0; i < iNumSkill; ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( i );
|
||
hSkill->UpdateRangeChecker( hSkill->GetSelectedLevelDataType() );
|
||
}
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
hSkill->UpdateRangeChecker( hSkill->GetSelectedLevelDataType() );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
#endif
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
void MASkillUser::SelectSkillLevelDataType( int iLevelDataType, bool bPlayerSummonedMonster/* = false*/ )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
for( int i = 0; i < (int)m_vlhSkillList.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlhSkillList.at( i );
|
||
hSkill->SelectLevelDataType( iLevelDataType, bPlayerSummonedMonster );
|
||
}
|
||
#else
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects.at( i ).hSkill;
|
||
hSkill->SelectLevelDataType( iLevelDataType, bPlayerSummonedMonster );
|
||
}
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
|
||
int MASkillUser::GetSelectedSkillLevelDataType( void )
|
||
{
|
||
#ifndef PRE_FIX_SKILLLIST
|
||
if( m_vlhSkillList.empty() )
|
||
return CDnSkill::NUM_SKILLLEVEL_APPLY_TYPE;
|
||
else
|
||
return m_vlhSkillList.front()->GetSelectedLevelDataType();
|
||
#else
|
||
if( m_vlSkillObjects.empty() )
|
||
return CDnSkill::NUM_SKILLLEVEL_APPLY_TYPE;
|
||
else
|
||
return m_vlSkillObjects.front().hSkill->GetSelectedLevelDataType();
|
||
#endif // #ifndef PRE_FIX_SKILLLIST
|
||
}
|
||
#endif
|
||
|
||
#ifndef _GAMESERVER
|
||
bool MASkillUser::IsUsingSkillAction( const char *szAction )
|
||
{
|
||
if( m_setUseActionNames.find( szAction ) != m_setUseActionNames.end() ) return true;
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
|
||
void MASkillUser::AddStateBlowIDToRemove(int blowID)
|
||
{
|
||
m_vlStateBlowIDToRemove.insert(std::map<int, int>::value_type(blowID, blowID));
|
||
}
|
||
|
||
void MASkillUser::InitStateBlowIDToRemove()
|
||
{
|
||
m_vlStateBlowIDToRemove.clear();
|
||
}
|
||
|
||
#ifdef _GAMESERVER
|
||
void MASkillUser::RemoveApplySEWhenTargetNormalHitProcessor( IDnSkillProcessor* pProcessor )
|
||
{
|
||
DNVector( IDnSkillProcessor* )::iterator iter = find( m_vlpApplySEWhenNormalHitProcessor.begin(), m_vlpApplySEWhenNormalHitProcessor.end(), pProcessor );
|
||
if( m_vlpApplySEWhenNormalHitProcessor.end() != iter )
|
||
m_vlpApplySEWhenNormalHitProcessor.erase( iter );
|
||
}
|
||
#endif
|
||
|
||
|
||
#if defined(_GAMESERVER)
|
||
bool MASkillUser::AddPreFixSystemDefenceSkill(int slotIndex, DnSkillHandle hSkill)
|
||
{
|
||
if (!hSkill)
|
||
{
|
||
RemovePreFixSystemDefenceSkill(slotIndex);
|
||
return false;
|
||
}
|
||
|
||
PREFIX_SYSTEM_SKILLINFO skillInfo;
|
||
skillInfo.slotIndex = slotIndex;
|
||
skillInfo.hSkill = hSkill;
|
||
skillInfo.hSkill->SetItemPrefixSkill();
|
||
|
||
//ÇØ´ç ½ºÅ³ÀÇ È®·ü°ªÀ» °¡Á®¿Â´Ù.
|
||
CDnProbabilityChecker* pProbabilityChecker = static_cast<CDnProbabilityChecker*>(hSkill->GetChecker(IDnSkillUsableChecker::PROB_CHECKER));
|
||
skillInfo.fRatio = pProbabilityChecker ? pProbabilityChecker->GetProbability() : 0.0f;
|
||
|
||
bool bResult = m_prefixSystemDefenceSkills.insert(PREFIX_SYSTEM_SKILL_LIST::value_type(slotIndex, skillInfo)).second;
|
||
|
||
// if (bResult)
|
||
// RefreshPrefixDefenceSkills();
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
AddPrefixDefenceSkill(hSkill);
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
|
||
return bResult;
|
||
}
|
||
|
||
void MASkillUser::RemovePreFixSystemDefenceSkill(int slotIndex)
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemDefenceSkills.find(slotIndex);
|
||
if (iter != m_prefixSystemDefenceSkills.end())
|
||
{
|
||
DnSkillHandle hSkill = iter->second.hSkill;
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
RemovePrefixDefenceSkill(hSkill);
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
|
||
RemoveProcessPrefixDefenceSkill(hSkill);
|
||
|
||
SAFE_RELEASE_SPTR(hSkill);
|
||
m_prefixSystemDefenceSkills.erase(iter);
|
||
|
||
//RefreshPrefixDefenceSkills();
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RemoveProcessPrefixDefenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessPreFixDefenceSkills.begin();
|
||
for( ; iter != m_listProcessPreFixDefenceSkills.end(); )
|
||
{
|
||
DnSkillHandle hProcessPrefixDefenceSkill = *iter;
|
||
if (hProcessPrefixDefenceSkill == hSkill)
|
||
{
|
||
iter = m_listProcessPreFixDefenceSkills.erase(iter);
|
||
continue;
|
||
}
|
||
|
||
++iter;
|
||
}
|
||
}
|
||
|
||
|
||
void MASkillUser::RefreshPrefixDefenceSkills()
|
||
{
|
||
PREFIX_SYSTEM_SKILL_COLLECTION sameSkillList;
|
||
//1. ½½·Ôº°·Î ÀúÀåµÈ ½ºÅ³µéÀ» °°Àº ½ºÅ³³¢¸® ¼öÁýÇÑ´Ù.
|
||
GroupingPrefixDefenceSkillsBySameSkillID(m_prefixSystemDefenceSkills, sameSkillList);
|
||
|
||
PREFIX_SYSTEM_SKILL_LIST tempCandiateDefenceSkills;
|
||
//2. °°Àº ½ºÅ³µé È®·üÀ» ´õÇؼ È®·üÀ» °áÁ¤ÇÏ°í, °°Àº ½ºÅ³Áß ·¹º§ÀÌ ³ôÀº ³à¼®À» ¼±ÅÃÇÑ´Ù.
|
||
CalculateProbabilitySkill(tempCandiateDefenceSkills, sameSkillList);
|
||
|
||
//3. ½ºÅ³IDº°·Î ·¹º§ÀÌ ³ôÀº ³à¼®ÀÇ ¸®½ºÆ®¿¡¼ ½ºÅ³ÀÇ ¿ì¼±¼øÀ§º°·Î ±×·ìÇÎÇÑ´Ù.
|
||
GroupingSkillByPriority(m_PrefixSystemCandiateDefenceSkills, tempCandiateDefenceSkills);
|
||
}
|
||
|
||
bool MASkillUser::AddPreFixSystemOffenceSkill(int slotIndex, DnSkillHandle hSkill)
|
||
{
|
||
if (!hSkill)
|
||
{
|
||
RemovePreFixSystemOffenceSkill(slotIndex);
|
||
return false;
|
||
}
|
||
|
||
PREFIX_SYSTEM_SKILLINFO skillInfo;
|
||
skillInfo.slotIndex = slotIndex;
|
||
skillInfo.hSkill = hSkill;
|
||
skillInfo.hSkill->SetItemPrefixSkill();
|
||
|
||
//ÇØ´ç ½ºÅ³ÀÇ È®·ü°ªÀ» °¡Á®¿Â´Ù.
|
||
CDnProbabilityChecker* pProbabilityChecker = static_cast<CDnProbabilityChecker*>(hSkill->GetChecker(IDnSkillUsableChecker::PROB_CHECKER));
|
||
skillInfo.fRatio = pProbabilityChecker ? pProbabilityChecker->GetProbability() : 0.0f;
|
||
|
||
bool bResult = m_prefixSystemOffenceSkills.insert(PREFIX_SYSTEM_SKILL_LIST::value_type(slotIndex, skillInfo)).second;
|
||
|
||
// if (bResult)
|
||
// RefreshPrefixOffenceSkills();
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
AddPrefixOffenceSkill(hSkill);
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
|
||
return bResult;
|
||
}
|
||
|
||
void MASkillUser::RemovePreFixSystemOffenceSkill(int slotIndex)
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = m_prefixSystemOffenceSkills.begin();
|
||
|
||
for( ; iter != m_prefixSystemOffenceSkills.end(); )
|
||
{
|
||
if( iter->first == slotIndex )
|
||
{
|
||
DnSkillHandle hSkill = iter->second.hSkill;
|
||
hSkill->OnEnd( 0, 0.f );
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
RemovePrefixOffenceSkill(hSkill);
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
|
||
RemoveProcessPrefixOffenceSkill(hSkill);
|
||
|
||
SAFE_RELEASE_SPTR(hSkill);
|
||
iter = m_prefixSystemOffenceSkills.erase(iter);
|
||
continue;
|
||
}
|
||
|
||
++iter;
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RemoveProcessPrefixOffenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessPreFixOffenceSkills.begin();
|
||
for( ; iter != m_listProcessPreFixOffenceSkills.end(); )
|
||
{
|
||
DnSkillHandle hProcessPrefixOffenceSkill = *iter;
|
||
if (hProcessPrefixOffenceSkill == hSkill)
|
||
{
|
||
iter = m_listProcessPreFixOffenceSkills.erase(iter);
|
||
continue;
|
||
}
|
||
|
||
++iter;
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RefreshPrefixOffenceSkills(float fHitDamageProb)
|
||
{
|
||
PREFIX_SYSTEM_SKILL_COLLECTION sameSkillList;
|
||
//1. ½½·Ôº°·Î ÀúÀåµÈ ½ºÅ³µéÀ» °°Àº ½ºÅ³³¢¸® ¼öÁýÇÑ´Ù.
|
||
GroupingPrefixDefenceSkillsBySameSkillID(m_prefixSystemOffenceSkills, sameSkillList);
|
||
|
||
PREFIX_SYSTEM_SKILL_LIST tempCandiateOffenceSkills;
|
||
//2. °°Àº ½ºÅ³µé È®·üÀ» ´õÇؼ È®·üÀ» °áÁ¤ÇÏ°í, °°Àº ½ºÅ³Áß ·¹º§ÀÌ ³ôÀº ³à¼®À» ¼±ÅÃÇÑ´Ù.
|
||
CalculateProbabilitySkill(tempCandiateOffenceSkills, sameSkillList);
|
||
|
||
//3. ½ºÅ³IDº°·Î ·¹º§ÀÌ ³ôÀº ³à¼®ÀÇ ¸®½ºÆ®¿¡¼ ½ºÅ³ÀÇ ¿ì¼±¼øÀ§º°·Î ±×·ìÇÎÇÑ´Ù.
|
||
GroupingSkillByPriority(m_PrefixSystemCandiateOffenceSkills, tempCandiateOffenceSkills, fHitDamageProb);
|
||
}
|
||
|
||
void MASkillUser::ProcessPrefixDefenceSkill(DnActorHandle hHitter)
|
||
{
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ ¹æ¾î¿ë ½ºÅ³ µî·ÏµÇ µÇ¾î ÀÖÁö ¾Ê´Ù¸é
|
||
if (m_prefixSystemDefenceSkills.empty())
|
||
return;
|
||
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³ ½ÃÀÛ-----------------------------!!\n");
|
||
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ ¹æ¾î¿ë ½ºÅ³Áß ¼±ÅÃ..
|
||
RefreshPrefixDefenceSkills();
|
||
|
||
// ÃÖÁ¾ ¸®½ºÆ®¿¡ ´ã±ä ½ºÅ³Áß¿¡¼ ¿ì¼±¼øÀ§°¡ °¡Àå ³ôÀº ¸®½ºÆ®¿¡ ÀúÀåµÈ ½ºÅ³¸¸ »ç¿ëÇÑ´Ù.
|
||
if (m_PrefixSystemCandiateDefenceSkills.empty())
|
||
{
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³ ¼±ÅõȰŠ¾øÀ½.-----------------------------!!\n");
|
||
return;
|
||
}
|
||
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator selectIter = m_PrefixSystemCandiateDefenceSkills.begin();
|
||
PRESIX_SYSTEM_SKILLS &skills = selectIter->second;
|
||
|
||
PRESIX_SYSTEM_SKILLS::iterator iter = skills.begin();
|
||
PRESIX_SYSTEM_SKILLS::iterator endIter = skills.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
DnSkillHandle hSkill = (*iter).hSkill;
|
||
if (!hSkill /*|| CDnSkill::UsingResult::Success != hSkill->CanExecute()*/)
|
||
continue;
|
||
|
||
/*
|
||
//ÄðŸÀÓ ³²¾Æ ÀÖÀ¸¸é °Ç³Ê¶Ü.
|
||
if (hSkill->GetCoolTime() != 0.0f && hSkill->GetElapsedDelayTime() > 0.0f)
|
||
continue;
|
||
*/
|
||
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³(%d) ½ÃÀÛ....\n", hSkill->GetClassID());
|
||
|
||
//Skill ÄðŸÀÓ ½ÃÀÛ?
|
||
hSkill->OnBeginCoolTime();
|
||
m_PrefixSkillCoolTimeManager.AddCoolTime(hSkill);
|
||
|
||
int nStateEffectCount = hSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( DWORD k = 0; k < hSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = hSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
hApplyActor = m_pActor->GetActorHandle();
|
||
break;
|
||
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
hApplyActor = hHitter;
|
||
break;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
if( m_pActor->GetTeam() == hHitter->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hHitter;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
if( m_pActor->GetTeam() != hHitter->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hHitter;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
|
||
//»ç¿ëµÈ ¹æ¾î ½ºÅ³Àº ¸®½ºÆ®¿¡ ´ã¾Æ ³õ´Â´Ù..
|
||
m_listProcessPreFixDefenceSkills.push_back(hSkill);
|
||
}
|
||
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³ ³¡ -----------------------------!!\n");
|
||
}
|
||
|
||
void MASkillUser::ProcessPrefixOffenceSkill(float fHitDamageProb)
|
||
{
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ ¹æ¾î¿ë ½ºÅ³ µî·ÏµÇ µÇ¾î ÀÖÁö ¾Ê´Ù¸é
|
||
if (m_prefixSystemOffenceSkills.empty())
|
||
return;
|
||
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ °ø°Ý¿ë ½ºÅ³Áß ¼±ÅÃ..
|
||
RefreshPrefixOffenceSkills(fHitDamageProb);
|
||
|
||
// ÃÖÁ¾ ¸®½ºÆ®¿¡ ´ã±ä ½ºÅ³Áß¿¡¼ ¿ì¼±¼øÀ§°¡ °¡Àå ³ôÀº ¸®½ºÆ®¿¡ ÀúÀåµÈ ½ºÅ³¸¸ »ç¿ëÇÑ´Ù.
|
||
if (m_PrefixSystemCandiateOffenceSkills.empty())
|
||
return;
|
||
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator selectIter = m_PrefixSystemCandiateOffenceSkills.begin();
|
||
PRESIX_SYSTEM_SKILLS &skills = selectIter->second;
|
||
|
||
PRESIX_SYSTEM_SKILLS::iterator iter = skills.begin();
|
||
PRESIX_SYSTEM_SKILLS::iterator endIter = skills.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
DnSkillHandle hSkill = (*iter).hSkill;
|
||
if (!hSkill/* || CDnSkill::UsingResult::Success != hSkill->CanExecute()*/)
|
||
continue;
|
||
|
||
//Skill ÄðŸÀÓ ½ÃÀÛ?
|
||
hSkill->OnBeginCoolTime();
|
||
m_PrefixSkillCoolTimeManager.AddCoolTime(hSkill);
|
||
|
||
int nStateEffectCount = hSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( DWORD k = 0; k < hSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = hSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
hApplyActor = m_pActor->GetActorHandle();
|
||
break;
|
||
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
continue;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
continue;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
continue;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
|
||
//»ç¿ëµÈ ¹æ¾î ½ºÅ³Àº ¸®½ºÆ®¿¡ ´ã¾Æ ³õ´Â´Ù..
|
||
m_listProcessPreFixOffenceSkills.push_back(hSkill);
|
||
}
|
||
}
|
||
|
||
void MASkillUser::ApplyPrefixOffenceSkillToTarget(DnActorHandle hTarget)
|
||
{
|
||
// ÃÖÁ¾ ¸®½ºÆ®¿¡ ´ã±ä ½ºÅ³Áß¿¡¼ ¿ì¼±¼øÀ§°¡ °¡Àå ³ôÀº ¸®½ºÆ®¿¡ ÀúÀåµÈ ½ºÅ³¸¸ »ç¿ëÇÑ´Ù.
|
||
if (m_listProcessPreFixOffenceSkills.empty())
|
||
return;
|
||
|
||
list<DnSkillHandle>::iterator iter = m_listProcessPreFixOffenceSkills.begin();
|
||
list<DnSkillHandle>::iterator endIter = m_listProcessPreFixOffenceSkills.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
DnSkillHandle hSkill = (*iter);
|
||
if (!hSkill)
|
||
continue;
|
||
|
||
int nStateEffectCount = hSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( DWORD k = 0; k < hSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = hSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
continue;
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
hApplyActor = hTarget;
|
||
break;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
if( m_pActor->GetTeam() == hTarget->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hTarget;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
if( m_pActor->GetTeam() != hTarget->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hTarget;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::CalculateProbabilitySkill(PREFIX_SYSTEM_SKILL_LIST &candidateSkills,
|
||
PREFIX_SYSTEM_SKILL_COLLECTION &sameSkillList)
|
||
{
|
||
//Èĺ¸ ½ºÅ³ ¸®½ºÆ® ÃʱâÈ
|
||
candidateSkills.clear();
|
||
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator iter = sameSkillList.begin();
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator endIter = sameSkillList.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
//°°Àº ½ºÅ³ID¸¦ °¡Áø ½ºÅ³µé È®·üÀ» ÇÕ»êÇÑ´Ù.
|
||
PRESIX_SYSTEM_SKILLS::iterator skillIter = iter->second.begin();
|
||
PRESIX_SYSTEM_SKILLS::iterator skillEndIter = iter->second.end();
|
||
|
||
float fProbability = 0.0f;
|
||
DnSkillHandle hSelectedSkill;
|
||
int nSlotIndex = -1;
|
||
|
||
for (; skillIter != skillEndIter; ++skillIter)
|
||
{
|
||
if (skillIter->hSkill)
|
||
{
|
||
fProbability += skillIter->fRatio;
|
||
|
||
// ÇØ´ç ½ºÅ³
|
||
if (!hSelectedSkill)
|
||
{
|
||
hSelectedSkill = skillIter->hSkill;
|
||
nSlotIndex = skillIter->slotIndex;
|
||
}
|
||
else
|
||
{
|
||
if (hSelectedSkill->GetLevel() < skillIter->hSkill->GetLevel())
|
||
{
|
||
hSelectedSkill = skillIter->hSkill;
|
||
nSlotIndex = skillIter->slotIndex;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ¼±ÅÃµÈ ½ºÅ³ÀÌ ÀÖÀ¸¸é ÃÖÁ¾ ½ºÅ³ Èĺ¸ ¸®½ºÆ®¿¡ Ãß°¡ÇÑ´Ù.
|
||
if (hSelectedSkill && -1 != nSlotIndex && 0.0f != fProbability)
|
||
{
|
||
int nSkillID = hSelectedSkill->GetClassID();
|
||
|
||
PREFIX_SYSTEM_SKILLINFO skillInfo;
|
||
skillInfo.fRatio = fProbability;
|
||
skillInfo.hSkill = hSelectedSkill;
|
||
skillInfo.slotIndex = nSlotIndex;
|
||
|
||
OutputDebug("°°Àº ½ºÅ³(%d) ÇÕ»ê ÃÖÁ¾ È®·ü (%f) ½½·Ô Index(%d)·Î °áÁ¤µÊ!!!!!\n", skillInfo.hSkill->GetClassID(), skillInfo.fRatio, skillInfo.slotIndex);
|
||
|
||
candidateSkills.insert(PREFIX_SYSTEM_SKILL_LIST::value_type(nSkillID, skillInfo));
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::GroupingPrefixDefenceSkillsBySameSkillID(PREFIX_SYSTEM_SKILL_LIST &skillList, PREFIX_SYSTEM_SKILL_COLLECTION &sameSkillList)
|
||
{
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = skillList.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator endIter = skillList.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
int nSkillID = -1;
|
||
int nSlotIndex = iter->first; //½½·Ô À妽º
|
||
|
||
PREFIX_SYSTEM_SKILLINFO skillInfo = iter->second;
|
||
|
||
if (!skillInfo.hSkill)
|
||
continue;
|
||
|
||
nSkillID = skillInfo.hSkill->GetClassID();
|
||
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator findIter = sameSkillList.find(nSkillID);
|
||
|
||
if (findIter != sameSkillList.end())
|
||
{
|
||
//ÀÌ¹Ì °°Àº ½ºÅ³ID¸¦ °¡Áø ½ºÅ³ÀÌ ¸®½ºÆ®¿¡ ÀÖ´Ù¸é
|
||
|
||
|
||
skillInfo.slotIndex = nSlotIndex;
|
||
|
||
findIter->second.push_back(skillInfo);
|
||
}
|
||
else
|
||
{
|
||
//¾ÆÁ÷ ½ºÅ³ µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê´Ù¸é ¸®½ºÆ®¸¦ ¸¸µé¾î µî·Ï..
|
||
PRESIX_SYSTEM_SKILLS skillList;
|
||
|
||
skillInfo.slotIndex = nSlotIndex;
|
||
skillList.push_back(skillInfo);
|
||
|
||
sameSkillList.insert(PREFIX_SYSTEM_SKILL_COLLECTION::value_type(nSkillID, skillList));
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::GroupingSkillByPriority(PREFIX_SYSTEM_SKILL_COLLECTION& prefixSystemSkills, PREFIX_SYSTEM_SKILL_LIST& tempCandiateSkills, float fHitDamageProb/* = 1.0f*/)
|
||
{
|
||
prefixSystemSkills.clear();
|
||
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator iter = tempCandiateSkills.begin();
|
||
PREFIX_SYSTEM_SKILL_LIST::iterator endIter = tempCandiateSkills.end();
|
||
|
||
//´ëÇ¥ ½ºÅ³ ¸®½ºÆ®¸¦ ¼øȸ ÇÏ¸é¼ ¿ì¼± ¼øÀ§º°·Î ±×·ìÇÎÀ» ÇÑ´Ù.
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
int nPriority = 0;
|
||
|
||
PREFIX_SYSTEM_SKILLINFO skillInfo = iter->second;
|
||
|
||
if (!skillInfo.hSkill)
|
||
continue;
|
||
|
||
nPriority = skillInfo.hSkill->GetPrefixSystemPriority();
|
||
|
||
//½ºÅ³ ÄðŸÀÓ È®ÀÎ...
|
||
//if (skillInfo.hSkill->GetCoolTime() > 0.0f && skillInfo.hSkill->GetElapsedDelayTime() > 0.0f)
|
||
if (m_PrefixSkillCoolTimeManager.IsCoolTime(skillInfo.hSkill->GetClassID()))
|
||
{
|
||
OutputDebug("½ºÅ³(%d) ÄðŸÀÓ Áß.........!!!!\n", skillInfo.hSkill->GetClassID());
|
||
continue;
|
||
}
|
||
|
||
//È®·ü°è»ê Çؼ Åë°úµÈ ½ºÅ³¸¸ ¸®½ºÆ®¿¡ Ãß°¡ÇÑ´Ù...
|
||
bool bExecuteable = rand() % 10000 <= (iter->second.fRatio * fHitDamageProb);
|
||
if (!bExecuteable)
|
||
{
|
||
OutputDebug("½ºÅ³(%d) È®·ü¿¡¼ °É·¯Áü...!!!!\n", skillInfo.hSkill->GetClassID());
|
||
continue;
|
||
}
|
||
|
||
OutputDebug("¿ì¼±¼øÀ§ (%d)¿¡ ½ºÅ³(%d) µî·ÏµÊ!!!!\n", nPriority, skillInfo.hSkill->GetClassID());
|
||
|
||
PREFIX_SYSTEM_SKILL_COLLECTION::iterator findIter = prefixSystemSkills.find(nPriority);
|
||
if (findIter != prefixSystemSkills.end())
|
||
{
|
||
//ÀÌ¹Ì ¿ì¼±¼øÀ§ Á¤º¸°¡ µî·Ï µÇ¾î ÀÖ´Ù¸é
|
||
//¿ì¼±¼øÀ§ ¸®½ºÆ®¿¡ ½ºÅ³ Á¤º¸¸¦ Ãß°¡ÇÑ´Ù.
|
||
findIter->second.push_back(skillInfo);
|
||
}
|
||
else
|
||
{
|
||
//¾ÆÁ÷ ¿ì¼±¼øÀ§°¡ µî·ÏÀÌ µÇ¾î ÀÖÁö ¾Ê´Ù¸é..
|
||
//½ºÅ³ ÀúÀåÇÒ ¸®½ºÆ® ¸¸µé°í
|
||
//½ºÅ³ Á¤º¸ ¼³Á¤ Çؼ ¸®½ºÆ®¿¡ Ãß°¡ÇÑ´Ù.
|
||
PRESIX_SYSTEM_SKILLS skillList;
|
||
skillList.push_back(skillInfo);
|
||
|
||
prefixSystemSkills.insert(PREFIX_SYSTEM_SKILL_COLLECTION::value_type(nPriority, skillList));
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void MASkillUser::EndPrefixSystemSkill( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
list<DnSkillHandle>::iterator iter = m_listProcessPreFixDefenceSkills.begin();
|
||
for( iter; iter != m_listProcessPreFixDefenceSkills.end(); ++iter )
|
||
{
|
||
DnSkillHandle hAutoPassive = *iter;
|
||
hAutoPassive->OnEnd( LocalTime, fDelta );
|
||
}
|
||
|
||
iter = m_listProcessPreFixOffenceSkills.begin();
|
||
for( iter; iter != m_listProcessPreFixOffenceSkills.end(); ++iter )
|
||
{
|
||
DnSkillHandle hAutoPassive = *iter;
|
||
hAutoPassive->OnEnd( LocalTime, fDelta );
|
||
}
|
||
}
|
||
|
||
void MASkillUser::InitPrefixOffenceSkills()
|
||
{
|
||
m_PrefixSystemCandiateOffenceSkills.clear();
|
||
}
|
||
|
||
bool MASkillUser::IsPrefixTriggerSkill()
|
||
{
|
||
if (!m_hProcessSkill)
|
||
return false;
|
||
|
||
return m_hProcessSkill->IsPrefixTriggerSkill();
|
||
}
|
||
|
||
#endif // _GAMESERVER
|
||
|
||
|
||
void MASkillUser::UpdateSkillLevelUpInfo()
|
||
{
|
||
std::map<int, SkillLevelUpInfo>::iterator iter = m_SkillLevelUpInfoList.begin();
|
||
std::map<int, SkillLevelUpInfo>::iterator endIter = m_SkillLevelUpInfoList.end();
|
||
|
||
m_SkillLevelUpInfo.clear();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
SkillLevelUpInfo& skillLevelUpInfo = iter->second;
|
||
|
||
//½ºÅ³ ID / ·¹º§¾÷ °ªÀÌ Á¤»óÀ̶ó¸é
|
||
if (skillLevelUpInfo.nSkillID != 0 && skillLevelUpInfo.nLevelUp != 0)
|
||
{
|
||
//½ºÅ³ ·¹º§¾÷ Á¤º¸ ¸®½ºÆ®¿¡¼ °°Àº ½ºÅ³ ¾ÆÀ̵𸦠ã´Â´Ù.
|
||
std::map<int, int>::iterator findIter = m_SkillLevelUpInfo.find(skillLevelUpInfo.nSkillID);
|
||
if (findIter != m_SkillLevelUpInfo.end())
|
||
{
|
||
// ±âÁ¸ ·¹º§¾÷ °ªÀÌ ´õ Å©´Ù¸é °Ç³Ê¶Ü.
|
||
if (findIter->second > skillLevelUpInfo.nLevelUp)
|
||
continue;
|
||
|
||
// ±âÁ¸ ·¹º§¾÷ °ªÀÌ Å©Áö ¾ÊÀ¸¸é ¸®½ºÆ®¿¡¼ Á¦°Å ÇÑ´Ù..
|
||
m_SkillLevelUpInfo.erase(findIter);
|
||
}
|
||
|
||
// »õ·Î¿î ½ºÅ³ ·¹º§¾÷ Á¤º¸¸¦ ÀúÀåÇÑ´Ù.
|
||
m_SkillLevelUpInfo.insert(std::make_pair(skillLevelUpInfo.nSkillID, skillLevelUpInfo.nLevelUp));
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::AddSkillLevelUpInfo(int nSlotIndex, int nSkillID, int nLevelUp)
|
||
{
|
||
DnSkillHandle hSkill = FindSkill(nSkillID);
|
||
if( hSkill )
|
||
{
|
||
if (hSkill->GetElapsedDelayTime() > 0.0f || hSkill->IsToggleOn())
|
||
return;
|
||
}
|
||
|
||
SkillLevelUpInfo skillLevelUpInfo;
|
||
skillLevelUpInfo.nSkillID = nSkillID;
|
||
skillLevelUpInfo.nLevelUp = nLevelUp;
|
||
|
||
m_SkillLevelUpInfoList.insert(std::make_pair(nSlotIndex, skillLevelUpInfo));
|
||
|
||
//½ºÅ³ ·¹º§¾÷ Á¤º¸ °»½Å..
|
||
UpdateSkillLevelUpInfo();
|
||
|
||
int nSkillLevelUp = GetSkillLevelUpValue(nSkillID);
|
||
SkillLevelUp(nSkillID, nSkillLevelUp);
|
||
}
|
||
|
||
void MASkillUser::RemoveSkillLevelUpInfo(int nSlotIndex)
|
||
{
|
||
std::map<int, SkillLevelUpInfo>::iterator findIter = m_SkillLevelUpInfoList.find(nSlotIndex);
|
||
if (findIter != m_SkillLevelUpInfoList.end())
|
||
{
|
||
//Áö¿öÁú ·¹º§¾÷ ¾ÆÀÌÅÛ¿¡ Àû¿ëµÈ ½ºÅ³ ID¸¦ ¹Þ¾Æ ³õ´Â´Ù.
|
||
int nSkillID = findIter->second.nSkillID;
|
||
|
||
DnSkillHandle hSkill = FindSkill(nSkillID);
|
||
if( hSkill )
|
||
{
|
||
if (hSkill->GetElapsedDelayTime() > 0.0f || hSkill->IsToggleOn())
|
||
return;
|
||
}
|
||
|
||
//·¹º§¾÷ Á¤º¸¸¦ ¸®½ºÆ®¿¡¼ Áö¿ì°í
|
||
m_SkillLevelUpInfoList.erase(findIter);
|
||
|
||
//·¹º§¾÷ Á¤º¸ °»½Å
|
||
UpdateSkillLevelUpInfo();
|
||
|
||
//·¹º§¾÷ Á¤º¸°¡ ¾ø¾îÁö¹Ç·Î
|
||
int nLevelUp = GetSkillLevelUpValue(nSkillID);
|
||
SkillLevelUp(nSkillID, nLevelUp);
|
||
}
|
||
}
|
||
|
||
int MASkillUser::GetSkillLevelUpValue(int nSkillID)
|
||
{
|
||
int nLevelUpValue = 0;
|
||
|
||
int nLevelUpValueByNormalItem = 0;
|
||
std::map<int, int>::iterator findNormalIter = m_SkillLevelUpInfo.find(nSkillID);
|
||
if (findNormalIter != m_SkillLevelUpInfo.end())
|
||
nLevelUpValueByNormalItem = findNormalIter->second;
|
||
|
||
int nLevelUpValueByCashItem = 0;
|
||
std::map<int, int>::iterator findCashIter = m_CashSkillLevelUpInfo.find(nSkillID);
|
||
if (findCashIter != m_CashSkillLevelUpInfo.end())
|
||
nLevelUpValueByCashItem = findCashIter->second;
|
||
|
||
//ij½Ã¾ÆÀÌÅÛÀÇ ·¹º§¾÷ Á¦ÇÑ °ªÀº 1
|
||
if (nLevelUpValueByCashItem > 1)
|
||
nLevelUpValueByCashItem = 1;
|
||
|
||
//·¹º§¾÷ ¾ÆÀÌÅÛÀº Áߺ¹ µÇÁö ¾Ê°í, ¼öÂ÷°¡ ³ôÀº °ªÀ» Àû¿ë Çϵµ·Ï ÇÑ´Ù.
|
||
nLevelUpValue = max(nLevelUpValueByNormalItem, nLevelUpValueByCashItem);
|
||
|
||
return nLevelUpValue;
|
||
}
|
||
|
||
bool MASkillUser::ExistSkillLevelUpValue()
|
||
{
|
||
if( m_SkillLevelUpInfo.empty() && m_CashSkillLevelUpInfo.empty() )
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
void MASkillUser::SkillLevelUp(int nSkillID, int nLevelUp)
|
||
{
|
||
//±âÁ¸ ½ºÅ³À» ã¾Æ¼ ½ºÅ³ÀÌ ÀÖ°í, ÃʱâÈ µÈ ½ºÅ³ÀÌ ¾Æ´Ï¸é ·¹º§¾÷ ½ÃŲ´Ù.
|
||
DnSkillHandle hSkill = FindSkill(nSkillID);
|
||
if (!hSkill)
|
||
return;
|
||
|
||
int nCurentSkillLevel = hSkill->GetLevel();
|
||
int nCurLevlUpValue = hSkill->GetLevelUpValue();
|
||
|
||
bool bChangeLevel = true;
|
||
|
||
if (nCurentSkillLevel == 0)
|
||
bChangeLevel = false;
|
||
|
||
//»õ·Î ·¹º§¾÷ ÇÒ ¼öÄ¡¿Í ÇöÀç ·¹º§¾÷ÀÌ Àû¿ëµÈ ¼öÄ¡°¡ °°À¸¸é ½ºÅ³À» º¯°æÇÒ ÇÊ¿ä°¡ ¾øÀ½.
|
||
if (nCurLevlUpValue == nLevelUp)
|
||
bChangeLevel = false;
|
||
|
||
if (bChangeLevel)
|
||
{
|
||
//SetSkillLevel³»ºÎ AddSkill¿¡¼ ¿ø·¡ ·¹º§¿¡ Áö±ÝÀÇ Áõ°¡Ä¡°¡ °è»êµÇ¾î ½ºÅ³ÀÌ »ý¼ºµÊ..
|
||
int nOrigLevel = nCurentSkillLevel - nCurLevlUpValue;
|
||
ChangeSkillLevelUp(nSkillID, nOrigLevel);
|
||
}
|
||
#if defined(_GAMESERVER)
|
||
#else
|
||
else
|
||
hSkill->DisableSkillByItemMove(false);
|
||
#endif // _GAMESERVER
|
||
}
|
||
|
||
void MASkillUser::ChangeSkillLevelUp(int nSkillID, int nOrigLevel)
|
||
{
|
||
RemoveSkill(nSkillID);
|
||
AddSkill(nSkillID, nOrigLevel);
|
||
}
|
||
|
||
|
||
|
||
// std::map<int, SkillLevelUpInfo> m_CashSkillLevelUpInfoList;
|
||
|
||
void MASkillUser::AddSkillLevelUpInfoByCashItem(int nSlotIndex, int nSkillID, int nLevelUp)
|
||
{
|
||
SkillLevelUpInfo skillLevelUpInfo;
|
||
skillLevelUpInfo.nSkillID = nSkillID;
|
||
skillLevelUpInfo.nLevelUp = nLevelUp;
|
||
|
||
m_CashSkillLevelUpInfoList.insert(std::make_pair(nSlotIndex, skillLevelUpInfo));
|
||
|
||
//½ºÅ³ ·¹º§¾÷ Á¤º¸ °»½Å..
|
||
UpdateSkillLevelUpInfoByCashItem();
|
||
|
||
int nSkillLevelUp = GetSkillLevelUpValue(nSkillID);
|
||
SkillLevelUp(nSkillID, nSkillLevelUp);
|
||
}
|
||
|
||
void MASkillUser::UpdateSkillLevelUpInfoByCashItem()
|
||
{
|
||
std::map<int, SkillLevelUpInfo>::iterator iter = m_CashSkillLevelUpInfoList.begin();
|
||
std::map<int, SkillLevelUpInfo>::iterator endIter = m_CashSkillLevelUpInfoList.end();
|
||
|
||
m_CashSkillLevelUpInfo.clear();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
SkillLevelUpInfo& skillLevelUpInfo = iter->second;
|
||
|
||
//½ºÅ³ ID / ·¹º§¾÷ °ªÀÌ Á¤»óÀ̶ó¸é
|
||
if (skillLevelUpInfo.nSkillID != 0 && skillLevelUpInfo.nLevelUp != 0)
|
||
{
|
||
//½ºÅ³ ·¹º§¾÷ Á¤º¸ ¸®½ºÆ®¿¡¼ °°Àº ½ºÅ³ ¾ÆÀ̵𸦠ã´Â´Ù.
|
||
std::map<int, int>::iterator findIter = m_CashSkillLevelUpInfo.find(skillLevelUpInfo.nSkillID);
|
||
if (findIter != m_CashSkillLevelUpInfo.end())
|
||
{
|
||
// ±âÁ¸ ·¹º§¾÷ °ªÀÌ ´õ Å©´Ù¸é °Ç³Ê¶Ü.
|
||
if (findIter->second > skillLevelUpInfo.nLevelUp)
|
||
continue;
|
||
|
||
// ±âÁ¸ ·¹º§¾÷ °ªÀÌ Å©Áö ¾ÊÀ¸¸é ¸®½ºÆ®¿¡¼ Á¦°Å ÇÑ´Ù..
|
||
m_CashSkillLevelUpInfo.erase(findIter);
|
||
}
|
||
|
||
// »õ·Î¿î ½ºÅ³ ·¹º§¾÷ Á¤º¸¸¦ ÀúÀåÇÑ´Ù.
|
||
m_CashSkillLevelUpInfo.insert(std::make_pair(skillLevelUpInfo.nSkillID, skillLevelUpInfo.nLevelUp));
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RemoveSkillLevelUpInfoByCashItem(int nSlotIndex)
|
||
{
|
||
std::map<int, SkillLevelUpInfo>::iterator findIter = m_CashSkillLevelUpInfoList.find(nSlotIndex);
|
||
if (findIter != m_CashSkillLevelUpInfoList.end())
|
||
{
|
||
//Áö¿öÁú ·¹º§¾÷ ¾ÆÀÌÅÛ¿¡ Àû¿ëµÈ ½ºÅ³ ID¸¦ ¹Þ¾Æ ³õ´Â´Ù.
|
||
int nSkillID = findIter->second.nSkillID;
|
||
|
||
//·¹º§¾÷ Á¤º¸¸¦ ¸®½ºÆ®¿¡¼ Áö¿ì°í
|
||
m_CashSkillLevelUpInfoList.erase(findIter);
|
||
|
||
//·¹º§¾÷ Á¤º¸ °»½Å
|
||
UpdateSkillLevelUpInfoByCashItem();
|
||
|
||
//·¹º§¾÷ Á¤º¸°¡ ¾ø¾îÁö¹Ç·Î
|
||
int nLevelUp = GetSkillLevelUpValue(nSkillID);
|
||
SkillLevelUp(nSkillID, nLevelUp);
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
|
||
#if defined(_GAMESERVER)
|
||
void MASkillUser::AddPrefixDefenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
if (!hSkill)
|
||
return;
|
||
|
||
//ÀÌ ½ºÅ³ÀÇ Á¢µÎ»ç ½ºÅ³ ŸÀÔ(Çà¿î/Æı«....)
|
||
int nPrefixSkillType = hSkill->GetPrefixSkillType();
|
||
PREFIX_SKILL_INFO::iterator findIter = m_PrefixDefenceSkills.find(nPrefixSkillType);
|
||
|
||
//±âÁ¸ Ä«Å×°í¸®°¡ ÀÖ´Ù¸é
|
||
if (findIter != m_PrefixDefenceSkills.end())
|
||
{
|
||
//±âÁ¸ Á¢µÎ»ç ½ºÅ³ °ü¸® °´Ã¼¿¡ ½ºÅ³À» Ãß°¡ ÇÏ°í, Á¤º¸¸¦ °»½ÅÇÑ´Ù.
|
||
findIter->second->AddSkill(hSkill);
|
||
}
|
||
else
|
||
{
|
||
//¾ÆÁ÷ µî·ÏµÈ Á¢µÎ»ç ½ºÅ³ÀÌ ¾ø´Ù¸é »õ·Î ¸¸µé¾î¼ µî·Ï ÇÑ´Ù.
|
||
CDnPrefixSkill* pPrefixSkill = new CDnPrefixSkill(nPrefixSkillType);
|
||
pPrefixSkill->AddSkill(hSkill);
|
||
|
||
m_PrefixDefenceSkills.insert(make_pair(nPrefixSkillType, pPrefixSkill));
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RemovePrefixDefenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
//ÀÌ ½ºÅ³ÀÇ Á¢µÎ»ç ½ºÅ³ ŸÀÔ(Çà¿î/Æı«....)
|
||
int nPrefixSkillType = hSkill->GetPrefixSkillType();
|
||
PREFIX_SKILL_INFO::iterator findIter = m_PrefixDefenceSkills.find(nPrefixSkillType);
|
||
|
||
//±âÁ¸ Ä«Å×°í¸®°¡ ÀÖ´Ù¸é
|
||
if (findIter != m_PrefixDefenceSkills.end())
|
||
{
|
||
//±âÁ¸ Á¢µÎ»ç ½ºÅ³ °ü¸® °´Ã¼¿¡¼ ½ºÅ³À» Á¦°Å ÇÑ´Ù.
|
||
findIter->second->RemoveSkill(hSkill);
|
||
|
||
//µî·ÏµÈ ½ºÅ³ÀÌ ¾øÀ¸¸é ¸®½ºÆ®¿¡¼ Á¦°Å ÇÑ´Ù.
|
||
if (findIter->second->GetSkillCount() == 0)
|
||
{
|
||
SAFE_DELETE(findIter->second);
|
||
m_PrefixDefenceSkills.erase(findIter);
|
||
}
|
||
}
|
||
}
|
||
|
||
void MASkillUser::ProcessPrefixDefenceSkill_New(DnActorHandle hHitter)
|
||
{
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ ¹æ¾î¿ë ½ºÅ³ µî·ÏµÇ µÇ¾î ÀÖÁö ¾Ê´Ù¸é
|
||
if (m_PrefixDefenceSkills.empty())
|
||
return;
|
||
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³ ½ÃÀÛ-----------------------------!!\n");
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ ¹ßµ¿ È®·ü °è»ê..
|
||
PREFIX_SKILL_INFO::iterator iter = m_PrefixDefenceSkills.begin();
|
||
PREFIX_SKILL_INFO::iterator endIter = m_PrefixDefenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
CDnPrefixSkill* pPrefixSkill = iter->second;
|
||
if (!pPrefixSkill)
|
||
continue;
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ÀÌ ÄðŸÀÓ ÁßÀÎÁö È®ÀÎÇÑ´Ù..
|
||
if (m_PrefixSkillCoolTimeManager.IsCoolTime(pPrefixSkill->GetSkillType()))
|
||
{
|
||
OutputDebug("Á¢µÎ»ç ¹æ¾î ½ºÅ³(%d) ÄðŸÀÓ Áß!!!!!!!!!!\n", pPrefixSkill->GetSkillType());
|
||
continue;
|
||
}
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ ¹ßµ¿ È®·ü È®ÀÎ.
|
||
bool bExecuteable = rand() % 10000 <= pPrefixSkill->GetProbability();
|
||
if (!bExecuteable)
|
||
{
|
||
OutputDebug("Á¢µÎ»ç ¹æ¾î ½ºÅ³(%d) È®·ü¿¡¼ °É·¯Áü...!!!!\n", pPrefixSkill->GetSkillType());
|
||
continue;
|
||
}
|
||
|
||
//´ëÇ¥ ½ºÅ³
|
||
DnSkillHandle hSkill = pPrefixSkill->GetSkillHandle();
|
||
if (!hSkill)
|
||
continue;
|
||
|
||
hSkill->OnBeginCoolTime();
|
||
//Skill ÄðŸÀÓ ½ÃÀÛ?
|
||
m_PrefixSkillCoolTimeManager.AddCoolTime(pPrefixSkill);
|
||
|
||
int nStateEffectCount = pPrefixSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( int k = 0; k < pPrefixSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = pPrefixSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
hApplyActor = m_pActor->GetActorHandle();
|
||
break;
|
||
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
hApplyActor = hHitter;
|
||
break;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
if( m_pActor->GetTeam() == hHitter->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hHitter;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
if( m_pActor->GetTeam() != hHitter->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hHitter;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
OutputDebug("Á¢µÎ»ç ¹æ¾î ½ºÅ³(%d) »óÅÂÈ¿°ú (%d)-(%s)\n", pPrefixSkill->GetSkillType(), pLocalStruct->nID, pLocalStruct->szValue.c_str());
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
|
||
//»ç¿ëµÈ ¹æ¾î ½ºÅ³Àº ¸®½ºÆ®¿¡ ´ã¾Æ ³õ´Â´Ù..
|
||
m_listProcessPreFixDefenceSkills.push_back(hSkill);
|
||
}
|
||
|
||
OutputDebug("Á¢µÎ¾î ¹æ¾î¿ë ½ºÅ³ ³¡ -----------------------------!!\n");
|
||
}
|
||
|
||
|
||
void MASkillUser::AddPrefixOffenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
if (!hSkill)
|
||
return;
|
||
|
||
//ÀÌ ½ºÅ³ÀÇ Á¢µÎ»ç ½ºÅ³ ŸÀÔ(Çà¿î/Æı«....)
|
||
int nPrefixSkillType = hSkill->GetPrefixSkillType();
|
||
PREFIX_SKILL_INFO::iterator findIter = m_PrefixOffenceSkills.find(nPrefixSkillType);
|
||
|
||
//±âÁ¸ Ä«Å×°í¸®°¡ ÀÖ´Ù¸é
|
||
if (findIter != m_PrefixOffenceSkills.end())
|
||
{
|
||
//±âÁ¸ Á¢µÎ»ç ½ºÅ³ °ü¸® °´Ã¼¿¡ ½ºÅ³À» Ãß°¡ ÇÏ°í, Á¤º¸¸¦ °»½ÅÇÑ´Ù.
|
||
findIter->second->AddSkill(hSkill);
|
||
}
|
||
else
|
||
{
|
||
//¾ÆÁ÷ µî·ÏµÈ Á¢µÎ»ç ½ºÅ³ÀÌ ¾ø´Ù¸é »õ·Î ¸¸µé¾î¼ µî·Ï ÇÑ´Ù.
|
||
CDnPrefixSkill* pPrefixSkill = new CDnPrefixSkill(nPrefixSkillType);
|
||
pPrefixSkill->AddSkill(hSkill);
|
||
|
||
m_PrefixOffenceSkills.insert(make_pair(nPrefixSkillType, pPrefixSkill));
|
||
}
|
||
}
|
||
|
||
void MASkillUser::RemovePrefixOffenceSkill(DnSkillHandle hSkill)
|
||
{
|
||
//ÀÌ ½ºÅ³ÀÇ Á¢µÎ»ç ½ºÅ³ ŸÀÔ(Çà¿î/Æı«....)
|
||
int nPrefixSkillType = hSkill->GetPrefixSkillType();
|
||
PREFIX_SKILL_INFO::iterator findIter = m_PrefixOffenceSkills.find(nPrefixSkillType);
|
||
|
||
//±âÁ¸ Ä«Å×°í¸®°¡ ÀÖ´Ù¸é
|
||
if (findIter != m_PrefixOffenceSkills.end())
|
||
{
|
||
//±âÁ¸ Á¢µÎ»ç ½ºÅ³ °ü¸® °´Ã¼¿¡¼ ½ºÅ³À» Á¦°Å ÇÑ´Ù.
|
||
findIter->second->RemoveSkill(hSkill);
|
||
|
||
//µî·ÏµÈ ½ºÅ³ÀÌ ¾øÀ¸¸é ¸®½ºÆ®¿¡¼ Á¦°Å ÇÑ´Ù.
|
||
if (findIter->second->GetSkillCount() == 0)
|
||
{
|
||
RemoveProcessPrefixOffenceSkill(findIter->second);
|
||
|
||
SAFE_DELETE(findIter->second);
|
||
m_PrefixOffenceSkills.erase(findIter);
|
||
}
|
||
}
|
||
}
|
||
|
||
//´ýÇÁ °ü·ÃÇؼ(ÇÑ ÇÁ·¹ÀÓ¿¡¼ µ¿ÀÛÇؼ ÀÌ·²ÀÏÀº ¾øÀ»µí Çѵ¥..) °ø°Ý¿ë Á¢¹Ì»ç ½ºÅ³ÀÌ Á¦°Å µÉ¶§
|
||
//½ÇÇàµÇ°í ÀÖ´Â Á¢¹Ì»ç ½ºÅ³ ¸®½ºÆ®¿¡ °°Àº ½ºÅ³ÀÌ ÀÖÀ¸¸é Á¦°Å Çϵµ·ÏÇÑ´Ù.
|
||
void MASkillUser::RemoveProcessPrefixOffenceSkill(CDnPrefixSkill* pRemovePrefixSkill)
|
||
{
|
||
if (NULL == pRemovePrefixSkill)
|
||
return;
|
||
|
||
list<CDnPrefixSkill*>::iterator iter = m_ProcessPrefixOffenceSkills.begin();
|
||
|
||
for (; iter != m_ProcessPrefixOffenceSkills.end(); )
|
||
{
|
||
CDnPrefixSkill* pPrefixSkill = (*iter);
|
||
if (pPrefixSkill && pPrefixSkill == pRemovePrefixSkill)
|
||
{
|
||
iter = m_ProcessPrefixOffenceSkills.erase(iter);
|
||
continue;
|
||
}
|
||
|
||
++iter;
|
||
}
|
||
}
|
||
|
||
void MASkillUser::ProcessPrefixOffenceSkill_New()
|
||
{
|
||
//Á¢µÎ¾î ½Ã½ºÅÛ ¹æ¾î¿ë ½ºÅ³ µî·ÏµÇ µÇ¾î ÀÖÁö ¾Ê´Ù¸é
|
||
if (m_PrefixOffenceSkills.empty())
|
||
return;
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ ¹ßµ¿ Àü¿¡ ¸®½ºÆ®¸¦ ºñ¿î´Ù.
|
||
m_ProcessPrefixOffenceSkills.clear();
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ ¹ßµ¿ È®·ü °è»ê..
|
||
PREFIX_SKILL_INFO::iterator iter = m_PrefixOffenceSkills.begin();
|
||
PREFIX_SKILL_INFO::iterator endIter = m_PrefixOffenceSkills.end();
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
CDnPrefixSkill* pPrefixSkill = iter->second;
|
||
if (!pPrefixSkill)
|
||
continue;
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ÀÌ ÄðŸÀÓ ÁßÀÎÁö È®ÀÎÇÑ´Ù..(¹«±â/¹æ¾î±¸ ±¸ºÐÀÌ µÈ´Ù??)
|
||
if (m_PrefixSkillCoolTimeManager.IsCoolTime(pPrefixSkill->GetSkillType()))
|
||
{
|
||
OutputDebug("Á¢µÎ»ç °ø°Ý ½ºÅ³(%d) ÄðŸÀÓ Áß!!!!!!!!!!\n", pPrefixSkill->GetSkillType());
|
||
continue;
|
||
}
|
||
|
||
//Á¢µÎ»ç ½ºÅ³ ¹ßµ¿ È®·ü È®ÀÎ.
|
||
bool bExecuteable = rand() % 10000 <= pPrefixSkill->GetProbability();
|
||
if (!bExecuteable)
|
||
{
|
||
OutputDebug("Á¢µÎ»ç °ø°Ý ½ºÅ³(%d) È®·ü¿¡¼ °É·¯Áü...!!!!\n", pPrefixSkill->GetSkillType());
|
||
continue;
|
||
}
|
||
|
||
//´ëÇ¥ ½ºÅ³
|
||
DnSkillHandle hSkill = pPrefixSkill->GetSkillHandle();
|
||
if (!hSkill)
|
||
continue;
|
||
|
||
//Skill ÄðŸÀÓ ½ÃÀÛ?
|
||
hSkill->OnBeginCoolTime();
|
||
m_PrefixSkillCoolTimeManager.AddCoolTime(pPrefixSkill);
|
||
|
||
int nStateEffectCount = pPrefixSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( int k = 0; k < pPrefixSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = pPrefixSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
hApplyActor = m_pActor->GetActorHandle();
|
||
break;
|
||
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
continue;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
continue;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
continue;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
//
|
||
OutputDebug("Á¢µÎ»ç °ø°Ý ½ºÅ³(%d) »óÅÂÈ¿°ú ÀÚ½ÅÇÑÅ× Àû¿ë (%d)-(%s)\n", pPrefixSkill->GetSkillType(), pLocalStruct->nID, pLocalStruct->szValue.c_str());
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
|
||
//»ç¿ëµÈ ¹æ¾î ½ºÅ³Àº ¸®½ºÆ®¿¡ ´ã¾Æ ³õ´Â´Ù..
|
||
m_listProcessPreFixOffenceSkills.push_back(hSkill);
|
||
|
||
//Áö±Ý ¹ßµ¿µÈ °ø°Ý¿ë Á¢µÎ»ç ½ºÅ³À» ´ã¾Æ ³õ´Â´Ù.
|
||
m_ProcessPrefixOffenceSkills.push_back(pPrefixSkill);
|
||
}
|
||
}
|
||
|
||
void MASkillUser::ApplyPrefixOffenceSkillToTarget_New(DnActorHandle hTarget)
|
||
{
|
||
// ÃÖÁ¾ ¸®½ºÆ®¿¡ ´ã±ä ½ºÅ³Áß¿¡¼ ¿ì¼±¼øÀ§°¡ °¡Àå ³ôÀº ¸®½ºÆ®¿¡ ÀúÀåµÈ ½ºÅ³¸¸ »ç¿ëÇÑ´Ù.
|
||
if (m_ProcessPrefixOffenceSkills.empty())
|
||
return;
|
||
|
||
list<CDnPrefixSkill*>::iterator iter = m_ProcessPrefixOffenceSkills.begin();
|
||
list<CDnPrefixSkill*>::iterator endIter = m_ProcessPrefixOffenceSkills.end();
|
||
|
||
for (; iter != endIter; ++iter)
|
||
{
|
||
CDnPrefixSkill* pPrefixSkill = (*iter);
|
||
if (!pPrefixSkill)
|
||
continue;
|
||
|
||
DnSkillHandle hSkill = pPrefixSkill->GetSkillHandle();
|
||
if (!hSkill)
|
||
continue;
|
||
|
||
int nStateEffectCount = pPrefixSkill->GetStateEffectCount();
|
||
// ÇØ´ç ½ºÅ³ÀÇ »óÅ ȿ°úº° Àû¿ë ¾×Å͸¦ °áÁ¤Çؼ Áߺ¹ ó¸® È®ÀÎÇÏ°í,
|
||
// ¾×Åͺ°·Î »óÅ ȿ°ú Àû¿ëÀ» ÇØ¾ß ÇÒµí Çѵ¥...
|
||
for( int k = 0; k < pPrefixSkill->GetStateEffectCount(); k++ )
|
||
{
|
||
CDnSkill::StateEffectStruct *pLocalStruct = pPrefixSkill->GetStateEffectFromIndex(k);
|
||
|
||
DnActorHandle hApplyActor;
|
||
|
||
// »óÅ ȿ°ú Àû¿ë Ÿ°Ù ŸÀÔ¿¡ µû¶ó Àû¿ëµÉ ¾×Å͸¦ °áÁ¤ÇÑ´Ù.
|
||
switch( pLocalStruct->ApplyType )
|
||
{
|
||
case CDnSkill::ApplySelf: // ÀÚ½ÅÇÑÅ×
|
||
continue;
|
||
case CDnSkill::ApplyTarget: // Ÿ°ÙÇÑÅ×
|
||
hApplyActor = hTarget;
|
||
break;
|
||
|
||
case CDnSkill::ApplyEnemy: // ÀûÇÑÅ×.. (°°Àº ÆíÀÌ ¾Æ´Ï¸é ³ª¸¦ ¶§¸° ³ðÀÌ ÀûÀÌ´Ù..)
|
||
if( m_pActor->GetTeam() == hTarget->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hTarget;
|
||
break;
|
||
|
||
case CDnSkill::ApplyFriend: // °°Àº Æí.. (°°Àº ÆíÀÌ¸é ³ª¸¦ ¶§¸° ³ðÀÌ °°Àº Æí..?)
|
||
if( m_pActor->GetTeam() != hTarget->GetTeam() )
|
||
continue;
|
||
else
|
||
hApplyActor = hTarget;
|
||
break;
|
||
}
|
||
|
||
// »óÅÂÈ¿°úÁß Áö¼Ó ½Ã°£ÀÌ 0ÀÌ°í Àڽſ¡°Ô °Å´Â »óÅ ȿ°ú´Â
|
||
// ½ºÅ³ÀÇ m_vlApplyNoPacketStateEffectList¿¡ ´ã¾Æ ³õ°í ½ºÅ³ ³¡³¯¶§
|
||
// Áö¿ö Áöµµ·Ï ÇÑ´Ù...[2011/01/13 semozz]
|
||
bool isSelfPermentStateEffect = false;
|
||
if (CDnSkill::ApplySelf == pLocalStruct->ApplyType &&
|
||
(0 == pLocalStruct->nDurationTime ||
|
||
-1 == pLocalStruct->nDurationTime))
|
||
{
|
||
pLocalStruct->nDurationTime = -1;
|
||
isSelfPermentStateEffect = true;
|
||
}
|
||
|
||
CDnStateBlow *pStateBlow = hApplyActor->GetStateBlow();
|
||
CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
|
||
|
||
if (pStateBlow)
|
||
eResult = pStateBlow->CanApplySkillStateEffect(hSkill->GetInfo(), *pLocalStruct);
|
||
|
||
if (CDnSkill::CanApply::Fail != eResult)
|
||
{
|
||
hApplyActor->RemoveResetStateBlow();
|
||
|
||
int nBlowID = hApplyActor->CmdAddStateEffect( hSkill->GetInfo(), (STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID,
|
||
pLocalStruct->nDurationTime, pLocalStruct->szValue.c_str(), false, false );
|
||
|
||
OutputDebug("Á¢µÎ»ç °ø°Ý ½ºÅ³(%d) »óÅÂÈ¿°ú »ó´ë¿¡ Àû¿ë (%d)-(%s)\n", pPrefixSkill->GetSkillType(), pLocalStruct->nID, pLocalStruct->szValue.c_str());
|
||
|
||
if (isSelfPermentStateEffect)
|
||
hSkill->AddPrefixBlow(hApplyActor, nBlowID);
|
||
}
|
||
|
||
hApplyActor->InitStateBlowIDToRemove();
|
||
}
|
||
}
|
||
|
||
//´ýÇÁ °ü·Ã ÀÇ½É ÄÚµå Á¤¸®
|
||
//Àû¿ëÇÏ°í ¸®½ºÆ®¸¦ ºñ¿î´Ù..
|
||
m_ProcessPrefixOffenceSkills.clear();
|
||
}
|
||
|
||
#endif // _GAMESERVER
|
||
#endif // PRE_ADD_PREFIX_SYSTE_RENEW
|
||
|
||
|
||
void MASkillUser::SkillToggle(DnSkillHandle hSkill, bool isOn)
|
||
{
|
||
if (!hSkill) return;
|
||
|
||
#if defined(_CLIENT)
|
||
CDnSkill::DurationTypeEnum eDurationType = hSkill->GetDurationType();
|
||
if (eDurationType == CDnSkill::DurationTypeEnum::SummonOnOff)
|
||
{
|
||
hSkill->SummonMonsterOff();
|
||
}
|
||
#endif // _CLIENT
|
||
|
||
int skillID = hSkill->GetClassID();
|
||
TOGGLESKILLLIST::iterator findIter = m_ToggleOnSkillList.find(skillID);
|
||
|
||
if (isOn)
|
||
{
|
||
//ÀÌ¹Ì ½ºÅ³ µî·ÏµÇ¾î ÀÖÀ½..
|
||
if (findIter != m_ToggleOnSkillList.end())
|
||
return;
|
||
|
||
m_ToggleOnSkillList.insert(std::make_pair(skillID, hSkill));
|
||
}
|
||
else
|
||
{
|
||
//µî·ÏµÈ ½ºÅ³ÀÌ ¾ø´Ù¸é
|
||
if (findIter == m_ToggleOnSkillList.end())
|
||
return;
|
||
|
||
m_ToggleOnSkillList.erase(findIter);
|
||
}
|
||
}
|
||
|
||
|
||
void MASkillUser::SummonOnOffSkillInit(DWORD dwSummonMonsterID)
|
||
{
|
||
DNVector(DnSkillHandle) summonOnOffSkills;
|
||
#if defined(PRE_FIX_SKILLLIST)
|
||
for( DWORD i=0; i<m_vlSkillObjects.size(); i++ )
|
||
{
|
||
DnSkillHandle hSkill = m_vlSkillObjects[i].hSkill;
|
||
if (hSkill && hSkill->GetDurationType() == CDnSkill::DurationTypeEnum::SummonOnOff)
|
||
summonOnOffSkills.push_back(hSkill);
|
||
}
|
||
#endif // PRE_FIX_SKILLLIST
|
||
|
||
for (DWORD i =0; i < summonOnOffSkills.size(); ++i)
|
||
{
|
||
DnSkillHandle hSkill = summonOnOffSkills[i];
|
||
if (hSkill && hSkill->GetSummonMonsterID() == dwSummonMonsterID)
|
||
hSkill->EnableToggle(false);
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
|
||
void MASkillUser::UpdateGlobalCoolTime(float fRate)
|
||
{
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
if(m_vlSkillObjects.at( i ).hSkill)
|
||
m_vlSkillObjects.at( i ).hSkill->UpdateGlobalCoolTime(fRate);
|
||
}
|
||
}
|
||
|
||
void MASkillUser::ResetGlobalCoolTime(float fRate)
|
||
{
|
||
for( DWORD i = 0; i < m_vlSkillObjects.size(); ++i )
|
||
{
|
||
if(m_vlSkillObjects.at( i ).hSkill)
|
||
m_vlSkillObjects.at( i ).hSkill->ResetGlobalCoolTime(fRate);
|
||
}
|
||
}
|
||
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
|