7541 lines
223 KiB
C++
7541 lines
223 KiB
C++
|
|
#include <network/IConnection.h>
|
|
#include <mmo/ArRegion.h>
|
|
#include <mmo/ArcadiaServer.h>
|
|
#include <toolkit/XConsole.h>
|
|
#include <toolkit/XQuadScanner.h>
|
|
#include <toolkit/XRandom.h>
|
|
#include <toolkit/XSTLUtil.h>
|
|
#include <toolkit/XEnv.h>
|
|
|
|
#include "ErrorCode/ErrorCode.h"
|
|
#include "LogClient/LogClient.h"
|
|
|
|
#include "StructCreature.h"
|
|
#include "StructPlayer.h" // 흠 ;;
|
|
#include "StructMonster.h" // 냥... ;;
|
|
#include "StructNPC.h"
|
|
#include "StructSkill.h"
|
|
#include "StructSkillProp.h"
|
|
#include "StructSummon.h"
|
|
#include "StructPet.h"
|
|
#include "StructItem.h"
|
|
#include "StructProc.h"
|
|
#include "CreatureBase.h"
|
|
#include "Extern.h"
|
|
#include "GameAllocator.h"
|
|
#include "SendMessage.h"
|
|
#include "GameProc.h"
|
|
#include "GameContent.h"
|
|
#include "GameMessage.h"
|
|
#include "ChannelManager.h"
|
|
#include "GuildManager.h"
|
|
#include "DungeonManager.h"
|
|
#include "PartyManager.h"
|
|
#include "DB_Commands.h"
|
|
#include "HuntaholicManager.h"
|
|
#include "Damage.h"
|
|
|
|
XQuadScanner< StructCreature::QuadTreeItem, AR_UNIT > * g_pQuadScanner = NULL;
|
|
|
|
volatile LONG s_nMaxSkillUID;
|
|
volatile LONG s_nMaxStateUID;
|
|
static std::vector< int > s_vDisabledStateList;
|
|
static XCriticalSection s_csDisabledStateListLock( "s_csDisabledStateListLock" );
|
|
volatile int g_bIgnoreRandomDamage = 0;
|
|
|
|
void StructCreature::InitCreatureSystem()
|
|
{
|
|
if( !g_pQuadScanner )
|
|
g_pQuadScanner = new XQuadScanner< StructCreature::QuadTreeItem, AR_UNIT >( g_nMapWidth, g_nMapHeight );
|
|
}
|
|
|
|
void StructCreature::DeInitCreatureSystem()
|
|
{
|
|
if( g_pQuadScanner )
|
|
{
|
|
delete g_pQuadScanner;
|
|
g_pQuadScanner = NULL;
|
|
}
|
|
}
|
|
|
|
bool StructCreature::QuadTreeItem::IsCanAdd( AR_UNIT x, AR_UNIT y )
|
|
{
|
|
if( g_pQuadScanner )
|
|
return !g_pQuadScanner->IsExist( QuadTreeItem::getX( x ), QuadTreeItem::getY( y ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
void StructCreature::QuadTreeItem::AddMe()
|
|
{
|
|
x = getX( pParent->GetX() );
|
|
y = getX( pParent->GetX() );
|
|
if( g_pQuadScanner )
|
|
g_pQuadScanner->Add( *this );
|
|
}
|
|
|
|
bool StructCreature::QuadTreeItem::RemoveMe()
|
|
{
|
|
if( g_pQuadScanner )
|
|
{
|
|
if( g_pQuadScanner->Remove( *this ) ) return true;
|
|
|
|
// assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int applyPercentageVar( const int & base_var, const int & percentage )
|
|
{
|
|
return base_var * ( ( 100 - percentage ) / 100 ); // 비율적용
|
|
}
|
|
|
|
template <typename T >
|
|
T MIN( const T & lh, const T & rh )
|
|
{
|
|
return lh < rh ? lh : rh;
|
|
}
|
|
|
|
template <typename T >
|
|
T MAX( const T & lh, const T & rh )
|
|
{
|
|
return lh > rh ? lh : rh;
|
|
}
|
|
|
|
StructCreature::StructCreature()
|
|
{
|
|
m_nTotalJobPoint = 0;
|
|
m_nMaxHP = m_nHP = 1;
|
|
m_nMinHP = 0;
|
|
m_fMinHP = 0.0f;
|
|
m_nMaxMP = m_nMP = 1;
|
|
m_nHPDecPart = m_nMPDecPart = 0;
|
|
m_nRegenHP = 0;
|
|
m_nRegenHP = 0;
|
|
|
|
m_nMaxEnergy = 0;
|
|
m_nEnergy = 0;
|
|
m_nEnergyStartPos = 0;
|
|
m_nEnergyUpkeepTime = 0;
|
|
m_nEnergyUnconsumptionRate = 0;
|
|
|
|
memset( m_arEnergy, 0, sizeof( m_arEnergy ) );
|
|
|
|
m_StatusFlag.On( STATUS_FIRST_ENTER );
|
|
m_bNeedToBroadcastStatusFlag = false;
|
|
|
|
quadTreeItem.Set( *this );
|
|
|
|
m_nUnitExpertLevel = 0;
|
|
m_fWeight = 0.0f;
|
|
|
|
m_nNextAttackableTime = 0;
|
|
m_nNextCastableTime = 0;
|
|
m_nDeadTime = GetArTime();
|
|
m_nMovableTime = 0;
|
|
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
m_fBowInterval = 0.0f;
|
|
|
|
m_nCriticalCount = 0;
|
|
|
|
m_nCastKeep = 100;
|
|
|
|
m_fBattleLevel = m_nLevel = m_nMaxReachedLevel = 1;
|
|
|
|
m_nEXP = 0;
|
|
m_nLastDecreasedEXP = 0;
|
|
|
|
m_fEXPMod = 0.0f;
|
|
|
|
m_nJob = 100;
|
|
m_nJobLevel= 0;
|
|
m_nJobPoint= 0;
|
|
|
|
m_fItemMod = 1.0f;
|
|
|
|
m_fHealRatio = 1.0f;
|
|
m_fMPHealRatio = 1.0f;
|
|
m_fHealRatioByItem = 1.0f;
|
|
m_fMPHealRatioByItem = 1.0f;
|
|
m_fHealRatioByRest = 2.0f;
|
|
m_fMPHealRatioByRest = 2.0f;
|
|
|
|
m_nAdditionalHeal = 0;
|
|
m_nAdditionalMPHeal = 0;
|
|
m_nAdditionalHealByItem = 0;
|
|
m_nAdditionalMPHealByItem = 0;
|
|
m_nAdditionalHealByRest = 0;
|
|
m_nAdditionalMPHealByRest = 0;
|
|
|
|
m_fHateRatio = 1.0f;
|
|
|
|
m_nCurrentStateUID = 0;
|
|
m_nPendedClearStateFlag = 0;
|
|
|
|
m_fResistHarmfulState = 0.0f;
|
|
m_mapResistHarmfulState.clear();
|
|
|
|
m_nLastUpdateTime = GetArTime();
|
|
m_nLastStateProcTime = GetArTime();
|
|
|
|
m_hEnemy = 0;
|
|
m_StatusFlag.On( STATUS_FIRST_ATTACK );
|
|
|
|
m_hSkillTarget = NULL;
|
|
m_hTrap = NULL;
|
|
m_pCastSkill = NULL;
|
|
memset( m_anWear, 0, sizeof( m_anWear ) );
|
|
|
|
memset( m_nPrevJobId, 0, sizeof( m_nPrevJobId ) );
|
|
memset( m_nPrevJobLevel, 0, sizeof( m_nPrevJobLevel ) );
|
|
|
|
m_nPendingMoveSpeed = 0;
|
|
|
|
m_fDetectHideRange = 0.0f;
|
|
|
|
m_StatusFlag.On( STATUS_MOVABLE );
|
|
m_StatusFlag.On( STATUS_ATTACKABLE );
|
|
m_StatusFlag.On( STATUS_SKILL_CASTABLE );
|
|
m_StatusFlag.On( STATUS_MAGIC_CASTABLE );
|
|
m_StatusFlag.On( STATUS_ITEM_USABLE );
|
|
m_StatusFlag.On( STATUS_MORTAL );
|
|
|
|
m_StatusFlag.On( STATUS_NEED_TO_CALCULATE_STAT );
|
|
m_nDoubleWeaponMasteryLevel = 0;
|
|
|
|
memset( &m_ParameterForSummon.Stat, 0, sizeof( m_ParameterForSummon.Stat ) );
|
|
memset( &m_ParameterForSummon.Attribute, 0, sizeof( m_ParameterForSummon.Attribute ) );
|
|
memset( &m_ParameterForSummon.Resist, 0, sizeof( m_ParameterForSummon.Resist ) );
|
|
|
|
m_ParameterForSummon.nMaxHP = 0;
|
|
m_ParameterForSummon.nMaxMP = 0;
|
|
m_ParameterForSummon.nMaxSP = 0;
|
|
m_ParameterForSummon.nSPRegenAdd = 0;
|
|
|
|
m_ParameterForSummon.fAttackPointRightWithoutWeapon = 0.0f;
|
|
m_ParameterForSummon.fMoveSpeed = 0.0f;
|
|
m_ParameterForSummon.fAttackRange = 0.0f;
|
|
|
|
m_ParameterForSummon.fMaxHPAmplifier = 0.0f;
|
|
m_ParameterForSummon.fMaxMPAmplifier = 0.0f;
|
|
m_ParameterForSummon.fMaxSPAmplifier = 0.0f;
|
|
m_ParameterForSummon.fSPRegenAddAmplifier = 0.0f;
|
|
|
|
memset( &m_ParameterForSummon.AttributeAmplifier, 0, sizeof( m_ParameterForSummon.AttributeAmplifier ) );
|
|
}
|
|
|
|
StructCreature::~StructCreature()
|
|
{
|
|
// 스킬 정보 삭제
|
|
std::vector< StructSkill * >::iterator it;
|
|
for( it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
// 메모리 풀 사용하도록 변경
|
|
//delete *it;
|
|
(*it)->FreeSkill();
|
|
}
|
|
}
|
|
|
|
int StructCreature::GetJobDepth() const
|
|
{
|
|
const JobInfo* pJobInfo = GameContent::GetJobInfo( GetJobId() );
|
|
return ( pJobInfo ? pJobInfo->job_depth :0 );
|
|
}
|
|
|
|
void StructCreature::SetMaxSkillUID( int nUID )
|
|
{
|
|
s_nMaxSkillUID = nUID;
|
|
}
|
|
|
|
void StructCreature::SetMaxStateUID( int nUID )
|
|
{
|
|
s_nMaxStateUID = nUID;
|
|
}
|
|
|
|
void StructCreature::SetDisabledStateList( std::vector< int > & vDisabledStateList )
|
|
{
|
|
THREAD_SYNCHRONIZE( s_csDisabledStateListLock );
|
|
|
|
s_vDisabledStateList.swap( vDisabledStateList );
|
|
}
|
|
|
|
void StructCreature::AddExp( __int64 exp, __int64 jp, bool bApplyStamina )
|
|
{
|
|
m_nEXP += ( exp );
|
|
m_nJobPoint += jp;
|
|
|
|
if( jp > 0 )
|
|
{
|
|
m_nTotalJobPoint += ( jp );
|
|
}
|
|
|
|
if( IsLoginComplete() )
|
|
onExpChange();
|
|
}
|
|
|
|
void StructCreature::SetEXP( __int64 exp )
|
|
{
|
|
m_nEXP = exp;
|
|
|
|
if( IsLoginComplete() )
|
|
onExpChange();
|
|
}
|
|
|
|
void StructCreature::SetJP( __int64 jp )
|
|
{
|
|
m_nJobPoint = jp;
|
|
|
|
if( m_nJobPoint < 0 )
|
|
m_nJobPoint = 0;
|
|
|
|
if( IsLoginComplete() )
|
|
onJPChange();
|
|
}
|
|
|
|
void StructCreature::regenHPMP( AR_TIME t )
|
|
{
|
|
if( t - m_nLastUpdateTime < 300 )
|
|
return;
|
|
|
|
// 기존의 100초간 리젠량 표기에서 60초간 리젠량으로 파라미터 룰 변경 (2007-03-24 리뉴얼 적용)
|
|
float f_100 = ( t - m_nLastUpdateTime ) / 6000.0f;
|
|
|
|
if( IsAlive() )
|
|
{
|
|
float pt = 0;
|
|
|
|
int prev_hp = GetHP();
|
|
int prev_mp = GetMP();
|
|
|
|
if( !IsMagicalImmune() )
|
|
{
|
|
if( m_Attribute.fHPAdd )
|
|
{
|
|
pt = m_Attribute.fHPAdd * f_100;
|
|
|
|
if( pt < 1 ) pt += 1;
|
|
if( pt ) Heal( pt );
|
|
}
|
|
|
|
if( m_Attribute.fHPAddByItem )
|
|
{
|
|
pt = m_Attribute.fHPAddByItem * f_100;
|
|
|
|
if( pt < 1 ) pt += 1;
|
|
if( pt ) HealByItem( pt );
|
|
}
|
|
|
|
if( m_Attribute.fMPAdd )
|
|
{
|
|
pt = m_Attribute.fMPAdd * f_100;
|
|
|
|
if( pt < 1 ) pt += 1;
|
|
if( pt ) MPHeal( pt );
|
|
}
|
|
|
|
if( m_Attribute.fMPAddByItem )
|
|
{
|
|
pt = m_Attribute.fMPAddByItem * f_100;
|
|
|
|
if( pt < 1 ) pt += 1;
|
|
if( pt ) MPHealByItem( pt );
|
|
}
|
|
}
|
|
|
|
// HP 증가
|
|
if( !isHPRegenStopped() )
|
|
{
|
|
int HPRegenPercentage = GetHPRegenPercentage();
|
|
|
|
if ( IsMonster() )
|
|
{
|
|
StructMonster* pMonster = static_cast< StructMonster * >( this );
|
|
|
|
if ( pMonster->GetMonsterType() >= MonsterBase::MONSTER_TYPE_HIGHEST_1_STAR )
|
|
HPRegenPercentage = GameRule::fMonsterRegenBoss;
|
|
else
|
|
HPRegenPercentage = GameRule::fMonsterRegen;
|
|
}
|
|
|
|
pt = 0;
|
|
pt += HPRegenPercentage * GetMaxHP() * 0.01 * f_100;
|
|
pt += GetHPRegenPoint() * f_100;
|
|
|
|
if( IsSitDown() )
|
|
{
|
|
// 휴식으로 인한 체력 회복 증폭 및 추가 증폭 패시브 적용
|
|
pt *= m_fHealRatioByRest ;
|
|
pt += m_nAdditionalHealByRest ;
|
|
}
|
|
|
|
pt *= m_fHPRegenMod;
|
|
|
|
pt = std::max<float>( pt, 1 );
|
|
pt = std::min<float>( pt, GetMaxHP() - GetHP() );
|
|
|
|
if( pt ) AddHP( pt );
|
|
|
|
// 버려진 소수 자리 누적(소수 둘째 자리 까지)
|
|
m_nHPDecPart += ( pt - (int)pt ) * 100;
|
|
if( m_nHPDecPart / 100 )
|
|
{
|
|
AddHP( m_nHPDecPart / 100 );
|
|
m_nHPDecPart %= 100;
|
|
}
|
|
}
|
|
|
|
// MP 증가
|
|
if( !isMPRegenStopped() )
|
|
{
|
|
pt = 0;
|
|
pt += GetMPRegenPercentage() * GetMaxMP() * 0.01 * f_100;
|
|
pt += GetMPRegenPoint() * f_100;
|
|
|
|
if( IsSitDown() )
|
|
{
|
|
// 휴식으로 인한 마나 회복 증폭 및 추가 증폭 패시브 적용
|
|
pt *= m_fMPHealRatioByRest ;
|
|
}
|
|
|
|
pt *= m_fMPRegenMod;
|
|
|
|
pt = std::max<float>( pt, 1 );
|
|
pt = std::min<float>( pt, GetMaxMP() - GetMP() );
|
|
|
|
if( pt ) AddMP( pt );
|
|
|
|
// 버려진 소수 자리 누적(소수 둘째 자리 까지)
|
|
m_nMPDecPart += ( pt - (int)pt ) * 100;
|
|
if( m_nMPDecPart / 100 )
|
|
{
|
|
AddMP( m_nMPDecPart / 100 );
|
|
m_nMPDecPart %= 100;
|
|
}
|
|
}
|
|
|
|
do
|
|
{
|
|
// 바뀐거 없음 패스
|
|
if( prev_hp == GetHP() && prev_mp == GetMP() )
|
|
break;
|
|
|
|
m_nRegenHP = GetHP() - prev_hp;
|
|
m_nRegenMP = GetMP() - prev_mp;
|
|
|
|
// 만땅 차거나, 3% 이상 변했으면 broadcast
|
|
// AziaMafia Fix HP-MP REGEN
|
|
//Or //if( GetMaxHP() == GetHP() || GetMaxMP() == GetMP() || m_nRegenHP * 100 / GetMaxHP() > 0 || m_nRegenMP * 100 / GetMaxMP() > 0 )
|
|
//Or //if (GetMaxHP() == GetHP() || GetMaxMP() == GetMP() || m_nRegenHP > 0 || m_nRegenMP > 0)
|
|
if (GetMaxHP() == GetHP() || GetMaxMP() == GetMP() || m_nRegenHP * 100 / GetMaxHP() > 0 || m_nRegenMP * 100 / GetMaxMP() > 0)
|
|
{
|
|
|
|
TS_SC_REGEN_HPMP msg;
|
|
|
|
msg.handle = GetHandle();
|
|
msg.hp_regen = m_nRegenHP;
|
|
msg.mp_regen = m_nRegenMP;
|
|
msg.hp = GetHP();
|
|
msg.mp = GetMP();
|
|
|
|
m_nRegenHP = 0;
|
|
m_nRegenMP = 0;
|
|
|
|
if( IsInWorld() )
|
|
{
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
|
|
if( IsSummon() )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructSummon * >( this )->GetMaster();
|
|
if( pPlayer && pPlayer->IsInWorld() && pPlayer->IsLoginComplete() && !pPlayer->GetLogoutTime() )
|
|
{
|
|
PendMessage( pPlayer, &msg );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while( false );
|
|
}
|
|
|
|
m_nLastUpdateTime = t;
|
|
}
|
|
|
|
void StructCreature::RegenFullHPMP()
|
|
{
|
|
int nHP = GetHP();
|
|
int nMP = GetMP();
|
|
|
|
if( nHP == GetMaxHP() && nMP == GetMaxMP() )
|
|
return;
|
|
|
|
SetHP( GetMaxHP() );
|
|
SetMP( GetMaxMP() );
|
|
|
|
TS_SC_REGEN_HPMP msg;
|
|
|
|
msg.handle = GetHandle();
|
|
msg.hp_regen = GetMaxHP() - nHP;
|
|
msg.mp_regen = GetMaxMP() - nMP;
|
|
msg.hp = GetHP();
|
|
msg.mp = GetMP();
|
|
|
|
m_nRegenHP = 0;
|
|
m_nRegenMP = 0;
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
|
|
struct StateDamage
|
|
{
|
|
StateDamage( AR_HANDLE _caster, Elemental::Type _elemental_type, int _base_effect_id, StructState::StateCode _code, unsigned short _level, int _damage_hp, int _damage_mp, bool _final )
|
|
: caster( _caster )
|
|
, elemental_type( _elemental_type )
|
|
, base_effect_id( _base_effect_id )
|
|
, code( _code )
|
|
, level( _level )
|
|
, damage_hp( _damage_hp )
|
|
, damage_mp( _damage_mp )
|
|
, final( _final )
|
|
{}
|
|
|
|
AR_HANDLE caster;
|
|
Elemental::Type elemental_type;
|
|
int base_effect_id;
|
|
StructState::StateCode code;
|
|
unsigned short level;
|
|
int damage_hp;
|
|
int damage_mp;
|
|
bool final;
|
|
};
|
|
|
|
void StructCreature::procState( AR_TIME t )
|
|
{
|
|
STATE_ITERATOR it;
|
|
|
|
// EF_ADD_REGION_STATE 유형 지속효과 처리용
|
|
struct ADD_STATE_INFO
|
|
{
|
|
StructState::StateCode code;
|
|
int nLevel;
|
|
AR_TIME nEndTime;
|
|
int nHate;
|
|
StructCreature * pTarget;
|
|
} add_state_info;
|
|
|
|
// 인스턴스를 보관하는 벡터이므로 Deep copy가 필요한 구조체를 넣으면 안됨
|
|
std::vector< ADD_STATE_INFO > vAddStateInfo;
|
|
|
|
std::vector< StructState > vGoodStateRemover; // 이름 참 구리다...(두 개의 바이올린을 위한 협주곡은 야밤에 들어도 좋구나...)
|
|
std::vector< StructState::StateCode > vGoodStates;
|
|
bool bHasSequantialStateRemover = false; // 지속효과를 제거하는 지속효과가 두개 이상 있을 수 있고, 순서대로 지우는 녀석이 있을 경우 먼저 처리해줘야 하므로...
|
|
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
assert( (*it).GetLastProcessedTime() > 0 );
|
|
|
|
if( (*it).GetEffectType() == StructState::EF_REMOVE_GOOD_STATE )
|
|
{
|
|
AR_TIME nThisFireTime = (*it).GetLastProcessedTime() + (*it).GetFireInterval();
|
|
|
|
if( nThisFireTime >= t || nThisFireTime > (*it).GetEndTime() )
|
|
continue;
|
|
|
|
if( (*it).GetValue( 5 ) == 0 ) // sequantial remover
|
|
{
|
|
bHasSequantialStateRemover = true;
|
|
}
|
|
|
|
vGoodStateRemover.push_back( (*it) );
|
|
}
|
|
else if( !(*it).IsHarmful() && ( (*it).GetTimeType() & StateInfo::ERASE_ON_DEAD ) ) // must not contain remover
|
|
{
|
|
vGoodStates.push_back( (*it).GetCode() );
|
|
}
|
|
|
|
if( (*it).GetEffectType() == StructState::EF_ADD_REGION_STATE )
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
if( (*it).GetLastProcessedTime() + (*it).GetValue(1) * 100 > t )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
(*it).SetLastProcessedTime( t );
|
|
|
|
StructState::StateCode code = static_cast< StructState::StateCode >( (int)(*it).GetValue(0) );
|
|
int nLevel = (*it).GetLevel();
|
|
int nHitRate = (*it).GetValue(8) + nLevel * (*it).GetValue(9);
|
|
AR_TIME end_time = t + ( (*it).GetValue(2) + nLevel * (*it).GetValue(3) ) * 100.0;
|
|
|
|
AR_HANDLE hCaster = (*it).GetCaster();
|
|
if( !hCaster )
|
|
continue;
|
|
|
|
StructCreature *pCaster = static_cast< StructCreature * >( GameObject::raw_get( hCaster ) );
|
|
if( !pCaster )
|
|
continue;
|
|
|
|
if( (*it).GetValue(12) == StructState::USE_TARGET_REGION_TYPE )
|
|
{
|
|
float fEffectLength = (*it).GetValue(4) * GameRule::DEFAULT_UNIT_SIZE;
|
|
int nTargetType = (*it).GetValue(7);
|
|
|
|
std::vector< StructCreature * > vTargetList;
|
|
|
|
EnumSkillTargetsAndCalcDamage( GetCurrentPosition( t ), GetLayer(), GetCurrentPosition( t ), true, fEffectLength, -1, 0, 0, true, pCaster, (*it).GetValue(5), (*it).GetValue(6), vTargetList, false );
|
|
|
|
for( std::vector< StructCreature * >::iterator itTarget = vTargetList.begin() ; itTarget != vTargetList.end() ; ++itTarget )
|
|
{
|
|
StructCreature *pTarget = (*itTarget);
|
|
if( !pTarget || pTarget->IsDead() ) continue;
|
|
|
|
// 효과 대상 1 : 동료 & 중립
|
|
if( nTargetType == 1 && IsEnemy( pTarget, true ) )
|
|
continue;
|
|
|
|
// 효과 대상 2 : 동료
|
|
else if( nTargetType == 2 && !IsAlly( pTarget ) )
|
|
continue;
|
|
|
|
// 효과 대상 3 : 적
|
|
else if( nTargetType == 3 && !IsEnemy( pTarget, true ) )
|
|
continue;
|
|
|
|
// 성공률 체크
|
|
if( nHitRate < XRandom( 0, 99 ) )
|
|
continue;
|
|
|
|
add_state_info.code = code;
|
|
add_state_info.nLevel = nLevel;
|
|
add_state_info.nEndTime = end_time;
|
|
add_state_info.nHate = (*it).GetValue(10) + nLevel * (*it).GetValue(11);
|
|
add_state_info.pTarget = pTarget;
|
|
|
|
vAddStateInfo.push_back( add_state_info );
|
|
}
|
|
}
|
|
else if( (*it).GetValue(12) == StructState::USE_TARGET_OWNER )
|
|
{
|
|
// 성공률 체크
|
|
if( nHitRate < XRandom( 0, 99 ) )
|
|
continue;
|
|
|
|
add_state_info.code = code;
|
|
add_state_info.nLevel = nLevel;
|
|
add_state_info.nEndTime = end_time;
|
|
add_state_info.nHate = (*it).GetValue(10) + nLevel * (*it).GetValue(11);
|
|
add_state_info.pTarget = this;
|
|
|
|
vAddStateInfo.push_back( add_state_info );
|
|
}
|
|
}
|
|
}
|
|
|
|
struct lessGoodStateRemover
|
|
{
|
|
bool operator()(StructState & lh, StructState & rh )
|
|
{
|
|
if( lh.GetValue( 5 ) == 0 && rh.GetValue( 5 ) != 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
if( vGoodStateRemover.size() )
|
|
{
|
|
if( bHasSequantialStateRemover )
|
|
{
|
|
std::sort( vGoodStateRemover.begin(), vGoodStateRemover.end(), lessGoodStateRemover() );
|
|
|
|
std::reverse( vGoodStates.begin(), vGoodStates.end() ); // 뒤에서부터 뽑아야 하니 한번 뒤집어 놓는다.
|
|
}
|
|
|
|
for( std::vector< StructState >::iterator iter = vGoodStateRemover.begin(); iter != vGoodStateRemover.end(); ++iter )
|
|
{
|
|
|
|
if( !vGoodStates.size() || ( (*iter).GetValue( 0 ) + (*iter).GetValue( 1 ) * (*iter).GetLevel() <= XRandom( 0, 99 ) ) )
|
|
break;
|
|
|
|
if( (*iter).GetValue( 5 ) != 0 )
|
|
{
|
|
std::random_shuffle( vGoodStates.begin(), vGoodStates.end() );
|
|
}
|
|
|
|
int nRemoveCount = (*iter).GetValue( 3 ) + (*iter).GetValue( 4 ) * (*iter).GetLevel();
|
|
|
|
for( int i = 0; i < nRemoveCount; ++i )
|
|
{
|
|
if( !vGoodStates.size() )
|
|
break;
|
|
|
|
RemoveState( vGoodStates.back() );
|
|
|
|
vGoodStates.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
// EF_ADD_REGION_STATE 유형 결과 리스트 처리
|
|
if( !vAddStateInfo.empty() )
|
|
{
|
|
for( std::vector< ADD_STATE_INFO >::iterator it = vAddStateInfo.begin() ; it != vAddStateInfo.end() ; ++it )
|
|
{
|
|
if( (*it).pTarget->IsDead() || !(*it).pTarget->IsInWorld() )
|
|
continue;
|
|
|
|
(*it).pTarget->AddState( (*it).code, GetHandle(), (*it).nLevel, t, (*it).nEndTime );
|
|
if( (*it).pTarget->IsMonster() )
|
|
static_cast< StructMonster * >( (*it).pTarget )->AddHate( GetHandle(), (*it).nHate );
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::procStateDamage( AR_TIME t )
|
|
{
|
|
// 직접 DealDamage 를 하면 DealDamage 내부에서 RemoveState() 를 하기도 하기 때문에 낭패.
|
|
// StateDamage는 여기서는 힐의 경우에는 힐량을 데미지로 보관하기도 함.
|
|
std::vector< StateDamage > vDamageList;
|
|
std::vector< StateDamage >::iterator vit;
|
|
|
|
bool bCreatureNeedNormalPriority = false;
|
|
bool bNeedNormalPriority = false;
|
|
|
|
// 뇌기 폭주 처리 필요 여부 조사
|
|
bool bNeedToProcLightningForceCongestion = false;
|
|
|
|
struct ByDeadCreature
|
|
{
|
|
ByDeadCreature( const StructCreature* target ) : target( target ) {}
|
|
const bool operator() ( const StructState& state )
|
|
{
|
|
if( target->IsPlayer() || target->IsSummon() )
|
|
{
|
|
StructCreature::iterator itCaster = StructCreature::get( state.GetCaster() );
|
|
|
|
if( !(*itCaster) &&
|
|
state.IsHarmful() &&
|
|
state.GetCode() != StructState::GAIA_MEMBER_SHIP &&
|
|
state.GetCode() != StructState::NEMESIS &&
|
|
state.GetCode() != StructState::NEMESIS_FOR_AUTO &&
|
|
state.GetCode() != StructState::CARELESSNESS &&
|
|
state.GetCode() != StructState::FALL_FROM_SUMMON )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const StructCreature* target;
|
|
} byDeadCreature( this );
|
|
|
|
RemoveStateIf( byDeadCreature );
|
|
|
|
STATE_ITERATOR it;
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
// 이번에 발동될 시각 미리 계산
|
|
AR_TIME nThisFireTime = (*it).GetLastProcessedTime() + (*it).GetFireInterval();
|
|
|
|
if( nThisFireTime >= t || nThisFireTime > (*it).GetEndTime() )
|
|
continue;
|
|
|
|
// 뇌기 폭주면 처리 필요 플래그 체크
|
|
if( (*it).GetCode() == StructState::LIGHTNING_FORCE_CONGESTION )
|
|
bNeedToProcLightningForceCongestion = true;
|
|
|
|
// 기본 효과가 0이면 데미지를 입히는 효과는 없음
|
|
int nBaseEffectID = (*it).GetBaseEffectID();
|
|
if( !nBaseEffectID )
|
|
continue;
|
|
|
|
bNeedNormalPriority = true;
|
|
|
|
int nDamageHP = 0;
|
|
int nDamageMP = 0;
|
|
Elemental::Type elem = static_cast< Elemental::Type >( (*it).GetElementalType() );
|
|
|
|
switch( nBaseEffectID )
|
|
{
|
|
case StructState::EF_PHYSICAL_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_STATE_DAMAGE:
|
|
case StructState::EF_MAGICAL_STATE_DAMAGE:
|
|
case StructState::EF_MAGICAL_IGNORE_RESIST_STATE_DAMAGE:
|
|
case StructState::EF_HEAL_HP_BY_MAGIC:
|
|
nDamageHP = (*it).GetBaseDamage();
|
|
nDamageHP = nDamageHP * ( (*it).GetAmplifyBase() + (*it).GetAmplifyPerSkillLevel() * (*it).GetLevel() ) + (*it).GetAddDamageBase() + (*it).GetAddDamagePerSkillLevel() * (*it).GetLevel();
|
|
break;
|
|
|
|
case StructState::EF_HEAL_MP_BY_MAGIC:
|
|
nDamageMP = (*it).GetBaseDamage();
|
|
nDamageMP = nDamageMP * ( (*it).GetAmplifyBase() + (*it).GetAmplifyPerSkillLevel() * (*it).GetLevel() ) + (*it).GetAddDamageBase() + (*it).GetAddDamagePerSkillLevel() * (*it).GetLevel();
|
|
break;
|
|
|
|
case StructState::EF_HEAL_HP_BY_ITEM:
|
|
nDamageHP = (*it).GetAddDamageBase() + (*it).GetAddDamagePerSkillLevel() * (*it).GetLevel();
|
|
break;
|
|
|
|
case StructState::EF_HEAL_MP_BY_ITEM:
|
|
nDamageMP = (*it).GetAddDamageBase() + (*it).GetAddDamagePerSkillLevel() * (*it).GetLevel();
|
|
break;
|
|
|
|
case StructState::EF_HEAL_HPMP_BY_ITEM:
|
|
nDamageHP = (*it).GetAddDamageBase() + (*it).GetAddDamagePerSkillLevel() * (*it).GetLevel();
|
|
nDamageMP = nDamageHP;
|
|
break;
|
|
|
|
case StructState::EF_HEAL_HPMP_PER_BY_ITEM:
|
|
nDamageHP = ( (*it).GetValue(0) + (*it).GetValue(1) * (*it).GetLevel() ) * GetMaxHP();
|
|
nDamageMP = ( (*it).GetValue(3) + (*it).GetValue(4) * (*it).GetLevel() ) * GetMaxMP();
|
|
break;
|
|
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_PER_STATE_DAMAGE:
|
|
nDamageHP = ( (*it).GetValue(0) + (*it).GetValue(1) * (*it).GetLevel() ) * GetMaxHP();
|
|
nDamageMP = ( (*it).GetValue(2) + (*it).GetValue(3) * (*it).GetLevel() ) * GetMaxMP();
|
|
break;
|
|
|
|
default:
|
|
assert( 0 );
|
|
continue;
|
|
}
|
|
|
|
if( !nDamageHP && !nDamageMP )
|
|
continue;
|
|
|
|
(*it).SetLastProcessedTime( nThisFireTime );
|
|
|
|
bool bFinal = nThisFireTime + (*it).GetFireInterval() > (*it).GetEndTime();
|
|
|
|
vDamageList.push_back( StateDamage( (*it).GetCaster(), elem, nBaseEffectID, (*it).GetCode(), (*it).GetLevel(), nDamageHP, nDamageMP, bFinal ) );
|
|
}
|
|
|
|
// 데미지/힐을 주는 상태이상이 있을 경우
|
|
if( !vDamageList.empty() )
|
|
{
|
|
// priority가 normal 미만인 경우 normal로 설정(단, 로그아웃을 위해 IDLE이 된 경우에는 제외)
|
|
if( GetFinalPriority() < UPDATE_PRIORITY_HIGH && GetFinalPriority() != UPDATE_PRIORITY_IDLE )
|
|
ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_HIGH );
|
|
}
|
|
|
|
for( vit = vDamageList.begin(); vit != vDamageList.end(); ++vit )
|
|
{
|
|
StructCreature::iterator cit = StructCreature::get( (*vit).caster );
|
|
|
|
switch( (*vit).base_effect_id )
|
|
{
|
|
// HP 데미지 종류는 일단 들어가셈
|
|
case StructState::EF_PHYSICAL_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_STATE_DAMAGE:
|
|
case StructState::EF_MAGICAL_STATE_DAMAGE:
|
|
case StructState::EF_MAGICAL_IGNORE_RESIST_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_PER_STATE_DAMAGE:
|
|
{
|
|
// 데미지류는 캐스터 없으면 제거
|
|
if( !(*cit) )
|
|
{
|
|
RemoveState( (*vit).code );
|
|
continue;
|
|
}
|
|
|
|
int nFlag = 0;
|
|
StructCreature::_DAMAGE damage;
|
|
switch( (*vit).base_effect_id )
|
|
{
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_PER_STATE_DAMAGE:
|
|
nFlag |= IGNORE_DEFENCE;
|
|
case StructState::EF_PHYSICAL_STATE_DAMAGE:
|
|
nFlag |= IGNORE_AVOID | IGNORE_BLOCK;
|
|
|
|
damage = DealPhysicalStateDamage( (*cit), (*vit).damage_hp, (*vit).elemental_type, 0, 0, nFlag, &m_StateStatePenalty );
|
|
break;
|
|
|
|
case StructState::EF_MAGICAL_IGNORE_RESIST_STATE_DAMAGE:
|
|
nFlag |= IGNORE_DEFENCE;
|
|
case StructState::EF_MAGICAL_STATE_DAMAGE:
|
|
nFlag |= IGNORE_BLOCK;
|
|
|
|
damage = DealStateMagicalDamage( (*cit), (*vit).damage_hp, (*vit).elemental_type, 0, 0, nFlag, &m_StateStatePenalty );
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
std::vector< StructState >::iterator it;
|
|
|
|
int total_damage = 0;
|
|
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
if( (*it).GetCode() == (*vit).code )
|
|
{
|
|
(*it).AddTotalDamage( damage.nDamage );
|
|
total_damage = (*it).GetTotalDamage();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
TS_SC_STATE_RESULT msg;
|
|
|
|
msg.result_type = TS_SC_STATE_RESULT::STATE_DAMAGE_HP;
|
|
msg.target_value = GetHP();
|
|
|
|
msg.caster_handle = (*vit).caster;
|
|
msg.target_handle = GetHandle();
|
|
|
|
msg.code = (*vit).code;
|
|
msg.level = (*vit).level;
|
|
msg.value = damage.nDamage;
|
|
msg.final = (*vit).final;
|
|
msg.total_amount = total_damage;
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
break;
|
|
|
|
case StructState::EF_HEAL_HP_BY_MAGIC:
|
|
case StructState::EF_HEAL_MP_BY_MAGIC:
|
|
case StructState::EF_HEAL_HP_BY_ITEM:
|
|
case StructState::EF_HEAL_MP_BY_ITEM:
|
|
case StructState::EF_HEAL_HPMP_BY_ITEM:
|
|
case StructState::EF_HEAL_HPMP_PER_BY_ITEM:
|
|
{
|
|
int nHealHP = 0;
|
|
int nHealMP = 0;
|
|
|
|
if( IsDead() ) // 죽은 상태에서 힐이 들어갈 여지가 있음
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( (*vit).base_effect_id == StructState::EF_HEAL_HP_BY_MAGIC )
|
|
{
|
|
nHealHP = Heal( (*vit).damage_hp );
|
|
}
|
|
else if( (*vit).base_effect_id == StructState::EF_HEAL_MP_BY_MAGIC )
|
|
{
|
|
nHealMP = MPHeal( (*vit).damage_mp );
|
|
}
|
|
else if( (*vit).base_effect_id == StructState::EF_HEAL_HP_BY_ITEM )
|
|
{
|
|
nHealHP = HealByItem( (*vit).damage_hp );
|
|
}
|
|
else if( (*vit).base_effect_id == StructState::EF_HEAL_MP_BY_ITEM )
|
|
{
|
|
nHealMP = MPHealByItem( (*vit).damage_mp );
|
|
}
|
|
else if( (*vit).base_effect_id == StructState::EF_HEAL_HPMP_BY_ITEM ||
|
|
(*vit).base_effect_id == StructState::EF_HEAL_HPMP_PER_BY_ITEM )
|
|
{
|
|
nHealHP = HealByItem( (*vit).damage_hp );
|
|
nHealMP = MPHealByItem( (*vit).damage_mp );
|
|
}
|
|
else
|
|
assert( 0 ); // -┏;? 뉘쇼?
|
|
|
|
TS_SC_STATE_RESULT msg;
|
|
|
|
int total_heal = 0;
|
|
std::vector< StructState >::iterator it;
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
if( (*it).GetCode() == (*vit).code )
|
|
{
|
|
if( nHealHP )
|
|
{
|
|
(*it).AddTotalDamage( nHealHP );
|
|
}
|
|
else if( nHealMP )
|
|
{
|
|
(*it).AddTotalDamage( nHealMP );
|
|
}
|
|
total_heal = (*it).GetTotalDamage();
|
|
break;
|
|
}
|
|
}
|
|
|
|
msg.caster_handle = (*vit).caster;
|
|
msg.target_handle = GetHandle();
|
|
|
|
msg.code = (*vit).code;
|
|
msg.level = (*vit).level;
|
|
|
|
msg.final = (*vit).final;
|
|
|
|
if( nHealHP )
|
|
{
|
|
msg.total_amount = total_heal;
|
|
msg.value = nHealHP;
|
|
msg.target_value = GetHP();
|
|
msg.result_type = TS_SC_STATE_RESULT::STATE_HEAL_HP;
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
|
|
if( nHealMP )
|
|
{
|
|
// HP, MP 모두 차는 건 MP 메시지에는 total을 0으로,
|
|
// MP만 차는 건 MP 메시지라도 total을 계산해서 보냄
|
|
if( msg.total_amount )
|
|
msg.total_amount = 0;
|
|
else
|
|
msg.total_amount = total_heal;
|
|
|
|
msg.value = nHealMP;
|
|
msg.target_value = GetMP();
|
|
msg.result_type = TS_SC_STATE_RESULT::STATE_HEAL_MP;
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 뇌기 폭주 처리
|
|
if( bNeedToProcLightningForceCongestion )
|
|
{
|
|
do
|
|
{
|
|
StructState *pState = GetState( StructState::LIGHTNING_FORCE_CONGESTION );
|
|
if( !pState )
|
|
break;
|
|
|
|
StructCreature::iterator itCaster = StructCreature::get( pState->GetCaster() );
|
|
int damage_hp = pState->GetValue(6) + pState->GetLevel() * pState->GetValue(7);
|
|
int damage_mp = pState->GetValue(8) + pState->GetLevel() * pState->GetValue(9);
|
|
|
|
if( !(*itCaster) || GetHP() < damage_hp || GetMP() < damage_mp )
|
|
{
|
|
RemoveState( pState->GetCode() );
|
|
break;
|
|
}
|
|
|
|
AR_TIME nThisFireTime = pState->GetLastProcessedTime() + pState->GetFireInterval();
|
|
|
|
TS_SC_STATE_RESULT msg;
|
|
|
|
msg.caster_handle = pState->GetCaster();
|
|
msg.target_handle = GetHandle();
|
|
msg.final = nThisFireTime + pState->GetFireInterval() > pState->GetEndTime();
|
|
msg.code = StructState::LIGHTNING_FORCE_CONGESTION;
|
|
msg.level = pState->GetLevel();
|
|
|
|
pState->SetLastProcessedTime( nThisFireTime );
|
|
|
|
if( damage_hp )
|
|
{
|
|
StructCreature::_DAMAGE damage = DealPhysicalStateDamage( (*itCaster), damage_hp, static_cast< Elemental::Type >( pState->GetElementalType() ), 0, 0, 0, &m_StateStatePenalty );
|
|
if( damage.nDamage )
|
|
{
|
|
pState->AddTotalDamage( damage.nDamage );
|
|
|
|
msg.value = damage.nDamage;
|
|
msg.target_value = GetHP();
|
|
msg.result_type = TS_SC_STATE_RESULT::STATE_DAMAGE_HP;
|
|
msg.total_amount = pState->GetTotalDamage();
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
}
|
|
|
|
if( damage_mp )
|
|
{
|
|
AddMP( -damage_mp );
|
|
|
|
msg.value = damage_mp;
|
|
msg.target_value = GetMP();
|
|
msg.result_type = TS_SC_STATE_RESULT::STATE_DAMAGE_MP;
|
|
msg.total_amount = damage_mp;
|
|
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
|
|
}
|
|
|
|
} while( false );
|
|
}
|
|
}
|
|
|
|
void StructCreature::OnUpdate()
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
assert( !IsInWorld() || ArcadiaServer::Instance().IsLocked( this ) );
|
|
|
|
if( isNeedToCalculateStat() )
|
|
{
|
|
CalculateStat();
|
|
m_StatusFlag.Off( STATUS_NEED_TO_CALCULATE_STAT );
|
|
}
|
|
|
|
// { energy process
|
|
int nEnergyCnt = GetEnergyCount();
|
|
if( nEnergyCnt )
|
|
{
|
|
int pos, cnt;
|
|
|
|
cnt = 0;
|
|
|
|
for( pos = m_nEnergyStartPos; m_arEnergy[pos] < t; pos = ++pos % GameRule::ENERGY_MAX )
|
|
{
|
|
if( !m_arEnergy[pos] || cnt == nEnergyCnt )
|
|
break;
|
|
|
|
++cnt;
|
|
}
|
|
|
|
if( cnt )
|
|
RemoveEnergy( cnt );
|
|
}
|
|
// } energy process
|
|
|
|
regenHPMP( t );
|
|
|
|
// 장비로 인해 지속적으로 거는 지속 효과 적용
|
|
// 동작 방식으로 보아 유사 오오라로 취급. 단, 오오라와 같이 주변에 대상에게도 지속효과를 건다면 AddState를 직접 호출해서는 안 됨
|
|
if( m_vPendStateListByItem.size() > 0 )
|
|
{
|
|
// m_vPendStateListByItem는 AddState 안에서 CalculateStat을 호출하면 초기화되었다가 다시 세팅되는데,
|
|
// 대개는 해당 벡터의 내용이 그대로 다시 채워지기 때문에 문제가 없지만 vector 순회 중에 포함된 데이터가 변경되는 건
|
|
// 위험한 상태이기 때문에 m_vPendStateListByItem를 복사한 vPendStateListByItem를 만들어서 순회함
|
|
// * AddState가 반드시 호출된다는 보장도 없고, 호출되더라도 CalculateStat이 호출되지 않는 경우도 있기 때문에
|
|
// m_vPendStateListByItem와 vPendStateListByItem를 swap 시키거나 m_vPendStateListByItem.clear()를 쓰면 안 됨(다음번 OnUpdate에서 바보됨)
|
|
std::vector< std::pair< AR_TIME, StructState > > vPendStateListByItem( m_vPendStateListByItem );
|
|
|
|
for( std::vector< std::pair< AR_TIME, StructState > >::iterator it = vPendStateListByItem.begin(); it != vPendStateListByItem.end(); ++it )
|
|
{
|
|
StructState & State = (*it).second;
|
|
|
|
if( (*it).first + SkillBase::TOGGLE_REFRESH_TIME <= t )
|
|
{
|
|
AddState( State.GetCode(), State.GetCaster(), State.GetLevel(), t, t + State.GetEndTime() - State.GetStartTime(), State.IsAura(), State.GetStateValue(), State.GetStateStringValue(), State.IsByEvent() );
|
|
(*it).first = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 오오라 적용
|
|
if( m_vAura.size() > 0 )
|
|
{
|
|
std::vector< std::pair<StructSkill *, int> >::iterator it;
|
|
for( it = m_vAura.begin(); it != m_vAura.end(); )
|
|
{
|
|
if( (*it).first->GetAuraRefreshTime() + SkillBase::TOGGLE_REFRESH_TIME <= t )
|
|
{
|
|
if( !onProcAura( (*it).first, (*it).second ) )
|
|
{
|
|
TS_SC_AURA msg;
|
|
|
|
msg.caster = GetHandle();
|
|
msg.skill_id = (*it).first->GetSkillId();
|
|
|
|
msg.status = false;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
PendMessage( this, &msg );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
StructSummon * pSummon = static_cast< StructSummon * >( this );
|
|
if( pSummon->GetMaster() && pSummon->IsInWorld() )
|
|
PendMessage( pSummon->GetMaster(), &msg );
|
|
}
|
|
|
|
it = m_vAura.erase( it );
|
|
continue;
|
|
}
|
|
(*it).first->SetAuraRefreshTime( t );
|
|
}
|
|
|
|
++it;
|
|
}
|
|
}
|
|
|
|
// 이하는 월드에 있을 때만 처리되어야 하는 내용들(방송을 동반하므로 -_ -)
|
|
if( !IsInWorld() )
|
|
return;
|
|
|
|
if( m_nPendedClearStateFlag )
|
|
{
|
|
int nClearStateFlag = m_nPendedClearStateFlag;
|
|
m_nPendedClearStateFlag = 0;
|
|
|
|
removeStateWithFlag( nClearStateFlag );
|
|
}
|
|
|
|
if( m_vStateList.size() && ClearExpiredState( t ) )
|
|
{
|
|
CalculateStat();
|
|
}
|
|
|
|
if( IsFeared() && ( !IsMoving( GetArTime() ) || !isFearMoving() ) )
|
|
{
|
|
StructState * pState = GetState( StructState::FEAR );
|
|
|
|
if( pState )
|
|
{
|
|
int nMoveSpeedAdd = pState->GetValue( 1 );
|
|
|
|
ArPosition newPos;
|
|
|
|
float theta = ( XRandom() % 628 ) / 100.0f;
|
|
|
|
newPos.x = GetX() + sin( theta ) * 120;
|
|
newPos.y = GetY() + cos( theta ) * 120;
|
|
|
|
if( !isFearMoving() )
|
|
{
|
|
m_StatusFlag.On( STATUS_MOVING_BY_FEAR );
|
|
|
|
AR_HANDLE hCaster = pState->GetCaster();
|
|
StructCreature::iterator itCaster = StructCreature::get( hCaster );
|
|
StructCreature * pCaster = (*itCaster);
|
|
if( pCaster )
|
|
{
|
|
ArPosition caster_pos = pCaster->GetPos();
|
|
ArPosition my_pos = GetCurrentPosition( GetArTime() );
|
|
AR_UNIT distance = my_pos.GetDistance( caster_pos );
|
|
|
|
if( distance > 0 )
|
|
{
|
|
newPos.x = my_pos.x + ( caster_pos.x - my_pos.x ) * 120 / distance;
|
|
newPos.y = my_pos.y + ( caster_pos.y - my_pos.y ) * 120 / distance;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( newPos.x > g_nMapWidth ) newPos.x = g_nMapWidth;
|
|
if( newPos.y > g_nMapWidth ) newPos.y = g_nMapWidth;
|
|
if( newPos.x < 0 ) newPos.x = 0;
|
|
if( newPos.y < 0 ) newPos.y = 0;
|
|
|
|
if( GameRule::bMonsterCollisionToLine == false || GameContent::CollisionToLine( GetX(), GetY(), newPos.x, newPos.y ) == false )
|
|
{
|
|
if( IsInWorld() && GetRealMoveSpeed() )
|
|
{
|
|
ArcadiaServer::Instance().SetMove( this, GetPos(), newPos, GetRealMoveSpeed() + nMoveSpeedAdd / 7, true, GetArTime() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( IsNeedToBroadcastStatusFlag() )
|
|
{
|
|
SetNeedToBroadcastStatusFlag( false );
|
|
BroadcastStatusMessage( this );
|
|
}
|
|
}
|
|
|
|
bool StructCreature::onProcAura( struct StructSkill *pSkill, int nRequestedSkillLevel )
|
|
{
|
|
pSkill->SetRequestedSkillLevel( nRequestedSkillLevel );
|
|
bool ret = pSkill->ProcAura();
|
|
pSkill->SetRequestedSkillLevel( 0 );
|
|
|
|
return ret;
|
|
}
|
|
|
|
StructState * StructCreature::GetState( StructState::StateCode code )
|
|
{
|
|
StructState * pRtn = NULL;
|
|
|
|
STATE_ITERATOR it;
|
|
for( it = m_vStateList.begin() ; it != m_vStateList.end() ; ++it )
|
|
{
|
|
if( (*it).GetCode() == code ) return &(*it);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const StructState * StructCreature::GetState( StructState::StateCode code ) const
|
|
{
|
|
StructState * pRtn = NULL;
|
|
|
|
STATE_CONST_ITERATOR it;
|
|
for( it = m_vStateList.begin() ; it != m_vStateList.end() ; ++it )
|
|
{
|
|
if( (*it).GetCode() == code ) return &(*it);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int StructCreature::AllocStateUID( int & nDBEnable )
|
|
{
|
|
int nUID = 0;
|
|
|
|
if( s_vDisabledStateList.size() )
|
|
{
|
|
THREAD_SYNCHRONIZE( s_csDisabledStateListLock );
|
|
|
|
if( s_vDisabledStateList.size() )
|
|
{
|
|
// 사용한 UID가 재사용되도록 유도하기 위해 위해 반환된 값을 먼저 사용한다.
|
|
// UID가 재사용될 수 있다는 것은 현재 DB의 Enable 값이 false라는 의미이다.
|
|
nUID = s_vDisabledStateList.back();
|
|
nDBEnable = StructState::UNUSED_IN_DB;
|
|
|
|
s_vDisabledStateList.pop_back();
|
|
|
|
return nUID;
|
|
}
|
|
}
|
|
|
|
nUID = InterlockedIncrement( &s_nMaxStateUID );
|
|
nDBEnable = StructState::NOT_IN_DB;
|
|
|
|
return nUID;
|
|
}
|
|
|
|
void StructCreature::DeallocStateUID( const int nUID )
|
|
{
|
|
#ifdef _DEBUG
|
|
if( nUID <= 0 )
|
|
{
|
|
assert( 0 );
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
THREAD_SYNCHRONIZE( s_csDisabledStateListLock );
|
|
|
|
s_vDisabledStateList.push_back( nUID );
|
|
}
|
|
|
|
unsigned short StructCreature::AddState( StructState::StateCode code, AR_HANDLE caster, int level, AR_TIME start_time, AR_TIME end_time, bool bIsAura, int nStateValue, const char * szStateValue, const bool bByEvent, const int nAllocatedUID, int nDBEnable )
|
|
{
|
|
SetNeedToUpdateState( true );
|
|
// 사망시 사라지지 않는 효과는 죽은채로도 걸 수 있도록 변경
|
|
// 사망 상태에서 접속시 더블 플러스, 무한 스테 세이버 효과를 받지 못 하는 문제가 있었음. 2007-05-18
|
|
//if( IsDead() )
|
|
// return RESULT_NOT_ACTABLE;
|
|
|
|
const StateInfo * pStateInfo = GameContent::GetStateInfo( code );
|
|
|
|
if( !pStateInfo )
|
|
{
|
|
GameObject *pObj = GameObject::raw_get( caster );
|
|
if( pObj && pObj->IsPlayer() && static_cast< StructPlayer * >(pObj)->pConnection )
|
|
{
|
|
static_cast< StructPlayer * >(pObj)->pConnection->Close();
|
|
}
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
// 지속 효과 적용 대상 플래그 체크
|
|
// ( 우선 현재 지속효과는 플레이어, 몬스터, 소환수에게만 가능하다. )
|
|
if( !( pStateInfo->uf_avatar && IsPlayer() ) &&
|
|
!( pStateInfo->uf_monster && IsMonster() ) &&
|
|
!( pStateInfo->uf_summon && IsSummon() ) )
|
|
return RESULT_ACCESS_DENIED;
|
|
|
|
STATE_ITERATOR it;
|
|
|
|
// 플레이어일 경우 체크되는 조건 검사(이벤트에 의한 강제 지속효과의 경우 체크 안 함)
|
|
if( IsPlayer() && !bByEvent )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
// 데스매치에서 제한된 지속효과는 걸 수 없음
|
|
if( pPlayer->IsInDeathmatch() && pStateInfo->state_time_type & StateInfo::NOT_ACTABLE_ON_DEATHMATCH )
|
|
{
|
|
return RESULT_NOT_ACTABLE_IN_DEATHMATCH;
|
|
}
|
|
|
|
if( pPlayer->IsInStartedCompete( true ) && pStateInfo->state_time_type & StateInfo::NOT_ACTABLE_IN_COMPETE )
|
|
{
|
|
return RESULT_NOT_IN_COMPETE;
|
|
}
|
|
}
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
//if( IsDead() && ( pStateInfo->state_time_type & StateInfo::ERASE_ON_DEAD || pStateInfo->state_time_type & StateInfo::ERASE_ON_RESURRECT ) && !bByEvent )
|
|
if (IsDead() && (pStateInfo->state_time_type & StateInfo::ERASE_ON_DEAD) && !bByEvent)
|
|
{
|
|
return RESULT_ACCESS_DENIED;
|
|
}
|
|
|
|
// 일어설 때 사라지는 효과는 일어선 대상에게 걸 수 없음(이벤트에 의한 강제 지속효과의 경우 체크 안 함)
|
|
if( !IsSitDown() && ( pStateInfo->state_time_type & StateInfo::ERASE_ON_STAND_UP ) && !bByEvent )
|
|
{
|
|
return RESULT_NOT_ACTABLE_ON_STAND_UP;
|
|
}
|
|
|
|
if( IsMonster() )
|
|
{
|
|
StructMonster * pMonster = static_cast< StructMonster * >( this );
|
|
|
|
// state_time_type is also used to determine whether it is an un-usable persistent effect on bosses. Might need renaming
|
|
if( ( pStateInfo->state_time_type & StateInfo::NOT_ACTABLE_TO_BOSS ) && pMonster->IsBossMonster() && !GameRule::nBossEffect )
|
|
{
|
|
return RESULT_LIMIT_TARGET;
|
|
}
|
|
|
|
// 던전 코어, 오토 트랩은 공포에 걸리지 않아야 함(돌아댕기면 이상하니까...)
|
|
if( code == StructState::FEAR && ( pMonster->IsDungeonConnector() || pMonster->IsAutoTrap() ) )
|
|
{
|
|
return RESULT_LIMIT_TARGET;
|
|
}
|
|
|
|
if( pMonster->IsRunaway() )
|
|
{
|
|
return RESULT_LIMIT_TARGET;
|
|
}
|
|
}
|
|
|
|
// 지속효과가 행동 불능을 야기시키는 경우 스킬 캔슬, 탑승 크리처에서 떨어짐
|
|
if( code == StructState::SLEEP || code == StructState::NIGHTMARE || code == StructState::SEAL ||
|
|
code == StructState::SHINE_WALL || code == StructState::FEAR || code == StructState::STUN ||
|
|
// AziaMafia Transformation bug pStateInfo->effect_type == StructState::EF_TRANSFORMATION ||
|
|
( pStateInfo->effect_type == StructState::EF_MEZZ && ( pStateInfo->fValue[0] || pStateInfo->fValue[1] || pStateInfo->fValue[2] || pStateInfo->fValue[3] ) ) )
|
|
{
|
|
if( IsUsingSkill() )
|
|
CancelSkill();
|
|
|
|
// 자신이 크리처 탑승 상태의 플레이어 혹은 플레이어를 태운 소환수였으면 낙상 처리
|
|
StructPlayer * pThisPlayer = NULL;
|
|
|
|
if( IsPlayer() )
|
|
pThisPlayer = static_cast< StructPlayer * >( this );
|
|
else if( IsSummon() )
|
|
{
|
|
pThisPlayer = static_cast< StructSummon * >( this )->GetMaster();
|
|
|
|
// 탑승 상태이긴 했는데 얻어맞은 소환수가 아닌 다른 놈을 탑승 중이었으면 낙상 처리 안 함
|
|
if( pThisPlayer && pThisPlayer->GetRideObject() != this )
|
|
pThisPlayer = NULL;
|
|
}
|
|
|
|
if( pThisPlayer )
|
|
{
|
|
// 행동 불능 지속효과를 건 주체가 낙상을 유발한 것으로 처리(데미지가 들어가야 하기 때문)
|
|
StructCreature::iterator itCaster = StructCreature::get( caster );
|
|
StructCreature * pCaster = (*itCaster);
|
|
|
|
// 행동 불능 지속효과를 건 주체가 없으면 낙상 처리 안 함(몬스터나 자신이어도 괜찮음. 아예 없지만 않으면 됨)
|
|
if( pCaster )
|
|
{
|
|
if( pThisPlayer )
|
|
{
|
|
if( pThisPlayer->IsRiding() || pThisPlayer->HasRidingState() )
|
|
{
|
|
pThisPlayer->UnMount( StructPlayer::UNMOUNT_FALL, pCaster );
|
|
|
|
// 낙상 발생 후 사망 가능. 사망시 사라지는 효과는 시체한테는 걸 수 없음(이벤트에 의한 강제 지속효과의 경우 체크 안 함)
|
|
if( IsDead() && ( pStateInfo->state_time_type & StateInfo::ERASE_ON_DEAD || pStateInfo->state_time_type & StateInfo::ERASE_ON_RESURRECT ) && !bByEvent )
|
|
{
|
|
return RESULT_ACCESS_DENIED;
|
|
}
|
|
}
|
|
else if( pThisPlayer->IsSitDown() )
|
|
{
|
|
pThisPlayer->StandUp();
|
|
BroadcastStatusMessage( pThisPlayer );
|
|
|
|
AR_TIME t = GetArTime();
|
|
pThisPlayer->AddState( StructState::CARELESSNESS, 0, 1, t, t + 300 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 지속효과가 크리처 탑승 효과일 경우 은신 해제됨
|
|
if( pStateInfo->effect_type == StructState::EF_RIDING && IsHiding() )
|
|
{
|
|
RemoveState( StructState::HIDE, GameRule::MAX_STATE_LEVEL );
|
|
RemoveState( StructState::TRACE_OF_FUGITIVE, GameRule::MAX_STATE_LEVEL );
|
|
}
|
|
|
|
if( code == StructState::FEAR )
|
|
{
|
|
m_StatusFlag.Off( STATUS_MOVING_BY_FEAR );
|
|
}
|
|
|
|
StructCreature::iterator itCaster;
|
|
itCaster = StructCreature::get( caster );
|
|
|
|
int base_damage = 0;
|
|
|
|
if( (*itCaster) )
|
|
{
|
|
switch( pStateInfo->base_effect_id )
|
|
{
|
|
case StructState::EF_PHYSICAL_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_STATE_DAMAGE:
|
|
case StructState::EF_PHYSICAL_IGNORE_DEFENCE_PER_STATE_DAMAGE:
|
|
base_damage = (*itCaster)->GetAttackPointRight( static_cast< Elemental::Type >(pStateInfo->elemental_type), true, true );
|
|
break;
|
|
case StructState::EF_MAGICAL_STATE_DAMAGE:
|
|
case StructState::EF_MAGICAL_IGNORE_RESIST_STATE_DAMAGE:
|
|
case StructState::EF_HEAL_HP_BY_MAGIC:
|
|
case StructState::EF_HEAL_MP_BY_MAGIC:
|
|
base_damage = (*itCaster)->GetMagicPoint( static_cast< Elemental::Type >(pStateInfo->elemental_type), false, true );
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool bNotErasable = pStateInfo->state_time_type & StateInfo::NOT_ERASABLE;
|
|
|
|
std::vector< StructState::StateCode > vDeleteStateCode;
|
|
bool bAlreadyExist = false;
|
|
|
|
for( it = m_vStateList.begin() ; it != m_vStateList.end() ; ++it )
|
|
{
|
|
bool bIsDuplicatedGroup = false;
|
|
if( code == (*it).GetCode() )
|
|
{
|
|
bAlreadyExist = true;
|
|
bIsDuplicatedGroup = true;
|
|
|
|
// 중첩 가능 횟수(reiteration_count)가 2회 이상일 경우, 중첩이 가능한 지속효과로 판단한다.
|
|
// 중첩 횟수는 사실상 레벨과 동일한 개념이며, 기존의 지속효과에 새로운 지속효과의 레벨을 더해 중첩을 표현한다.
|
|
// 따라서 한 번에 더해지는 중첩 횟수는 개념상 1회이며, 이에 따라 중첩 가능한 지속효과들은 1레벨 단위로만 걸릴 수 있다.
|
|
if( pStateInfo->reiteration_count >= 2 )
|
|
level = std::min( static_cast< int >( pStateInfo->reiteration_count ), (*it).GetLevel() + level );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0 ; i < 3 ; ++i )
|
|
{
|
|
if( (*it).IsDuplicatedGroup( pStateInfo->duplicate_group[i] ) )
|
|
{
|
|
bIsDuplicatedGroup = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bIsDuplicatedGroup )
|
|
{
|
|
// 이벤트에 의한 강제 지속효과의 경우 무조건 기존 버프 삭제(동일한 지속효과가 있었다고 해도 업데이트 아니고 강제로 삭제)
|
|
// 이벤트에 의한 강제 지속효과가 아니고 기존에 중복되어 있던 지속효과가 이벤트에 의한 강제 지속효과일 경우는 아무것도 못 함
|
|
if( bByEvent )
|
|
{
|
|
bAlreadyExist = false;
|
|
vDeleteStateCode.push_back( (*it).GetCode() );
|
|
continue;
|
|
}
|
|
else if( (*it).IsByEvent() )
|
|
{
|
|
return RESULT_ALREADY_EXIST;
|
|
}
|
|
|
|
bool bNotErasableCur = (*it).GetTimeType() & StateInfo::NOT_ERASABLE;
|
|
|
|
// 기존, 새 지속효과 모두 소멸 안 됨 플래그 없거나 있음
|
|
if( bNotErasable == bNotErasableCur )
|
|
{
|
|
// 그룹 같고 둘다 플래그 걸려 있으면 같은 지속효과여야 함.
|
|
// 만일 같지 않은 지속효과가 추가되어야 할 경우가 생기면
|
|
// 플래그 있을 때와 없을 때 분리해야 함
|
|
if( ( (*it).GetLevel() > level ) || ( (*it).GetLevel() == level && (*it).GetEndTime() > end_time ) )
|
|
{
|
|
return RESULT_ALREADY_EXIST;
|
|
}
|
|
|
|
// 같은 코드이면 기존의 지속효과를 업데이트 시키도록 해야 함(토글형의 갱신 문제)
|
|
if( code == (*it).GetCode() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
vDeleteStateCode.push_back( (*it).GetCode() );
|
|
}
|
|
// 새 지속효과에만 소멸 안 됨 플래그 있음
|
|
else if( bNotErasable )
|
|
{
|
|
vDeleteStateCode.push_back( (*it).GetCode() );
|
|
continue;
|
|
}
|
|
// 기존 지속효과에만 소멸 안 됨 플래그 있음
|
|
else
|
|
{
|
|
return RESULT_ALREADY_EXIST;
|
|
}
|
|
}
|
|
}
|
|
|
|
for( std::vector< StructState::StateCode >::iterator dit = vDeleteStateCode.begin() ; dit != vDeleteStateCode.end() ; ++dit )
|
|
{
|
|
RemoveState( *dit );
|
|
}
|
|
|
|
if( bAlreadyExist )
|
|
{
|
|
for( it = m_vStateList.begin() ; it != m_vStateList.end() ; ++it )
|
|
{
|
|
if( code == (*it).GetCode() )
|
|
{
|
|
// 변화가 있다면 스탯 재계산 및 방송
|
|
if( (*it).AddState( caster, level, start_time, end_time, base_damage, bIsAura ) )
|
|
{
|
|
CalculateStat();
|
|
onUpdateState( (*it), false );
|
|
|
|
onAfterAddState( (*it) );
|
|
}
|
|
else if( !bIsAura )
|
|
{
|
|
onUpdateState( (*it), false );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
int nUID = -1;
|
|
|
|
// EventState 지속효과나 로그아웃 시 삭제되는 지속효과와 같이 저장이 필요없는 지속효과는 UID를 할당하지 않는다.
|
|
// 여기서 UID가 부여되지 않는다면 UID의 존재 여부로 지속효과의 저장 필요 여부를 판단할 수 있어 효율적이다.
|
|
if( ( !IsPlayer() && !IsSummon() ) ||
|
|
bByEvent ||
|
|
pStateInfo->state_time_type & StateInfo::ERASE_ON_LOGOUT )
|
|
{
|
|
nUID = -1;
|
|
}
|
|
else
|
|
{
|
|
// UID 할당이 필요한 경우에도 미리 할당된 UID를 사용한다면 새로 발급할 필요가 없다.
|
|
// 실제 저장되지 않고 만료되는 지속효과가 많기에 대부분의 UID 발급이 무의미하지만, Save에 의해 이미 부여된 지속효과의 UID가 변경되는 경우는 발생해서는 안 된다.
|
|
// 이는 UID가 클라이언트로 방송될 때 handle로 활용되기 때문인데 handle이라고 해서 반드시 고유값일 필요는 없고 변경만 발생하지 않으면 문제가 없다.
|
|
// 예를 들어 위와 같이 DB에 저장이 필요없는 경우 UID를 -1로 일괄 부여하더라도 UID가 변경되지 않기 때문에 클라이언트에서 문제 없이 처리할 수 있다.
|
|
if( nAllocatedUID )
|
|
nUID = nAllocatedUID;
|
|
else
|
|
nUID = StructCreature::AllocStateUID( nDBEnable );
|
|
}
|
|
|
|
m_vStateList.push_back( StructState( code, nUID, caster, level, start_time, end_time, base_damage, bIsAura, nStateValue, szStateValue, bByEvent, nDBEnable ) );
|
|
|
|
CalculateStat();
|
|
|
|
onUpdateState( m_vStateList.back(), false );
|
|
|
|
if( IsMonster() && !IsMovable() )
|
|
{
|
|
if( m_Attribute.fAttackRange < GameRule::MAX_ATTACK_RANGE * GameRule::ATTACK_RANGE_UNIT )
|
|
{
|
|
m_Attribute.fAttackRange = GameRule::MAX_ATTACK_RANGE * GameRule::ATTACK_RANGE_UNIT;
|
|
}
|
|
}
|
|
|
|
onAfterAddState( m_vStateList.back() );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
void StructCreature::PendAddState( StructState::StateCode code, AR_HANDLE caster, int level, AR_TIME start_time, AR_TIME end_time, bool bIsAura, int nStateValue, const char * szStateValue, const bool bByEvent )
|
|
{
|
|
m_vPendStateList.push_back( StructState( code, -1, caster, level, start_time, end_time, -1, bIsAura, nStateValue, szStateValue, bByEvent, StructState::NOT_IN_DB ) );
|
|
}
|
|
|
|
void StructCreature::PendAddStateByItem( StructState::StateCode code, AR_HANDLE caster, int level, AR_TIME start_time, AR_TIME end_time, bool bIsAura, int nStateValue, const char * szStateValue, const bool bByEvent )
|
|
{
|
|
m_vPendStateListByItem.push_back( std::make_pair( 0, StructState( code, -1, caster, level, start_time, end_time, -1, bIsAura, nStateValue, szStateValue, bByEvent, StructState::NOT_IN_DB ) ) );
|
|
}
|
|
|
|
void StructCreature::onUpdateState( StructState & state, bool bIsExpire )
|
|
{
|
|
BroadcastStateMessage( this, &state, bIsExpire );
|
|
}
|
|
|
|
void StructCreature::RemoveState( StructState::StateCode code, int state_level, const bool bByEvent )
|
|
{
|
|
bool bFlag = false;
|
|
|
|
STATE_ITERATOR it;
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); )
|
|
{
|
|
if( (*it).GetCode() == code && (*it).GetLevel() <= state_level && ( !(*it).IsByEvent() || bByEvent ) )
|
|
{
|
|
bFlag = true;
|
|
break;
|
|
}
|
|
|
|
++it;
|
|
}
|
|
|
|
if( !bFlag ) return;
|
|
|
|
if( (*it).GetLevel() <= state_level )
|
|
{
|
|
StructState state = (*it);
|
|
|
|
onUpdateState( (*it), true );
|
|
m_vStateList.erase( it );
|
|
CalculateStat();
|
|
|
|
onAfterRemoveState( state );
|
|
}
|
|
}
|
|
|
|
template< typename Predicate >
|
|
void StructCreature::RemoveStateIf( Predicate& predicate, std::vector< StructState >* result, const bool bByDead )
|
|
{
|
|
std::vector< StructState > removedStates;
|
|
std::vector< StructState >::iterator it;
|
|
std::vector< StructState >::iterator trail;
|
|
|
|
// 필요한 경우 삭제된 state들을 반환하기 위해 우선 스왑
|
|
if( result != NULL )
|
|
{
|
|
removedStates.swap( *result );
|
|
}
|
|
|
|
// predicate이 true인 값은 removedStates로 이동시키고 false인 값은 m_vStateList에 남겨둠
|
|
for ( it = m_vStateList.begin(), trail = it; it != m_vStateList.end(); ++it )
|
|
{
|
|
if ( predicate( *it ) )
|
|
{
|
|
removedStates.push_back( *it );
|
|
}
|
|
else
|
|
{
|
|
if( trail != it )
|
|
{
|
|
*trail = *it;
|
|
}
|
|
++trail;
|
|
}
|
|
}
|
|
|
|
m_vStateList.resize( trail - m_vStateList.begin() );
|
|
|
|
// 삭제 대상인 녀석들을 대상으로 사후 처리
|
|
for ( it = removedStates.begin(); it != removedStates.end(); ++it )
|
|
{
|
|
onUpdateState( (*it), true );
|
|
onAfterRemoveState( *it, bByDead );
|
|
}
|
|
|
|
// 삭제된 지속효과가 하나라도 있다면 CalculateStat을 호출한다.
|
|
if( removedStates.size() )
|
|
{
|
|
CalculateStat();
|
|
}
|
|
|
|
// 삭제된 state들을 추가한 vector를 반환해주자
|
|
if( result != NULL )
|
|
{
|
|
removedStates.swap( *result );
|
|
}
|
|
}
|
|
|
|
void StructCreature::RemoveStatesOnDamaged()
|
|
{
|
|
RemoveStateIf( StateFlagChecker( StateInfo::ERASE_ON_DAMAGED ) );
|
|
}
|
|
|
|
void StructCreature::DecreaseState( StructState::StateCode code, const unsigned char level, const bool bByEvent )
|
|
{
|
|
struct CheckStateCode
|
|
{
|
|
CheckStateCode( StructState::StateCode code, bool byEvent ) : code( code ), byEvent( byEvent ) {}
|
|
const bool operator () ( const StructState & state ) const
|
|
{
|
|
if( state.GetCode() != code || state.IsByEvent() ^ byEvent )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
StructState::StateCode code;
|
|
bool byEvent;
|
|
} checkStateCode( code, bByEvent );
|
|
DecreaseStateIf( checkStateCode, level );
|
|
}
|
|
|
|
template< typename Predicate >
|
|
void StructCreature::DecreaseStateIf( Predicate& predicate, const unsigned char level, std::vector< StructState >* result )
|
|
{
|
|
bool bDecreased = false;
|
|
std::vector< StructState > removedStates;
|
|
std::vector< StructState >::iterator it;
|
|
std::vector< StructState >::iterator trail;
|
|
|
|
// 필요한 경우 삭제된 state들을 반환하기 위해 우선 스왑
|
|
if( result != NULL )
|
|
{
|
|
removedStates.swap( *result );
|
|
}
|
|
|
|
// predicate이 true인 값은 지속 레벨을 감소시키고 만약 레벨이 0이 된다면 removedStates로 이동시킨다.
|
|
for ( it = m_vStateList.begin(), trail = it; it != m_vStateList.end(); ++it )
|
|
{
|
|
if ( predicate( *it ) )
|
|
{
|
|
bDecreased = true;
|
|
|
|
(*it).SetLevel( (*it).GetLevel() > level ? (*it).GetLevel() - level : 0 );
|
|
|
|
// 감소된 지속효과 레벨이 0이면 삭제
|
|
if( (*it).GetLevel() == 0 )
|
|
{
|
|
removedStates.push_back( *it );
|
|
continue;
|
|
}
|
|
|
|
// 삭제되지 않은 지속효과라면 변경된 레벨을 방송
|
|
onUpdateState( *it );
|
|
}
|
|
|
|
if( trail != it )
|
|
{
|
|
*trail = *it;
|
|
}
|
|
++trail;
|
|
}
|
|
|
|
m_vStateList.resize( trail - m_vStateList.begin() );
|
|
|
|
// 삭제 대상인 녀석들을 대상으로 사후 처리
|
|
for ( it = removedStates.begin(); it != removedStates.end(); ++it )
|
|
{
|
|
onUpdateState( (*it), true );
|
|
onAfterRemoveState( *it );
|
|
}
|
|
|
|
// 감소되었거나 삭제된 지속효과가 하나라도 있다면 CalculateStat을 호출한다.
|
|
if( bDecreased || removedStates.size() )
|
|
{
|
|
CalculateStat();
|
|
}
|
|
|
|
// 삭제된 state들을 추가한 vector를 반환해주자
|
|
if( result != NULL )
|
|
{
|
|
removedStates.swap( *result );
|
|
}
|
|
}
|
|
|
|
bool StructCreature::ClearExpiredState( AR_TIME t )
|
|
{
|
|
struct CheckAndProcessExpiredState {
|
|
CheckAndProcessExpiredState( StructCreature& creature, AR_TIME time )
|
|
: creature( creature ), isExpiredStateExist( false ), time( time ) {}
|
|
|
|
const bool operator () ( StructState& state )
|
|
{
|
|
bool erase = false;
|
|
|
|
// 이벤트에 의해 부여된 지속효과가 아닐 경우에만 만료 처리 체크 함
|
|
if( !state.IsByEvent() )
|
|
{
|
|
if( state.ClearExpiredState( time ) )
|
|
{
|
|
isExpiredStateExist = true;
|
|
erase = true;
|
|
}
|
|
}
|
|
|
|
return erase;
|
|
}
|
|
|
|
StructCreature& creature;
|
|
bool isExpiredStateExist;
|
|
AR_TIME time;
|
|
} checkAndProcessExpiredState( *this, t );
|
|
std::vector< StructState > removedStates;
|
|
|
|
RemoveStateIf( checkAndProcessExpiredState, &removedStates );
|
|
|
|
bool returnValue = checkAndProcessExpiredState.isExpiredStateExist;
|
|
|
|
for ( std::vector< StructState >::iterator it = removedStates.begin(); it != removedStates.end(); ++it )
|
|
{
|
|
// { 추가 작업
|
|
if( (*it).GetCode() == StructState::ADD_ENERGY )
|
|
{
|
|
AddEnergy();
|
|
}
|
|
else if( (*it).GetEffectType() == StructState::EF_PROVOKE && IsMonster() )
|
|
{
|
|
StructMonster *pMonster = static_cast< StructMonster * >( this );
|
|
|
|
pMonster->SetNeedToFindEnemy();
|
|
}
|
|
|
|
// 지속효과 소멸 시 로그 남겨야 하는 경우 로그 남김
|
|
if( it->IsLogRequiredOnExpiration() )
|
|
{
|
|
StructPlayer * pPlayer = NULL;
|
|
StructSummon * pSummon = NULL;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
pPlayer = static_cast< StructPlayer * >( this );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
pSummon = static_cast< StructSummon * >( this );
|
|
pPlayer = pSummon->GetMaster();
|
|
}
|
|
|
|
if( pPlayer && pPlayer->IsLogin() && !pPlayer->IsDeleteRequested() )
|
|
{
|
|
if( pSummon )
|
|
{
|
|
LOG::Log11N4S( LM_STATE_EXPIRATION, pPlayer->GetAccountID(), pPlayer->GetSID(), it->GetCode(), it->GetLevel(),
|
|
pSummon->GetSID(), pSummon->GetSummonCode(), pSummon->GetLevel(), 0, pSummon->GetX(), pSummon->GetY(), pSummon->GetParentCard()->GetItemUID(),
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, pSummon->GetName(), LOG::STR_NTS, "", 0 );
|
|
}
|
|
else
|
|
{
|
|
LOG::Log11N4S( LM_STATE_EXPIRATION, pPlayer->GetAccountID(), pPlayer->GetSID(), it->GetCode(), it->GetLevel(),
|
|
0, 0, 0, 0, 0, pPlayer->GetX(), pPlayer->GetY(),
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "", 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
|
|
void StructCreature::RestoreRemovedStateByDead()
|
|
{
|
|
// 사망시 없어진 지속효과를 시작/종료 시각 조정하여 다시 부여
|
|
AR_TIME t = GetArTime();
|
|
for( STATE_ITERATOR it = m_vStateListRemovedByDeath.begin() ; it != m_vStateListRemovedByDeath.end() ; )
|
|
{
|
|
const StructState & state = (*it);
|
|
|
|
// 이미 걸려있는 지속효과면 패스
|
|
if( GetState( state.GetCode() ) || ( it->GetTimeType() & StateInfo::ERASE_ON_RESURRECT ) )
|
|
{
|
|
++it;
|
|
continue;
|
|
}
|
|
|
|
if( state.GetEndTime() == (AR_TIME)-1 )
|
|
{
|
|
AddState( state.GetCode(), state.GetCaster(), state.GetLevel(), state.GetStartTime(), -1, state.IsAura(), state.GetStateValue(), state.GetStateStringValue(), state.IsByEvent(), state.GetUID(), state.GetDBEnable() );
|
|
}
|
|
else
|
|
{
|
|
AR_TIME time_difference = GetArTime() - GetDeadTime();
|
|
|
|
AddState( state.GetCode(), state.GetCaster(), state.GetLevel(), state.GetStartTime() + time_difference, state.GetEndTime() + time_difference, state.IsAura(), state.GetStateValue(), state.GetStateStringValue(), state.IsByEvent(), state.GetUID(), state.GetDBEnable() );
|
|
}
|
|
|
|
it = m_vStateListRemovedByDeath.erase( it );
|
|
}
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
ClearRemovedStateByDead();
|
|
|
|
}
|
|
|
|
void StructCreature::ClearRemovedStateByDead()
|
|
{
|
|
for( std::vector< StructState >::iterator it = m_vStateListRemovedByDeath.begin(); it != m_vStateListRemovedByDeath.end(); ++it )
|
|
{
|
|
(*it).Expire( this );
|
|
}
|
|
|
|
m_vStateListRemovedByDeath.clear();
|
|
}
|
|
|
|
void StructCreature::RemoveAllAura()
|
|
{
|
|
if( m_vAura.size() )
|
|
{
|
|
std::vector< std::pair<StructSkill *, int> >::iterator it;
|
|
for( it = m_vAura.begin(); it != m_vAura.end(); ++it )
|
|
{
|
|
TS_SC_AURA msg;
|
|
|
|
msg.caster = GetHandle();
|
|
msg.skill_id = (*it).first->GetSkillId();
|
|
|
|
msg.status = false;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
PendMessage( this, &msg );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
PendMessage( static_cast< StructSummon * >( this )->GetMaster(), &msg );
|
|
}
|
|
}
|
|
m_vAura.clear();
|
|
}
|
|
}
|
|
|
|
void StructCreature::RemoveAllStateByDeadOrLogout()
|
|
{
|
|
// 소환수 역소환에 의해 호출되는 함수로 실제로는 죽는 것과 관련이 없는 함수이다. 따라서 bByDead를 false로 넘긴다.
|
|
// 또한 소환수의 경우는 부활 시 지속효과 복구 기능이 구현되어 있지 않으며 사용하지도 않는다.
|
|
RemoveStateIf( StateFlagChecker( StateInfo::ERASE_ON_DEAD | StateInfo::ERASE_ON_LOGOUT ) );
|
|
}
|
|
|
|
void StructCreature::RemoveAllStateByQuittingHuntaholic()
|
|
{
|
|
RemoveStateIf( StateFlagChecker( StateInfo::ERASE_ON_QUIT_HUNTAHOLIC ) );
|
|
}
|
|
|
|
void StructCreature::RemoveStateByEnteringDeathmatch()
|
|
{
|
|
struct DeathMatchFlagChecker
|
|
{
|
|
const bool operator() ( const StructState& state )
|
|
{
|
|
return ( !( state.GetTimeType() & StateInfo::NOT_ERASABLE_ON_ENTER_DEATHMATCH ) ) && !state.IsAura() && !state.IsByEvent();
|
|
}
|
|
} deathMatchFlagChecker;
|
|
|
|
RemoveStateIf( deathMatchFlagChecker );
|
|
}
|
|
|
|
void StructCreature::RemoveAllStateByQuittingDeathmatch()
|
|
{
|
|
RemoveStateIf( StateFlagChecker( StateInfo::ERASE_ON_QUIT_DEATHMATCH ) );
|
|
}
|
|
|
|
struct BattleArenaStateChecker
|
|
{
|
|
static const int REMOVE_FLAG = ( StateInfo::ERASE_ON_DEAD | StateInfo::ERASE_ON_QUIT_BATTLE_ARENA );
|
|
|
|
const bool operator()( const StructState & state )
|
|
{
|
|
return ( state.GetTimeType() & REMOVE_FLAG ) != 0;
|
|
}
|
|
};
|
|
|
|
void StructCreature::RemoveAllStateByQuittingBattleArena()
|
|
{
|
|
BattleArenaStateChecker basc;
|
|
|
|
RemoveStateIf( basc );
|
|
}
|
|
|
|
bool StructCreature::AddAimer( AR_HANDLE aimer )
|
|
{
|
|
if( std::find( m_vAimerList.begin(), m_vAimerList.end(), aimer ) != m_vAimerList.end() )
|
|
return false;
|
|
|
|
m_vAimerList.push_back( aimer );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StructCreature::RemoveAimer( AR_HANDLE aimer )
|
|
{
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
|
|
it = std::find( m_vAimerList.begin(), m_vAimerList.end(), aimer );
|
|
|
|
if( it == m_vAimerList.end() )
|
|
return false;
|
|
|
|
vector_fast_erase( &m_vAimerList, it );
|
|
|
|
return true;
|
|
}
|
|
|
|
void StructCreature::ReleaseAimerList()
|
|
{
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
|
|
for( it = m_vAimerList.begin(); it != m_vAimerList.end(); it++ )
|
|
{
|
|
StructPlayer::iterator itPlayer = StructPlayer::get( *it );
|
|
StructPlayer *pObj = *itPlayer;
|
|
|
|
if( pObj )
|
|
{
|
|
pObj->SetTarget( 0 );
|
|
}
|
|
}
|
|
|
|
m_vAimerList.clear();
|
|
}
|
|
|
|
bool StructCreature::IsUsingSkill()
|
|
{
|
|
return !!m_pCastSkill;
|
|
}
|
|
|
|
bool StructCreature::CancelSkill()
|
|
{
|
|
if( !IsUsingSkill() )
|
|
return false;
|
|
|
|
if( !m_pCastSkill->Cancel() )
|
|
return false;
|
|
|
|
m_pCastSkill = NULL;
|
|
// _oprint("[%s] 스킬 캔슬\n", GetName() );
|
|
|
|
return true;
|
|
}
|
|
bool StructCreature::OnCompleteSkill()
|
|
{
|
|
if( !IsUsingSkill() ) return false;
|
|
|
|
m_pCastSkill = NULL;
|
|
// _oprint("[%s] 스킬 시전 완료\n", GetName() );
|
|
|
|
return true;
|
|
}
|
|
|
|
const unsigned short StructCreature::CastSkill( int nSkillId, int nSkillLevel, AR_HANDLE target_handle, const ArPosition & pos, unsigned char layer, AR_HANDLE hCastItem )
|
|
{
|
|
ArPosition target_pos = pos;
|
|
|
|
// AziaMafia Fix bug if skill is being used
|
|
if( IsUsingSkill() ) return RESULT_NOT_ACTABLE;
|
|
|
|
if( IsPlayer() && static_cast< StructPlayer * >( this )->IsUsingStorage() ) return RESULT_NOT_ACTABLE;
|
|
|
|
StructSkill* pSkill = getSkill( nSkillId );
|
|
if( !pSkill ) return RESULT_NO_SKILL;
|
|
|
|
GameObject::iterator it = StructCreature::get( target_handle );
|
|
StructCreature *pSkillTarget = NULL;
|
|
|
|
if( *it )
|
|
{
|
|
if( (*it)->IsCreature() ) pSkillTarget = static_cast< StructCreature * >( *it );
|
|
}
|
|
|
|
// Check if skill is usable on the target
|
|
if( pSkill->GetSkillBase()->GetSkillTargetType() == SkillBase::TARGET_MASTER )
|
|
{
|
|
if( !IsSummon() )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
StructSummon* pSummon = static_cast< StructSummon* >( this );
|
|
if( pSummon->GetMaster() != pSkillTarget )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
}
|
|
else if( pSkill->GetSkillBase()->GetSkillTargetType() == SkillBase::TARGET_SELF_WITH_MASTER )
|
|
{
|
|
if( !IsSummon() )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
StructSummon* pSummon = static_cast< StructSummon* >( this );
|
|
if( pSkillTarget != this && pSkillTarget != pSummon->GetMaster() )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
}
|
|
|
|
// 자신에게 사용할 수 없는 스킬일 경우 체크
|
|
if( pSkill->GetSkillBase()->GetSkillTargetType() == SkillBase::TARGET_TARGET_EXCEPT_CASTER &&
|
|
pSkillTarget == this )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
if( pSkillTarget )
|
|
{
|
|
if( !pSkillTarget->IsInWorld() )
|
|
return RESULT_NOT_ACTABLE;
|
|
|
|
// ??-_-??
|
|
// if( ( pSkill->GetSkillBase()->IsHarmful() && pSkill->IsNeedTarget() && !IsEnemy( pSkillTarget ) ) || ( !pSkill->GetSkillBase()->IsHarmful() && IsEnemy( pSkillTarget ) ) )
|
|
// {
|
|
// return false;
|
|
// }
|
|
|
|
AR_TIME t = GetArTime();
|
|
ArPosition enemyPosition = pSkillTarget->GetCurrentPosition( t );
|
|
ArPosition myPosition = GetCurrentPosition( t );
|
|
AR_UNIT enemy_distance = myPosition.GetDistance( enemyPosition ) - GetUnitSize()/2 - pSkillTarget->GetUnitSize()/2;;
|
|
|
|
float range_mod = 1.2f;
|
|
|
|
if( pSkillTarget->IsMoving() )
|
|
{
|
|
range_mod = 1.5f;
|
|
|
|
}
|
|
|
|
if( pSkill->GetCastRange() == -1 )
|
|
{
|
|
if( enemy_distance > GetRealAttackRange() * range_mod )
|
|
{
|
|
return RESULT_TOO_FAR;
|
|
}
|
|
}
|
|
else if( enemy_distance > pSkill->GetCastRange() * GameRule::DEFAULT_UNIT_SIZE * range_mod )
|
|
{
|
|
return RESULT_TOO_FAR;
|
|
}
|
|
|
|
if( pSkill->GetSkillBase()->IsValidToCorpse() )
|
|
{
|
|
if( !pSkillTarget->IsDead() )
|
|
// _cprint( "스킬 시전 실패 : 살아있는 대상에게 사용 불가\n" );
|
|
return RESULT_NOT_ACTABLE;
|
|
|
|
// 죽었더라도 내구도가 다한 소환수는 살릴 수 없음
|
|
else if( pSkillTarget->IsSummon() )
|
|
{
|
|
StructItem *pCardItem = static_cast< StructSummon * >( pSkillTarget )->GetParentCard();
|
|
|
|
if( pCardItem && pCardItem->GetMaxEtherealDurability() && !pCardItem->GetCurrentEtherealDurability() )
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
}
|
|
|
|
if( pSkillTarget == this || ( pSkillTarget->IsSummon() && static_cast< StructSummon * >( pSkillTarget )->GetMaster() == this ) )
|
|
{
|
|
if( !pSkill->IsUsable( SkillBase::USE_SELF ) )
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
else if( IsAlly( pSkillTarget ) )
|
|
{
|
|
if( !pSkill->IsUsable( SkillBase::USE_ALLY ) )
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
else if( IsEnemy( pSkillTarget ) )
|
|
{
|
|
if( !pSkill->IsUsable( SkillBase::USE_ENEMY ) )
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
else
|
|
{
|
|
if( !pSkill->IsUsable( SkillBase::USE_NEUTRAL ) )
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
if( pSkillTarget->IsPlayer() && !pSkill->IsUseableOnAvatar() )
|
|
{
|
|
// _cprint( "스킬 시전 실패 : 아바타에게 사용 불가\n" );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
if( pSkillTarget->IsMonster() && !pSkill->IsUseableOnMonster() )
|
|
{
|
|
// _cprint( "스킬 시전 실패 : 몬스터에게 사용 불가\n" );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
if( pSkillTarget->IsSummon() && !pSkill->IsUseableOnSummon() )
|
|
{
|
|
// _cprint( "스킬 시전 실패 : 소환수에게 사용 불가\n" );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
target_pos = pSkillTarget->GetCurrentPosition( GetArTime() );
|
|
}
|
|
|
|
else
|
|
{
|
|
if( nSkillId == StructSkill::SKILL_RETURN_FEATHER && IsPlayer() )
|
|
{
|
|
if( static_cast< StructPlayer * >( this )->IsInSiegeOrRaidDungeon() )
|
|
{
|
|
// _cprintf" 스킬 시전 실패 : 귀환의 깃털은 레이드/시즈 던전 안에서는 사용 불가\n")
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
// 숨겨진 던전 안에서는 귀환의 깃털 스킬을 사용할 수 없도록 되어 있었으나, 사용 가능한 크루 아이템의 추가로 여기서의 체크 제거
|
|
// * 체크를 제거해도 실제로 layer를 별도의 manager에 의해 관리하거나 하는 영역이 아니기 때문에 시스템상 별다른 문제는 없을 걸로 예상됨
|
|
if( static_cast< StructPlayer * >( this )->IsInInstanceDungeon() )
|
|
{
|
|
// _cprintf" 스킬 시전 실패 : 귀환의 깃털은 인스턴스 던전 안에서는 사용 불가\n")
|
|
return RESULT_NOT_ACTABLE_IN_INSTANCE_DUNGEON;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !m_vInterruptedSkill.empty() )
|
|
{
|
|
for( std::vector< int >::iterator it = m_vInterruptedSkill.begin() ; it != m_vInterruptedSkill.end() ; ++it )
|
|
{
|
|
if( (*it) == nSkillId )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !m_vAllowedSkill.empty() )
|
|
{
|
|
bool bActable = true;
|
|
for( std::vector< std::set< int > >::iterator it = m_vAllowedSkill.begin(); bActable && it != m_vAllowedSkill.end(); it++ )
|
|
{
|
|
if( (*it).find( pSkill->GetSkillId() ) == (*it).end() )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetDirection( target_pos );
|
|
|
|
m_pCastSkill = pSkill;
|
|
// _oprint("[%s] 스킬 시전 m_pSkill 설정\n", GetName() );
|
|
|
|
int nErrorCode = m_pCastSkill->Cast( nSkillLevel, target_handle, target_pos, layer, hCastItem );
|
|
|
|
if( nErrorCode != RESULT_SUCCESS )
|
|
{
|
|
|
|
// AziaMafia log GS
|
|
//_cprint("Cast nErrorCode != RESULT_SUCCESS : %s / nErrorCode = %d / skillid = %d / hCastItem = %d \n", GetName(), nErrorCode , nSkillId , hCastItem);
|
|
//FILELOG("Cast nErrorCode != RESULT_SUCCESS : %s / nErrorCode = %d / skillid = %d / hCastItem = %d ", GetName(), nErrorCode, nSkillId, hCastItem);
|
|
// _oprint("[%s] 스킬 시전 실패\n", GetName() );
|
|
m_pCastSkill = NULL;
|
|
return nErrorCode;
|
|
}
|
|
|
|
// _oprint("[%s] 스킬 시전 성공\n", GetName() );
|
|
ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_HIGHEST );
|
|
|
|
// C급 보스 이상의 몬스터가 스킬 시전에 성공한 경우 로그 남김
|
|
if( IsMonster() && static_cast< StructMonster * >( this )->GetMonsterType() >= MonsterBase::MONSTER_TYPE_HIGHEST_1_STAR )
|
|
{
|
|
StructMonster * pMonster = static_cast< StructMonster * >( this );
|
|
|
|
if( pSkillTarget )
|
|
{
|
|
StructPlayer * pPlayer = NULL;
|
|
|
|
if( pSkillTarget->IsPlayer() )
|
|
{
|
|
pPlayer = static_cast< StructPlayer * >( pSkillTarget );
|
|
}
|
|
else if( pSkillTarget->IsSummon() )
|
|
{
|
|
pPlayer = static_cast< StructSummon * >( pSkillTarget )->GetMaster();
|
|
}
|
|
|
|
if( pPlayer )
|
|
{
|
|
LOG::Log11N4S( LM_MONSTER_SKILL_CAST, pPlayer->GetAccountID(), pPlayer->GetSID(), pSkillTarget->GetX(), pSkillTarget->GetY(), pSkillTarget->GetLayer(),
|
|
pMonster->GetMonsterId(), pMonster->GetX(), pMonster->GetY(), pMonster->GetLayer(),
|
|
nSkillId, nSkillLevel,
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS,
|
|
pSkillTarget->GetName(), LOG::STR_NTS, pMonster->GetName(), LOG::STR_NTS );
|
|
}
|
|
else
|
|
{
|
|
LOG::Log11N4S( LM_MONSTER_SKILL_CAST, 0, 0, pSkillTarget->GetX(), pSkillTarget->GetY(), pSkillTarget->GetLayer(),
|
|
pMonster->GetMonsterId(), pMonster->GetX(), pMonster->GetY(), pMonster->GetLayer(),
|
|
nSkillId, nSkillLevel,
|
|
"", 0, "", 0,
|
|
pSkillTarget->GetName(), LOG::STR_NTS, pMonster->GetName(), LOG::STR_NTS );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG::Log11N4S( LM_MONSTER_SKILL_CAST, 0, 0, 0, 0, 0,
|
|
pMonster->GetMonsterId(), pMonster->GetX(), pMonster->GetY(), pMonster->GetLayer(),
|
|
nSkillId, nSkillLevel,
|
|
"", 0, "", 0,
|
|
"", 0, pMonster->GetName(), LOG::STR_NTS );
|
|
}
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
// 두 벡터의 각도차이
|
|
static short getDegreeDiff( const ArMoveVector & mv1, const ArMoveVector & mv2 )
|
|
{
|
|
short d1 = mv1.GetDegree();
|
|
short d2 = mv2.GetDegree();
|
|
|
|
short diff = ( d1 > d2 ? d1 - d2 : d2 - d1 );
|
|
if( diff < 0 ) diff = 0 - diff;
|
|
|
|
return diff;
|
|
}
|
|
|
|
bool StructCreature::IsBackOf( const StructCreature & target )
|
|
{
|
|
short diff = getDegreeDiff( target.GetMv(), GetMv() );
|
|
|
|
return ( diff < 180 + 90 / 2 && 180 - 90 / 2 );
|
|
}
|
|
|
|
bool StructCreature::IsSideOf( const StructCreature & target )
|
|
{
|
|
short diff = getDegreeDiff( target.GetMv(), GetMv() );
|
|
|
|
return ( diff < 90 + 90 / 2 && 90 - 90 / 2 ) ||
|
|
( diff < 270 + 90 / 2 && 270 - 90 / 2 );
|
|
}
|
|
|
|
StructSkill * StructCreature::GetSkill( int nSkillId ) const
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
for( it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillId() == nSkillId ) return *it;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const StructSkill * StructCreature::GetSkillByEffectType( const int nEffectTypeID ) const
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
for( it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillBase()->GetEffectType() == nEffectTypeID ) return *it;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
StructSkill * StructCreature::getSkill( int nSkillId ) const
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
for( it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillId() == nSkillId ) return *it;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
StructSkill * StructCreature::SetSkill( int skill_uid, int skill_id, int skill_level, AR_TIME remain_cool_time )
|
|
{
|
|
int nPrevLevel;
|
|
|
|
if( !GameContent::GetSkillBase( skill_id ) ) return NULL;
|
|
|
|
StructSkill *pSkill = getSkill( skill_id );
|
|
if( !pSkill )
|
|
{
|
|
// 메모리 풀 사용하도록 변경
|
|
//pSkill = new StructSkill( this, skill_uid, skill_id );
|
|
pSkill = StructSkill::AllocSkill( this, skill_uid, skill_id );
|
|
|
|
m_vAllSkillList.push_back( pSkill );
|
|
if( pSkill->IsPassiveSkill() ) m_vPassiveSkillList.push_back( pSkill );
|
|
else m_vActiveSkillList.push_back( pSkill );
|
|
}
|
|
|
|
nPrevLevel = pSkill->GetBaseSkillLevel();
|
|
pSkill->SetBaseSkillLevel( skill_level );
|
|
|
|
// remain_cool_time이 가끔 음수인 경우가 있는데 여기서 DBCoolTime을 0으로 보정하지 않고 그대로 음수로 저장을 하면,
|
|
// 로그아웃 시점의 remain_cool_time이 0이라고 하더라도 저장이 되며 0 또는 양수의 정상 범위 값으로 변한다.
|
|
if( remain_cool_time ) pSkill->SetRemainCoolTime( remain_cool_time );
|
|
pSkill->SetDBCoolTime( remain_cool_time );
|
|
|
|
CheckAndSetEnhanceSkill( pSkill );
|
|
|
|
return pSkill;
|
|
}
|
|
|
|
void StructCreature::CheckAndSetEnhanceSkill( StructSkill* skill )
|
|
{
|
|
// 강화 스킬은 강화의 대상이 되지 않도록 의도하였다. 강화 자체가 재귀적으로 이루어지는 것이 아니라 최대 한 단계만 참조하기 문.
|
|
// 다시 말해 강화 스킬1을 강화하는 스킬2가 있다고 해도 스킬1에 의해 강화되는 스킬은 스킬2에 아무런 영향을 받지 않는다.
|
|
if ( skill->GetSkillBase()->GetSkillEffectType() == SkillBase::EF_ENHANCE_SKILL )
|
|
{
|
|
for( std::vector< StructSkill* >::iterator it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
if ( skill->GetSkillBase()->GetEnhancedSkillId() == (*it)->GetSkillId() )
|
|
{
|
|
assert( (*it)->GetSkillBase()->GetSkillEffectType() != SkillBase::EF_ENHANCE_SKILL );
|
|
(*it)->SetEnhanceSkill( skill );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( std::vector< StructSkill* >::iterator it = m_vPassiveSkillList.begin(); it != m_vPassiveSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillBase()->GetSkillEffectType() == SkillBase::EF_ENHANCE_SKILL &&
|
|
(*it)->GetSkillBase()->GetEnhancedSkillId() == skill->GetSkillId() )
|
|
{
|
|
skill->SetEnhanceSkill( *it );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::RegisterSkill( int skill_id, int skill_level, AR_TIME remain_cool_time, int skill_tree_id )
|
|
{
|
|
int nJobId = GetJobId();
|
|
|
|
// JP, TP 소비
|
|
__int64 nNeedJP = GameContent::GetNeedJpForSkillLevelUp( skill_id, skill_level, skill_tree_id );
|
|
int nNeedTP = GameContent::GetNeedTpForSkillLevelUp( skill_id, skill_level );
|
|
|
|
if( nNeedJP > GetJobPoint() || nNeedTP > GetTalentPoint() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( nNeedJP > 0 ) m_nJobPoint -= nNeedJP;
|
|
if( nNeedTP > 0 )
|
|
{
|
|
// TP 사용은 로그로 찍어준다.
|
|
StructPlayer * pClient = NULL;
|
|
if( IsPlayer() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( this );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( static_cast< StructSummon * >( this )->GetMaster() );
|
|
}
|
|
|
|
if( pClient )
|
|
{
|
|
LOG::Log11N4S( LM_CHARACTER_USE_TP, pClient->GetAccountID(),
|
|
pClient->GetSID(), nJobId,
|
|
GetJobLevel(), skill_id,
|
|
skill_level, nNeedJP,
|
|
nNeedTP, GetTalentPoint() - nNeedTP,
|
|
0, 0,
|
|
pClient->GetAccountName(), LOG::STR_NTS,
|
|
pClient->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"ByLearnSkill", LOG::STR_NTS );
|
|
}
|
|
|
|
SetTalentPoint( GetTalentPoint() - nNeedTP );
|
|
}
|
|
|
|
if( m_nJobPoint < 0 ) m_nJobPoint = 0;
|
|
// 여기서 렙업할 일은 없고, 렙업할 일이 없다는 것은 calculatestat호출 될 일이 없다는 것이므로, 여기선 lock을 걸지 않는다.
|
|
// JP 방송은 onExpChange에서 하고 TP 방송은 SetTalentPoint에서 이미 했다.
|
|
onExpChange();
|
|
//
|
|
|
|
int nSkillUID = 0;
|
|
int nPrevLevel = GetBaseSkillLevel( skill_id );
|
|
bool bIsNewSkill = false;
|
|
|
|
if( !GetSkill( skill_id ) )
|
|
{
|
|
bIsNewSkill = true;
|
|
nSkillUID = InterlockedIncrement( &s_nMaxSkillUID );
|
|
}
|
|
|
|
StructSkill *pSkill = SetSkill( nSkillUID, skill_id, skill_level, remain_cool_time );
|
|
|
|
if( pSkill )
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
LOG::Log11N4S( LM_CHARACTER_LEARN_SKILL, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, skill_id, skill_level, nNeedJP, GetJobPoint(), nSkillUID, nNeedTP, GetTalentPoint(), 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "", 0 );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
StructSummon * pSummon = static_cast< StructSummon * >( this );
|
|
__int64 nCardUID = 0;
|
|
|
|
if( pSummon->GetParentCard() )
|
|
{
|
|
nCardUID = pSummon->GetParentCard()->GetItemUID();
|
|
}
|
|
LOG::Log11N4S( LM_SUMMON_LEARN_SKILL, pSummon->GetMaster()->GetAccountID(), pSummon->GetMaster()->GetSID(), pSummon->GetSID(), skill_id, skill_level, nNeedJP, m_nJobPoint, nSkillUID, nNeedTP, GetTalentPoint(), nCardUID, pSummon->GetMaster()->GetAccountName(), LOG::STR_NTS, pSummon->GetMaster()->GetName(), LOG::STR_NTS, pSummon->GetName(), LOG::STR_NTS, "", 0 );
|
|
}
|
|
|
|
|
|
if( pSkill->IsPassiveSkill() )
|
|
{
|
|
CalculateStat();
|
|
}
|
|
|
|
onRegisterSkill( pSkill->GetSkillUID(), skill_id, skill_level, bIsNewSkill );
|
|
}
|
|
}
|
|
|
|
void StructCreature::EnumState( StructCreature::STATE_FUNCTOR & _fo )
|
|
{
|
|
std::vector< StructState >::iterator it;
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
_fo.onState( &(*it) );
|
|
}
|
|
}
|
|
|
|
void StructCreature::EnumSkill( StructCreature::SKILL_FUNCTOR & _fo ) const
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
for( it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillUID() > 0 )
|
|
_fo.onSkill( (*it)->GetSkillUID(), (*it)->GetSkillId(), (*it)->GetBaseSkillLevel(), (*it)->GetCurrentSkillLevel(), (*it)->GetSkillCoolTime(), (*it)->GetRemainCoolTime( t ) );
|
|
}
|
|
}
|
|
|
|
StructSkill* StructCreature::GetCurrentPassiveSkill( int skill_id ) const
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
for( it = m_vPassiveSkillList.begin(); it != m_vPassiveSkillList.end(); ++it )
|
|
{
|
|
if( (*it)->GetSkillId() == skill_id ) return (*it);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int StructCreature::GetCurrentPassiveSkillLevel( int skill_id ) const
|
|
{
|
|
StructSkill* pSkill = GetCurrentPassiveSkill( skill_id );
|
|
if( pSkill ) return pSkill->GetCurrentSkillLevel();
|
|
return 0;
|
|
}
|
|
|
|
// skillLevelBase에서 skillLevelTarget까지 필요한 JP, TP 반환
|
|
const LearningCost GetSumOfSkillLearningCost( const StructCreature* creature, const int skillId, const int skillLevelBase, const int skillLevelTarget )
|
|
{
|
|
int jobId[GameRule::MAX_JOB_DEPTH];
|
|
int jobDepth = creature->GetJobDepth();
|
|
|
|
for( int i = 0; i < jobDepth; ++i )
|
|
{
|
|
jobId[i] = creature->GetPrevJobId(i);
|
|
}
|
|
|
|
jobId[ jobDepth ] = creature->GetJobId();
|
|
|
|
LearningCost cost;
|
|
|
|
for( int skillLevel = skillLevelTarget; skillLevel > skillLevelBase; skillLevel-- )
|
|
{
|
|
int i = 0;
|
|
|
|
__int64 JPPerLv = -1;
|
|
while( JPPerLv == -1 && i <= jobDepth )
|
|
{
|
|
if( creature->IsSummon() )
|
|
{
|
|
SummonBase *pBase = GameContent::GetSummonInfo( jobId[i++] );
|
|
if( !pBase )
|
|
continue;
|
|
|
|
for( int j = 0 ; j < GameRule::MAX_SUMMON_SKILL_TREE && JPPerLv == -1 ; ++j )
|
|
{
|
|
if( !pBase->skill_tree_id[j] )
|
|
continue;
|
|
JPPerLv = GameContent::GetNeedJpForSkillLevelUp( skillId, skillLevel, pBase->skill_tree_id[j] );
|
|
}
|
|
}
|
|
else if( creature->IsPlayer() )
|
|
{
|
|
const JobInfo *pInfo = GameContent::GetJobInfo( jobId[i++] );
|
|
if( !pInfo || !pInfo->skill_tree_id )
|
|
continue;
|
|
|
|
JPPerLv = GameContent::GetNeedJpForSkillLevelUp( skillId, skillLevel, pInfo->skill_tree_id );
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
if( JPPerLv != -1 )
|
|
{
|
|
cost.jp += JPPerLv;
|
|
}
|
|
|
|
int TPPerLv = GameContent::GetNeedTpForSkillLevelUp( skillId, skillLevel );
|
|
if( TPPerLv != -1 )
|
|
{
|
|
cost.tp += TPPerLv;
|
|
}
|
|
}
|
|
|
|
return cost;
|
|
}
|
|
|
|
const int GetAllowedMaxSkillLevel( const StructCreature* creature, const StructSkill* skill, const int remainingMaxJobDepth )
|
|
{
|
|
int allowedSkillLevel = 0;
|
|
int maxJobDepth = std::min( creature->GetJobDepth(), remainingMaxJobDepth );
|
|
|
|
for( int checkedJobDepth = 0; checkedJobDepth <= maxJobDepth; checkedJobDepth++ )
|
|
{
|
|
int jobId = ( checkedJobDepth == creature->GetJobDepth() ) ? creature->GetJobId() : creature->GetPrevJobId( checkedJobDepth );
|
|
if( creature->IsPlayer() )
|
|
{
|
|
const JobInfo *pInfo = GameContent::GetJobInfo( jobId );
|
|
if( pInfo )
|
|
{
|
|
allowedSkillLevel = std::max( allowedSkillLevel, GameContent::GetAllowedMaxSkillLevel( pInfo->skill_tree, skill->GetSkillId() ) );
|
|
}
|
|
}
|
|
else if( creature->IsSummon() )
|
|
{
|
|
const SummonBase *pBase = GameContent::GetSummonInfo( jobId );
|
|
if( pBase )
|
|
{
|
|
for( int i = 0 ; i < GameRule::MAX_SUMMON_SKILL_TREE ; ++i )
|
|
{
|
|
if( !pBase->skill_tree_id[ i ] )
|
|
continue;
|
|
allowedSkillLevel = std::max( allowedSkillLevel, GameContent::GetAllowedMaxSkillLevel( pBase->skill_tree[ i ], skill->GetSkillId() ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return allowedSkillLevel;
|
|
}
|
|
|
|
|
|
template< typename SkillPredicate >
|
|
void StructCreature::turnOffAuraOnSkillReset( const SkillPredicate& predicate )
|
|
{
|
|
typedef std::pair<StructSkill *, int> Aura;
|
|
|
|
// TODO : lambda 쓰면 한 줄로 처리 가능하니 차후 바꾸자
|
|
struct RemainingAuraCriteria
|
|
{
|
|
RemainingAuraCriteria( const SkillPredicate& pred ) : predicate( pred ) {}
|
|
const SkillPredicate& predicate;
|
|
|
|
const bool operator() ( const Aura& aura ) const { return !predicate( aura.first ); }
|
|
};
|
|
|
|
std::vector< Aura >::iterator removedItems =
|
|
std::stable_partition( m_vAura.begin(), m_vAura.end(), RemainingAuraCriteria( predicate ) );
|
|
|
|
for( std::vector< Aura >::iterator it = removedItems; it != m_vAura.end(); ++it )
|
|
{
|
|
SendAuraMsessage( this, it->first->GetSkillId() );
|
|
}
|
|
|
|
m_vAura.erase( removedItems, m_vAura.end() );
|
|
}
|
|
|
|
template< typename SkillPredicate >
|
|
LearningCost StructCreature::removeSkillFromList( const SkillPredicate& predicate )
|
|
{
|
|
// TODO : lambda 쓰면 한 줄로 처리 가능하니 차후 바꾸자
|
|
struct RemainingSkillCriteria
|
|
{
|
|
RemainingSkillCriteria( const SkillPredicate& pred ) : predicate( pred ) {}
|
|
const SkillPredicate& predicate;
|
|
|
|
const bool operator() ( const StructSkill* skill ) const {
|
|
return ( skill->GetSkillUID() < 0 ) || !predicate( skill );
|
|
}
|
|
};
|
|
|
|
std::vector< StructSkill* >::iterator removedSkills =
|
|
std::stable_partition( m_vAllSkillList.begin(), m_vAllSkillList.end(), RemainingSkillCriteria( predicate ) );
|
|
|
|
LearningCost returnedSkillCost;
|
|
|
|
for( std::vector< StructSkill* >::iterator it = removedSkills; it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
StructSkill* removedSkill = *it;
|
|
|
|
if( removedSkill->IsPassiveSkill() )
|
|
{
|
|
m_vPassiveSkillList.erase( std::find( m_vPassiveSkillList.begin(), m_vPassiveSkillList.end(), removedSkill ) );
|
|
}
|
|
else
|
|
{
|
|
m_vActiveSkillList.erase( std::find( m_vActiveSkillList.begin(), m_vActiveSkillList.end(), removedSkill ) );
|
|
}
|
|
|
|
returnedSkillCost += GetSumOfSkillLearningCost( this, removedSkill->GetSkillId(), 0, removedSkill->GetBaseSkillLevel() );
|
|
|
|
onRemoveSkill( removedSkill );
|
|
|
|
removedSkill->FreeSkill();
|
|
}
|
|
|
|
m_vAllSkillList.erase( removedSkills, m_vAllSkillList.end() );
|
|
|
|
return returnedSkillCost;
|
|
}
|
|
|
|
// 아래 함수에서는 클라쪽으로 스킬 메시지를 보내는 처리를 따로 하지는 않는다.
|
|
// 이는 메시지 처리를 가급적 한꺼번에 처리하도록 하기 위함이다
|
|
template< typename SkillPredicate >
|
|
LearningCost StructCreature::RemoveSkill( const SkillPredicate& predicate )
|
|
{
|
|
LearningCost returnSkillCost;
|
|
|
|
if( IsUsingSkill() )
|
|
{
|
|
CancelSkill();
|
|
}
|
|
|
|
turnOffAuraOnSkillReset( predicate );
|
|
returnSkillCost = removeSkillFromList( predicate );
|
|
|
|
return returnSkillCost;
|
|
}
|
|
|
|
// TODO: RegisterSkill과 중복되는 코드가 잔뜩 있으나 일단은 구현부터 해놓고 나중에 리팩토링
|
|
const bool StructCreature::UpdateSkillLevel( StructSkill* skill, int targetLevel )
|
|
{
|
|
if( targetLevel < 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// JP, TP 소비
|
|
LearningCost cost;
|
|
int prevLevel = skill->GetBaseSkillLevel();
|
|
|
|
if( prevLevel > targetLevel )
|
|
{
|
|
cost = GetSumOfSkillLearningCost( this, skill->GetSkillId(), targetLevel, skill->GetBaseSkillLevel() );
|
|
|
|
cost.jp = -cost.jp;
|
|
cost.tp = -cost.tp;
|
|
}
|
|
else
|
|
{
|
|
cost = GetSumOfSkillLearningCost( this, skill->GetSkillId(), skill->GetBaseSkillLevel(), targetLevel );
|
|
|
|
if( cost.jp > GetJobPoint() || cost.tp > GetTalentPoint() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( cost.jp != 0 ) SetJP( std::max<__int64>( GetJobPoint() - cost.jp, 0 ) ) ;
|
|
if( cost.tp != 0 )
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
if( cost.tp > 0 )
|
|
{
|
|
LOG::Log11N4S( LM_CHARACTER_GAIN_TP, pPlayer->GetAccountID(),
|
|
pPlayer->GetSID(), skill->GetSkillId(),
|
|
pPlayer->GetPrevJobId( pPlayer->GetJobDepth() - 1 ), pPlayer->GetJobId(),
|
|
pPlayer->GetPrevJobLevel( pPlayer->GetJobDepth() - 1 ), pPlayer->GetJobLevel(),
|
|
pPlayer->GetTalentPoint(), pPlayer->GetTalentPoint() - cost.tp,
|
|
skill->GetBaseSkillLevel(), targetLevel,
|
|
pPlayer->GetAccountName(), LOG::STR_NTS,
|
|
pPlayer->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"ByUpdateSkill", LOG::STR_NTS );
|
|
}
|
|
else
|
|
{
|
|
LOG::Log11N4S( LM_CHARACTER_USE_TP, pPlayer->GetAccountID(),
|
|
pPlayer->GetSID(), pPlayer->GetJobId(),
|
|
GetJobLevel(), skill->GetSkillId(),
|
|
skill->GetBaseSkillLevel(), cost.jp,
|
|
pPlayer->GetTalentPoint(), pPlayer->GetTalentPoint() - cost.tp,
|
|
targetLevel, 0,
|
|
pPlayer->GetAccountName(), LOG::STR_NTS,
|
|
pPlayer->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"ByUpdateSkill", LOG::STR_NTS );
|
|
}
|
|
}
|
|
SetTalentPoint( GetTalentPoint() - cost.tp );
|
|
}
|
|
|
|
skill->SetBaseSkillLevel( targetLevel );
|
|
|
|
onRegisterSkill( skill->GetSkillUID(), skill->GetSkillId(), targetLevel, false );
|
|
|
|
return true;
|
|
}
|
|
|
|
// 현재 스킬 트리에서 허용된 레벨 외의 범위에 있는 스킬들의 레벨을 재조정, 스킬 리셋에서 사용한다
|
|
void StructCreature::AdjustOverflowedSkillLevel( const int remainingMaxJobDepth )
|
|
{
|
|
for( std::vector< StructSkill* >::iterator it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it )
|
|
{
|
|
StructSkill* skill = *it;
|
|
if( skill->GetSkillUID() < 0 )
|
|
{ // 시스템 스킬인 경우는 패스
|
|
continue;
|
|
}
|
|
|
|
int allowedSkillLevel = GetAllowedMaxSkillLevel( this, skill, remainingMaxJobDepth );
|
|
|
|
if( allowedSkillLevel < skill->GetBaseSkillLevel() )
|
|
{
|
|
UpdateSkillLevel( skill, allowedSkillLevel );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool StructCreature::ResetSkill( const _SKILL_RESET_METHOD eMethod, const int jobDepth, int doResetRandomSkill )
|
|
{
|
|
if( jobDepth < 0 || jobDepth > GetJobDepth() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
__int64 nPrevJP = GetJobPoint();
|
|
int nPrevTP = GetTalentPoint();
|
|
|
|
if( doResetRandomSkill == 2 )
|
|
{
|
|
bool hasRandomSkill = false;
|
|
bool hasResetRandomSkill = false;
|
|
|
|
for (std::vector< StructSkill* >::iterator it = m_vAllSkillList.begin(); it != m_vAllSkillList.end(); ++it)
|
|
{
|
|
if( (*it)->IsRandomSkill() )
|
|
{
|
|
if ( (*it)->GetCurrentSkillLevel() == 0 )
|
|
hasResetRandomSkill = true;
|
|
else
|
|
hasRandomSkill = true;
|
|
}
|
|
}
|
|
|
|
if (!hasRandomSkill || !hasResetRandomSkill)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
// TODO: 차후 람다로 교체
|
|
struct NotOwnedByRemainingSkillTree
|
|
{
|
|
NotOwnedByRemainingSkillTree( const StructCreature* creature, const int remainingMaxJobDepth, int resetRandomSkill )
|
|
: creature( creature ), remainingMaxJobDepth( remainingMaxJobDepth ), resetRandomSkill( resetRandomSkill ) {}
|
|
|
|
const bool operator() ( const StructSkill* skill ) const
|
|
{
|
|
// 만약 크리쳐 랜덤 스킬일 경우 삭제하지 않는다. (밑에서 skill_level만 0으로 만들어준다.)
|
|
// 단, 강제 초기화 일 경우 스킬 다 날려줌. (resetRandomSkill == true)
|
|
if( !resetRandomSkill && creature->IsSummon() && skill->IsRandomSkill() )
|
|
{
|
|
return false;
|
|
}
|
|
if( resetRandomSkill == 2 && creature->IsSummon() && ( !skill->IsRandomSkill() || skill->GetBaseSkillLevel() > 0 ) )
|
|
{
|
|
return false;
|
|
}
|
|
// 남아 있어야하는 스킬 트리에서 허용 레벨이 0 -> 삭제 대상
|
|
return GetAllowedMaxSkillLevel( creature, skill, remainingMaxJobDepth ) == 0;
|
|
}
|
|
const StructCreature* creature;
|
|
int remainingMaxJobDepth;
|
|
int resetRandomSkill;
|
|
};
|
|
|
|
// 스킬 초기화 후 포인트 반납
|
|
LearningCost returnedSkillCost = RemoveSkill( NotOwnedByRemainingSkillTree( this, jobDepth-1, doResetRandomSkill ) );
|
|
|
|
// AziaMafia CP Change
|
|
SetJP( GetJobPoint() + returnedSkillCost.jp );
|
|
//if (IsSummon()) SetJP(GetJobPoint() + returnedSkillCost.jp);
|
|
|
|
if( returnedSkillCost.tp )
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
LOG::Log11N4S( LM_CHARACTER_GAIN_TP, pPlayer->GetAccountID(),
|
|
pPlayer->GetSID(), 0,
|
|
pPlayer->GetPrevJobId( pPlayer->GetJobDepth() - 1 ), pPlayer->GetJobId(),
|
|
pPlayer->GetPrevJobLevel( pPlayer->GetJobDepth() - 1 ), pPlayer->GetJobLevel(),
|
|
pPlayer->GetTalentPoint(), pPlayer->GetTalentPoint() + returnedSkillCost.tp,
|
|
0, 0,
|
|
pPlayer->GetAccountName(), LOG::STR_NTS,
|
|
pPlayer->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"ByResetSkill", LOG::STR_NTS );
|
|
}
|
|
SetTalentPoint( GetTalentPoint() + returnedSkillCost.tp );
|
|
}
|
|
|
|
// 크리쳐의 경우 남아 있는 랜덤 스킬들을 0으로 업데이트 시켜줌. 여기서 0으로 업데이트 된 애들 스킬 포인트 반납
|
|
if( IsSummon() )
|
|
{
|
|
// 남아있는 랜덤 스킬들의 경우 0으로 업데이트 시켜준다.
|
|
for( std::vector< StructSkill* >::iterator it = m_vAllSkillList.begin() ; it != m_vAllSkillList.end() ; ++it )
|
|
{
|
|
if( doResetRandomSkill != 2 )
|
|
UpdateSkillLevel((*it), 0);
|
|
}
|
|
}
|
|
|
|
if( jobDepth > 0 )
|
|
{
|
|
// 현재 스킬 트리로는 찍을 수 없는 일부 스킬이 남아 있을 수 있다.
|
|
// 이 경우는 스킬 리스트에서 남아 있는 녀석들을 대상으로 스킬 레벨을 업데이트하자
|
|
AdjustOverflowedSkillLevel( jobDepth-1 );
|
|
}
|
|
|
|
CalculateStat();
|
|
onResetSkill( jobDepth );
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
const StructPlayer * pPlayer = static_cast< const StructPlayer * >( this );
|
|
LOG::Log11N4S( LM_SKILL_RESET, pPlayer->GetAccountID(), pPlayer->GetPlayerUID(), 0, eMethod, nPrevJP, nPrevTP, GetJobPoint(), GetTalentPoint(), 0, 0, 0,
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "", 0 );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
const StructSummon * pSummon = static_cast< const StructSummon * >( this );
|
|
const StructPlayer * pPlayer = pSummon->GetMaster();
|
|
// pPlayer == NULL 일 가능성이 작지만 있으므로 pPlayer 참조 부분에 모두 NULL 체크해서 대체 값이 존재하도록 처리해야 함
|
|
LOG::Log11N4S( LM_SKILL_RESET,
|
|
( pPlayer ) ? pPlayer->GetAccountID() : 0,
|
|
( pPlayer ) ? pPlayer->GetPlayerUID() : 0,
|
|
pSummon->GetSummonSID(), eMethod, nPrevJP, nPrevTP, GetJobPoint(), GetTalentPoint(), 0, 0, 0,
|
|
( pPlayer ) ? pPlayer->GetAccountName() : "", LOG::STR_NTS,
|
|
( pPlayer ) ? pPlayer->GetName() : "", LOG::STR_NTS,
|
|
pSummon->GetName(), LOG::STR_NTS, "", 0 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
__int64 StructCreature::GetAllSkillJP() const
|
|
{
|
|
int nJobId[GameRule::MAX_JOB_DEPTH];
|
|
int nJobDepth = GetJobDepth();
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < nJobDepth; ++i )
|
|
{
|
|
nJobId[i] = GetPrevJobId(i);
|
|
}
|
|
|
|
nJobId[i] = GetJobId();
|
|
|
|
__int64 nJP = 0;
|
|
|
|
// 지금 가지고 있는 스킬들 배우는데 필요한 잡포 계산
|
|
for( std::vector< StructSkill * >::const_iterator it = m_vAllSkillList.begin() ; it != m_vAllSkillList.end() ; it++ )
|
|
{
|
|
StructSkill *pSkill = (*it);
|
|
|
|
if( (*it)->GetSkillUID() == StructSkill::SKILL_UID_ITEM_SKILL ||
|
|
(*it)->GetSkillUID() == StructSkill::SKILL_UID_PROP_SKILL ||
|
|
(*it)->GetSkillUID() == StructSkill::SKILL_UID_SUMMON_SKILL ||
|
|
(*it)->GetSkillUID() == StructSkill::SKILL_UID_MONSTER_SKILL ||
|
|
(*it)->GetSkillUID() == StructSkill::SKILL_UID_PET_SKILL ||
|
|
(*it)->GetSkillUID() == StructSkill::SKILL_UID_BOOSTER_SKILL )
|
|
continue;
|
|
|
|
for( int nSkillLevel = pSkill->GetBaseSkillLevel() ; nSkillLevel > 0 ; nSkillLevel-- )
|
|
{
|
|
int jp = -1;
|
|
|
|
i = 0;
|
|
|
|
while( jp == -1 && i <= nJobDepth )
|
|
{
|
|
if( IsSummon() )
|
|
{
|
|
SummonBase *pBase = GameContent::GetSummonInfo( nJobId[i++] );
|
|
if( !pBase )
|
|
continue;
|
|
|
|
for( int j = 0 ; j < GameRule::MAX_SUMMON_SKILL_TREE && jp == -1 ; ++j )
|
|
{
|
|
if( !pBase->skill_tree_id[j] )
|
|
continue;
|
|
|
|
jp = GameContent::GetNeedJpForSkillLevelUp( pSkill->GetSkillId(), nSkillLevel, pBase->skill_tree_id[j] );
|
|
}
|
|
}
|
|
else if( IsPlayer() )
|
|
{
|
|
const JobInfo *pInfo = GameContent::GetJobInfo( nJobId[i++] );
|
|
if( !pInfo || !pInfo->skill_tree_id )
|
|
continue;
|
|
|
|
jp = GameContent::GetNeedJpForSkillLevelUp( pSkill->GetSkillId(), nSkillLevel, pInfo->skill_tree_id );
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if( jp != -1 )
|
|
{
|
|
nJP += jp;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nJP;
|
|
}
|
|
|
|
__int64 StructCreature::GetAllJobLevelJP() const
|
|
{
|
|
__int64 nJP = 0;
|
|
int nJobLevel = GetJobLevel();
|
|
int nJobDepth = GetJobDepth();
|
|
|
|
for( int i = 1 ; i < nJobLevel ; ++i )
|
|
{
|
|
nJP += GameContent::GetNeedJpForJobLevelUp( i, nJobDepth );
|
|
}
|
|
|
|
return nJP;
|
|
}
|
|
|
|
int StructCreature::IsLearnableSkill( int nSkillID, int nSkillLevel, int *nSkillTreeID )
|
|
{
|
|
return RESULT_ACCESS_DENIED;
|
|
}
|
|
|
|
int StructCreature::GetBaseSkillLevel( int skill_id ) const
|
|
{
|
|
StructSkill *pSkill = getSkill( skill_id );
|
|
if( !pSkill ) return 0;
|
|
return pSkill->GetBaseSkillLevel();
|
|
}
|
|
|
|
int StructCreature::GetAddedSkillLevel( const StructSkill *const pSkill ) const
|
|
{
|
|
// if( pSkill->IsLimitedAddedSkill() ) return 0; // AziaMafia Skill ++
|
|
|
|
std::vector< std::pair< int, int > >::const_iterator it;
|
|
|
|
int skill_id = pSkill->GetSkillId();
|
|
int skill_type = 0;
|
|
int addedSkillLevel = 0;
|
|
|
|
// 스킬의 타입을 정의
|
|
if( pSkill->GetSkillBase()->IsHarmful() ) skill_type += StructState::FLAG_HARMFUL;
|
|
else skill_type += StructState::FLAG_HELPFUL;
|
|
|
|
if( pSkill->GetSkillBase()->IsPassive() ) skill_type += StructState::FLAG_PASSIVE;
|
|
else skill_type += StructState::FLAG_ACTIVE;
|
|
|
|
if( pSkill->GetSkillBase()->IsPhysicalSkill() ) skill_type += StructState::FLAG_PHYSICAL;
|
|
else skill_type += StructState::FLAG_MAGICAL;
|
|
|
|
for( it = m_vAddedSkillBySkillId.begin(); it != m_vAddedSkillBySkillId.end(); it++ )
|
|
{
|
|
if( (*it).first == skill_id )
|
|
{
|
|
addedSkillLevel += (*it).second;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( it = m_vAddedSkillBySkillType.begin(); it != m_vAddedSkillBySkillType.end(); it++ )
|
|
{
|
|
if( (*it).first & skill_type )
|
|
{
|
|
if( !pSkill->IsLimitedAddedSkill() ) // AziaMafia Skill ++
|
|
addedSkillLevel += (*it).second;
|
|
}
|
|
}
|
|
|
|
if( addedSkillLevel < 0 && addedSkillLevel < this->GetBaseSkillLevel( skill_id ) )
|
|
addedSkillLevel = -this->GetBaseSkillLevel( skill_id );
|
|
|
|
|
|
|
|
return addedSkillLevel;
|
|
}
|
|
|
|
int StructCreature::GetCurrentSkillLevel( int skill_id ) const
|
|
{
|
|
StructSkill *pSkill = getSkill( skill_id );
|
|
if( !pSkill ) return 0;
|
|
return pSkill->GetCurrentSkillLevel();
|
|
}
|
|
|
|
|
|
|
|
int StructCreature::GetCurrentSkillEnchant(int skill_id) const
|
|
{
|
|
StructSkill* pSkill = getSkill(skill_id);
|
|
if (!pSkill) return 0;
|
|
return pSkill->GetEnhance();
|
|
}
|
|
|
|
void StructCreature::AddRemainCoolTime( const int skill_id, const int nInc, const float fAmp )
|
|
{
|
|
StructPlayer * pClient = NULL;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( this );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
pClient = static_cast< StructSummon * >( this )->GetMaster();
|
|
}
|
|
|
|
if( skill_id < 0 )
|
|
{
|
|
struct _mySkillFunctor : SKILL_POINTER_FUNCTOR
|
|
{
|
|
_mySkillFunctor( const bool _bExceptRulerOfTime, const int _nInc, const float _fAmp ) : tCurrentTime( GetArTime() ), bExceptRulerOfTime( _bExceptRulerOfTime ), nInc( _nInc ), fAmp( _fAmp ) {}
|
|
|
|
virtual void onSkill( StructSkill *pSkill )
|
|
{
|
|
// 은총 스킬은 전직업 공통 스킬로 시스템 스킬의 의도로 들어갔기 때문에 쿨타임 제어에 영향을 받지 않아야 한다.
|
|
if( pSkill->GetSkillId() == StructSkill::SKILL_GRACE ) return;
|
|
|
|
// 시간의 지배자의 쿨타임 값을 변경하지 않아야하는 경우는 변경하지 않도록 한다.
|
|
if( bExceptRulerOfTime && pSkill->GetSkillId() == StructSkill::SKILL_RULER_OF_TIME ) return;
|
|
|
|
if( pSkill->CheckCoolTime( tCurrentTime ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 현재는 증가와 증폭이 동시에 적용되지 않는다.
|
|
// ArTime은 1/100초
|
|
pSkill->SetRemainCoolTime( pSkill->GetRemainCoolTime( tCurrentTime ) * fAmp + nInc * 100 );
|
|
|
|
vSkill.push_back( pSkill->GetSkillId() );
|
|
}
|
|
|
|
AR_TIME tCurrentTime;
|
|
std::vector< int > vSkill;
|
|
bool bExceptRulerOfTime;
|
|
int nInc;
|
|
float fAmp;
|
|
} foCooldown( ( m_pCastSkill && m_pCastSkill->GetSkillId() == StructSkill::SKILL_RULER_OF_TIME ), nInc, fAmp );
|
|
|
|
EnumActiveSkill( foCooldown );
|
|
|
|
SendSkillMessage( pClient, this, foCooldown.vSkill );
|
|
}
|
|
else
|
|
{
|
|
// 은총 스킬은 전직업 공통 스킬로 시스템 스킬의 의도로 들어갔기 때문에 쿨타임 제어에 영향을 받지 않아야 한다.
|
|
if( skill_id == StructSkill::SKILL_GRACE ) return;
|
|
|
|
AR_TIME tCurrentTime = GetArTime();
|
|
|
|
StructSkill *pSkill = GetSkill( skill_id );
|
|
|
|
if( !pSkill || pSkill->GetSkillUID() <= 0 || pSkill->CheckCoolTime( tCurrentTime ) ) return;
|
|
|
|
// 현재는 증가와 증폭이 동시에 적용되지 않는다.
|
|
// ArTime은 1/100초
|
|
pSkill->SetRemainCoolTime( pSkill->GetRemainCoolTime( tCurrentTime ) * fAmp + nInc * 100 );
|
|
|
|
SendSkillMessage( pClient, this, skill_id );
|
|
}
|
|
}
|
|
|
|
AR_TIME StructCreature::GetRemainCoolTime( int skill_id ) const
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
if( ENV().GetInt( "game.no_skill_cooltime", 0 ) )
|
|
return 0;
|
|
|
|
StructSkill *pSkill = getSkill( skill_id );
|
|
if( !pSkill ) return 0;
|
|
return pSkill->GetRemainCoolTime( t );
|
|
}
|
|
|
|
AR_TIME StructCreature::GetTotalCoolTime( int skill_id ) const
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
if( ENV().GetInt( "game.no_skill_cooltime", 0 ) )
|
|
return 0;
|
|
|
|
StructSkill *pSkill = getSkill( skill_id );
|
|
if( !pSkill ) return 0;
|
|
return pSkill->GetSkillCoolTime();
|
|
}
|
|
|
|
const __int64 StructCreature::GetBulletCount() const
|
|
{
|
|
return 1; // Full Bullet
|
|
StructItem* pBullet = GetWearedItem(ItemBase::WEAR_BULLET);
|
|
|
|
return (pBullet && pBullet->IsBullet()) ? pBullet->GetCount() : 0;
|
|
}
|
|
|
|
void StructCreature::BindSkillCard( struct StructItem *pItem, const bool bSkipDBUpdate )
|
|
{
|
|
StructSkill *pSkill = getSkill( pItem->GetSkillId() );
|
|
if( !pSkill ) return;
|
|
|
|
pSkill->SetEnhance( pItem->GetItemEnhance() );
|
|
|
|
pItem->SetBindTarget( this, bSkipDBUpdate );
|
|
|
|
SendSkillCardInfo( pItem );
|
|
|
|
// 다만 스킬 카드가 2개 이상일 경우 나머지 카드들은 빼서 뒤로 넣어준다
|
|
if( pItem->GetCount() > 1 )
|
|
{
|
|
StructPlayer * pClient;
|
|
if( IsPlayer() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( this );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( static_cast< StructSummon* >( this )->GetMaster() );
|
|
}
|
|
|
|
|
|
|
|
StructItem * pItemOriginal = pItem;
|
|
int nCount = pItemOriginal->GetCount();
|
|
pItemOriginal->SetCount( 1 );
|
|
SendItemMessage( pClient, pItemOriginal );
|
|
|
|
pItem = StructItem::AllocItem( 0, pItem->GetItemCode(), 1, ItemInstance::BY_DIVIDE );
|
|
pItem->CopyFrom( pItemOriginal );
|
|
pItem->SetBindTarget( NULL );
|
|
pItem->SetCount( nCount - 1 );
|
|
pItem->SetIdx( 0 );
|
|
pClient->PushItem( pItem, nCount - 1 );
|
|
|
|
// 아이템 추적을 위해 분리되면 로그로 기록해준다.
|
|
LOG::Log11N4S( LM_ITEM_DIVIDE, pClient->GetAccountID(),
|
|
pClient->GetSID(), pItem->GetItemEnhance() * 100 + pItem->GetItemLevel(),
|
|
pItem->GetItemCode(), pItem->GetCount(),
|
|
pItemOriginal->GetCount(), pClient->GetGold().GetRawData(),
|
|
0, 0,
|
|
pItemOriginal->GetItemUID(), pItem->GetItemUID(),
|
|
pClient->GetAccountName(), LOG::STR_NTS,
|
|
pClient->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"CARD_BIND", LOG::STR_NTS );
|
|
|
|
|
|
}
|
|
}
|
|
|
|
void StructCreature::UnBindSkillCard( struct StructItem *pItem )
|
|
{
|
|
// 해제는 할 수 있어야 한다.
|
|
StructSkill *pSkill = getSkill( pItem->GetSkillId() );
|
|
if( pSkill )
|
|
pSkill->SetEnhance( 0 );
|
|
|
|
pItem->SetBindTarget( NULL );
|
|
|
|
SendSkillCardInfo( pItem );
|
|
|
|
// 스킬 카드 해제 시 같은 카드들이 인벤에 있나 보고 있다면 가져와서 합쳐준다.
|
|
StructPlayer * pClient = NULL;
|
|
if( IsPlayer() )
|
|
{
|
|
pClient = static_cast< StructPlayer * >( this );
|
|
}
|
|
if( IsSummon() )
|
|
{
|
|
pClient = static_cast< StructSummon * >( this )->GetMaster();
|
|
}
|
|
|
|
StructItem *pJoinableItem = pClient->GetInventory()->FindJoinablePair( pItem );
|
|
if( pJoinableItem )
|
|
{
|
|
int nCount = pJoinableItem->GetCount();
|
|
pClient->PopItem( pJoinableItem, nCount );
|
|
pItem->SetCount( nCount + 1 );
|
|
SendItemMessage( pClient, pItem );
|
|
|
|
// 아이템 추적을 위해 합쳐지면 로그로 기록해준다.
|
|
LOG::Log11N4S( LM_ITEM_JOIN, pClient->GetAccountID(),
|
|
pClient->GetSID(), pJoinableItem->GetItemEnhance() * 100 + pJoinableItem->GetItemLevel(),
|
|
pJoinableItem->GetItemCode(), pJoinableItem->GetCount(),
|
|
pItem->GetCount(), pClient->GetGold().GetRawData(),
|
|
0, 0,
|
|
pItem->GetItemUID(), pJoinableItem->GetItemUID(),
|
|
pClient->GetAccountName(), LOG::STR_NTS,
|
|
pClient->GetName(), LOG::STR_NTS,
|
|
"", 0,
|
|
"CARD_UNBIND", LOG::STR_NTS );
|
|
}
|
|
}
|
|
|
|
AR_HANDLE StructCreature::GetTrapHandle()
|
|
{
|
|
if( !m_hTrap )
|
|
return NULL;
|
|
|
|
GameObject *pObj = GameObject::raw_get( m_hTrap );
|
|
if( !pObj || !pObj->IsSkillProp() || !pObj->IsInWorld() || pObj->IsDeleteRequested() )
|
|
{
|
|
m_hTrap = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
return m_hTrap;
|
|
}
|
|
|
|
bool StructCreature::IsWearShield() const
|
|
{
|
|
StructItem * pShield = GetWearedItem( ItemBase::WEAR_SHIELD );
|
|
return pShield ? pShield->GetItemClass() == ItemBase::CLASS_SHIELD : false;
|
|
}
|
|
|
|
bool StructCreature::IsWeared( AR_HANDLE ItemHandle )
|
|
{
|
|
StructItem *pItem = StructItem::FindItem( ItemHandle );
|
|
if( !pItem ) return false;
|
|
|
|
for( int i = 0; i < ItemBase::MAX_SPARE_ITEM_WEAR; ++i )
|
|
{
|
|
if( m_anWear[i] == pItem ) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool StructCreature::IsWeared( ItemBase::ItemCode code )
|
|
{
|
|
|
|
for( int i = 0; i < ItemBase::MAX_SPARE_ITEM_WEAR; ++i )
|
|
{
|
|
if( m_anWear[i] )
|
|
{
|
|
if( m_anWear[i]->GetItemCode() == code )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool StructCreature::TranslateWearPosition( ItemBase::ItemWearType & pos, struct StructItem *pItem, std::vector< int > * vpOverlappItemList )
|
|
{
|
|
// 장비품 아님
|
|
if( pItem->GetWearType() == ItemBase::WEAR_CANTWEAR && !pItem->IsChaosStone() ) return false;
|
|
|
|
// 파기되었는지?
|
|
if( !pItem->IsWearable() ) return false;
|
|
|
|
// 유니트 익스퍼트 스킬이 있으면 랭크 무시하고 장착 가능하다고 함.
|
|
int nMyLevel = m_nUnitExpertLevel > GetLevel() ? m_nUnitExpertLevel : GetLevel();
|
|
|
|
if( pItem->GetLevelLimit() > nMyLevel ) return false;
|
|
|
|
// 장비 아이템에 레벨 제한 설정이 별도로 걸려 있을 경우 해당 레벨 제한을 확인
|
|
// 최소 레벨 체크
|
|
if( pItem->GetItemBase().nMinLevel && GetLevel() < pItem->GetItemBase().nMinLevel )
|
|
return false;
|
|
// 최대 레벨 체크
|
|
if( pItem->GetItemBase().nMaxLevel && GetLevel() > pItem->GetItemBase().nMaxLevel )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
unsigned short StructCreature::putonItem( ItemBase::ItemWearType pos, struct StructItem * pItem )
|
|
{
|
|
assert( pos < ItemBase::MAX_SPARE_ITEM_WEAR );
|
|
|
|
assert( !m_anWear[ pos ] );
|
|
|
|
m_anWear[ pos ] = pItem;
|
|
|
|
// floyd 2008. 7..3
|
|
// http://bug.nflavor.com/view.php?id=3380 관련 문제를 처리하다 수정
|
|
// StructSummon::putonItem에서 처리하면 굳이 IsSummon() 확인 할 필요가 없다.
|
|
// if( IsSummon() )
|
|
// {
|
|
// pItem->SetOwnSummonInfo( GetHandle(), GetSID() );
|
|
// }
|
|
|
|
pItem->SetWearInfo( pos );
|
|
|
|
pItem->SetBindedCreatureHandle( GetHandle() );
|
|
|
|
pItem->TurnOnUpdateFlag();
|
|
|
|
if( ( pItem->IsBow() || pItem->IsCrossBow() ) && pos < ItemBase::MAX_ITEM_WEAR )
|
|
{
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
}
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
SendItemWearInfoMessage( static_cast< StructPlayer* >( this ), this, m_anWear[ pos ] );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
SendItemWearInfoMessage( static_cast< StructPlayer* >( static_cast< StructSummon * >(this)->GetMaster() ), this, m_anWear[ pos ] );
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short StructCreature::putoffItem( ItemBase::ItemWearType pos )
|
|
{
|
|
assert( pos < ItemBase::MAX_SPARE_ITEM_WEAR );
|
|
|
|
m_anWear[ pos ]->SetWearInfo( static_cast< ItemBase::ItemWearType >( -1 ) );
|
|
|
|
m_anWear[ pos ]->SetBindedCreatureHandle( NULL );
|
|
|
|
m_anWear[ pos ]->TurnOnUpdateFlag();
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
SendItemWearInfoMessage( static_cast< StructPlayer* >( this ), this, m_anWear[ pos ] );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
SendItemWearInfoMessage( static_cast< StructPlayer* >( static_cast< StructSummon * >(this)->GetMaster() ), this, m_anWear[ pos ] );
|
|
}
|
|
|
|
m_anWear[ pos ] = NULL;
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
void StructCreature::PutonSet( struct StructItem* pItemList[] )
|
|
{
|
|
int idx = 0;
|
|
|
|
// 일단 다 벗자
|
|
for( idx = 0; idx < ItemBase::MAX_ITEM_WEAR; ++idx )
|
|
{
|
|
if( m_anWear[idx] ) putoffItem( static_cast< ItemBase::ItemWearType >( idx ) );
|
|
}
|
|
|
|
// 다 입자
|
|
for( idx = 0; idx < ItemBase::MAX_ITEM_WEAR; ++idx )
|
|
{
|
|
if( ! ( pItemList[idx] ) ) continue;
|
|
|
|
Puton( static_cast< ItemBase::ItemWearType >( idx ), pItemList[idx] );
|
|
}
|
|
|
|
// 스탯 재계산
|
|
CalculateStat();
|
|
}
|
|
|
|
unsigned short StructCreature::Puton( ItemBase::ItemWearType pos, struct StructItem * pItem )
|
|
{
|
|
if( pItem->IsChaosStone() )
|
|
{
|
|
pos = ItemBase::WEAR_CHAOS_STONE;
|
|
}
|
|
|
|
if( !pItem->IsInInventory() )
|
|
{
|
|
// _cprint( "StructCreature::Puton() :: 장비 불가 : (%I64d)\n", pItem->GetItemUID() );
|
|
return RESULT_ACCESS_DENIED;
|
|
}
|
|
|
|
if( pItem->GetWearInfo() != ItemBase::WEAR_NONE )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
std::vector< int > vOverlappItemList;
|
|
|
|
if( !TranslateWearPosition( pos, pItem, &vOverlappItemList ) )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
// 장착 위치에 무언가 입고 있다면 벗는다
|
|
for( std::vector< int >::iterator it = vOverlappItemList.begin(); it != vOverlappItemList.end(); it++ )
|
|
{
|
|
putoffItem( static_cast< ItemBase::ItemWearType >( *it ) );
|
|
|
|
if( m_anWear[ *it ] ) return RESULT_NOT_ACTABLE; // 벗기 실패. (목걸이 같은 경우)
|
|
}
|
|
|
|
// 장착
|
|
return putonItem( pos, pItem );
|
|
}
|
|
|
|
unsigned short StructCreature::Putoff( ItemBase::ItemWearType pos )
|
|
{
|
|
// 두손무기는 오른손이므로..
|
|
if( pos == ItemBase::WEAR_TWOHAND ) pos = ItemBase::WEAR_WEAPON;
|
|
|
|
// 예외처리 #3. 투슬롯 반지를 장착해야 하는데 이미 오른쪽에 반지를 입고 있으면 벗는다
|
|
if( pos == ItemBase::WEAR_TWOFINGER_RING )
|
|
{
|
|
pos = ItemBase::WEAR_RING;
|
|
}
|
|
|
|
// 검증
|
|
if( ( pos >= ItemBase::MAX_SPARE_ITEM_WEAR && pos != ItemBase::WEAR_TWOHAND ) || pos < 0 )
|
|
{
|
|
// _cprint( "StructCreature::Putoff() :: 잘못된 탈착위치 : %d\n", pos );
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
// 입고있는 상태가 아니라면 실패
|
|
ItemBase::ItemWearType absolute_pos = GetAbsoluteWearPos( pos );
|
|
if( absolute_pos == static_cast< ItemBase::ItemWearType >( -1 ) )
|
|
{
|
|
return RESULT_NOT_ACTABLE;
|
|
}
|
|
|
|
// 장착된 가방을 해제하려 할 때 최대 무게치보다 소지량이 커지면 불가
|
|
if( pos == ItemBase::WEAR_BAG_SLOT )
|
|
{
|
|
if( GetMaxWeight() < GetWeight() )
|
|
{
|
|
return RESULT_TOO_HEAVY;
|
|
}
|
|
|
|
const ItemBaseServer & current_bag_base = m_anWear[ absolute_pos ]->GetItemBase();
|
|
c_fixed10 current_bag_capacity;
|
|
|
|
for( int i = 0 ; i < ItemBase::MAX_OPTION_NUMBER ; ++i )
|
|
{
|
|
if( current_bag_base.nOptType[ i ] != ITEM_EFFECT_PASSIVE::CARRY_WEIGHT )
|
|
continue;
|
|
|
|
current_bag_capacity += current_bag_base.fOptVar1[ i ];
|
|
}
|
|
|
|
// 가방에는 소울스톤 세공이 불가능하므로 소울스톤 중에 소지량 증가 성능이 있는 경우를 체크할 필요는 없음
|
|
|
|
if( current_bag_base.pvEffectList && !current_bag_base.pvEffectList->empty() )
|
|
{
|
|
for( std::vector< EffectInfo * >::const_iterator it = current_bag_base.pvEffectList->begin() ; it != current_bag_base.pvEffectList->end() ; ++it )
|
|
{
|
|
EffectInfo * pEffect = (*it);
|
|
if( pEffect->nMinLevel && GetLevel() < pEffect->nMinLevel ) continue;
|
|
if( pEffect->nMaxLevel && GetLevel() > pEffect->nMaxLevel ) continue;
|
|
|
|
if( pEffect->eType != EffectInfo::EFFECT_TYPE_OPTIONAL )
|
|
continue;
|
|
|
|
if( pEffect->fValue[ 0 ] == ITEM_EFFECT_PASSIVE::CARRY_WEIGHT ) current_bag_capacity += pEffect->fValue[ 1 ];
|
|
if( pEffect->fValue[ 3 ] == ITEM_EFFECT_PASSIVE::CARRY_WEIGHT ) current_bag_capacity += pEffect->fValue[ 4 ];
|
|
if( pEffect->fValue[ 6 ] == ITEM_EFFECT_PASSIVE::CARRY_WEIGHT ) current_bag_capacity += pEffect->fValue[ 7 ];
|
|
if( pEffect->fValue[ 9 ] == ITEM_EFFECT_PASSIVE::CARRY_WEIGHT ) current_bag_capacity += pEffect->fValue[ 10 ];
|
|
}
|
|
}
|
|
|
|
current_bag_capacity *= m_fItemMod;
|
|
|
|
if( GetMaxWeight() - current_bag_capacity < GetWeight() )
|
|
{
|
|
return RESULT_TOO_HEAVY;
|
|
}
|
|
}
|
|
|
|
// 벗자
|
|
return putoffItem( absolute_pos );
|
|
}
|
|
|
|
void StructCreature::ProcByAttack( StructCreature *pTarget, const int nDamage, const bool bIsAttacking, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
std::vector< _ATTACK_TAG > *pvProc;
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
if( bIsAttacking ) pvProc = &m_vProcByAttack;
|
|
else pvProc = &m_vProcByBeingAttacked;
|
|
|
|
std::vector< _ATTACK_TAG >::const_iterator it;
|
|
for( it = pvProc->begin(); it != pvProc->end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByAttack( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1, nAttackType, nElementalType ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, nDamage, bIsAttacking );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcBySkillId( StructCreature *pTarget, const int nDamage, const bool bIsAttacking, const int nSkillId )
|
|
{
|
|
std::map< int, std::vector< _PROC_TAG > >::iterator foundIt = m_mapProcBySkillId.find( nSkillId );
|
|
if( foundIt == m_mapProcBySkillId.end() ) return;
|
|
|
|
std::vector< _PROC_TAG > *pvProc = &(*foundIt).second;
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
std::vector< _PROC_TAG >::const_iterator it;
|
|
for( it = pvProc->begin(); it != pvProc->end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProc( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1 ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, nDamage, bIsAttacking );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcByKill( StructCreature *pTarget, const bool bIsKilling )
|
|
{
|
|
std::vector< _KILL_TAG > *pvProc;
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
if( bIsKilling ) pvProc = &m_vProcByKill;
|
|
else pvProc = &m_vProcByDead;
|
|
|
|
std::vector< _KILL_TAG >::const_iterator it;
|
|
for( it = pvProc->begin(); it != pvProc->end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByDead( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1, GetLevel() - pTarget->GetLevel(), GetMPPercentage() ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, 0, bIsKilling );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcByCritical( StructCreature *pTarget, const int nDamage, const bool bIsAttacking, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
std::vector< _ATTACK_TAG > *pvProc;
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
if( bIsAttacking ) pvProc = &m_vProcByCriticalAttack;
|
|
else pvProc = &m_vProcByBeingCriticalAttacked;
|
|
|
|
std::vector< _ATTACK_TAG >::const_iterator it;
|
|
for( it = pvProc->begin(); it != pvProc->end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByAttack( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1, nAttackType, nElementalType ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, nDamage, bIsAttacking );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcByAvoid( StructCreature *pFrom, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
std::vector< _ATTACK_TAG >::const_iterator it;
|
|
for( it = m_vProcByAvoid.begin(); it != m_vProcByAvoid.end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByAttack( GetHPPercentage(), pFrom ? pFrom->GetHPPercentage() : -1, nAttackType, nElementalType ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pFrom, 0, false );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcByBlock( StructCreature *pTarget, const int nDamage, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
std::vector< _ATTACK_TAG >::const_iterator it;
|
|
for( it = m_vProcByBlock.begin(); it != m_vProcByBlock.end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByAttack( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1, nAttackType, nElementalType ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, nDamage, false );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProcByPerfectBlock( StructCreature *pTarget, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
std::vector< StructProc * > vActableProc;
|
|
|
|
std::vector< _ATTACK_TAG >::const_iterator it;
|
|
for( it = m_vProcByPerfectBlock.begin(); it != m_vProcByPerfectBlock.end(); ++it )
|
|
{
|
|
// 타겟이 존재하지 않는 경우에도 정상 호출이 되어야 하는 경우가 있으므로 우선 검사한다.
|
|
if( (*it).CheckProcByAttack( GetHPPercentage(), pTarget ? pTarget->GetHPPercentage() : -1, nAttackType, nElementalType ) )
|
|
{
|
|
vActableProc.push_back( (*it).proc->Clone() );
|
|
}
|
|
}
|
|
|
|
std::vector< StructProc * >::iterator procIt;
|
|
for( procIt = vActableProc.begin(); procIt != vActableProc.end(); ++procIt )
|
|
{
|
|
(*procIt)->Proc( this, pTarget, 0, false );
|
|
delete (*procIt);
|
|
}
|
|
}
|
|
|
|
void StructCreature::Attack( StructCreature *pTarget, AR_TIME t, AR_TIME attack_interval, struct StructCreature::_ATTACK_INFO * arDamage, bool & bIsDoubleAttack )
|
|
{
|
|
if( !t ) t = GetArTime();
|
|
|
|
// 공격 시간 설정
|
|
SetNextAttackableTime( t + attack_interval );
|
|
|
|
// 초기화
|
|
|
|
int nHate = 0;
|
|
int nAttackCount = 1;
|
|
|
|
bIsDoubleAttack = false;
|
|
|
|
if( IsUsingDoubleWeapon() )
|
|
nAttackCount *= 2; // 아픔 두배
|
|
|
|
if( XRandom() % 100 < m_Attribute.fDoubleAttackRatio )
|
|
{
|
|
bIsDoubleAttack = true;
|
|
nAttackCount *= 2; // 아픔 두배
|
|
}
|
|
|
|
for( int i = 0; i < nAttackCount; ++i )
|
|
{
|
|
bool bLeftHandAttack = IsUsingDoubleWeapon() && i % 2; // 양손 공격이고 두번째 공격이면 왼손 공격입니다아~
|
|
|
|
int prev_target_hp = pTarget->GetHP();
|
|
int prev_target_mp = pTarget->GetMP();
|
|
int prev_hp = GetHP();
|
|
int prev_mp = GetMP();
|
|
|
|
if( bLeftHandAttack )
|
|
{
|
|
arDamage[i].SetDamageInfo( pTarget->DealPhysicalNormalLeftHandDamage( this, GetAttackPointLeft(), Elemental::TYPE_NONE, 0, 0 ) );
|
|
}
|
|
else
|
|
{
|
|
arDamage[i].SetDamageInfo( pTarget->DealPhysicalNormalDamage( this, GetAttackPointRight(), Elemental::TYPE_NONE, 0, 0 ) );
|
|
}
|
|
|
|
bool bSuccess = !arDamage[i].bMiss;
|
|
|
|
if( bSuccess )
|
|
{
|
|
// 소울스톤 내구도 감소
|
|
StructItem *pItem = m_anWear[ ItemBase::WEAR_RIGHTHAND ];
|
|
if( bLeftHandAttack )
|
|
{
|
|
pItem = m_anWear[ ItemBase::WEAR_LEFTHAND ];
|
|
}
|
|
|
|
|
|
// AziaMafia No Endurence
|
|
/*
|
|
if( pItem && pItem->GetCurrentEndurance() > 0 && pItem->GetUsingSocketCount() > 0 )
|
|
{
|
|
int nPrevEndurance = pItem->GetCurrentEndurance();
|
|
pItem->SetCurrentEndurance( pItem->GetCurrentEndurance() - GameRule::ENDURANCE_REDUCE_ON_ATTACK );
|
|
if( GameRule::GetDecreasedEndurancePoint( nPrevEndurance, pItem->GetCurrentEndurance() ) > 0 )
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
SendItemMessage( static_cast< StructPlayer * >( this ), pItem );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
StructPlayer *pMaster = static_cast< StructSummon * >( this )->GetMaster();
|
|
if( pMaster && pMaster->IsLogin() && pMaster->IsInWorld() )
|
|
{
|
|
SendItemMessage( pMaster, pItem );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( pItem->GetCurrentEndurance() == 0 )
|
|
SetNeedCalculateStat();
|
|
}
|
|
*/
|
|
}
|
|
|
|
// 여기서 한번 더 보정
|
|
arDamage[i].nDamage = prev_target_hp - pTarget->GetHP();
|
|
arDamage[i].mp_damage = prev_target_mp - pTarget->GetMP();
|
|
arDamage[i].attacker_damage = prev_hp - GetHP();
|
|
arDamage[i].attacker_mp_damage = prev_mp - GetMP();
|
|
|
|
arDamage[i].target_hp = pTarget->GetHP();
|
|
arDamage[i].target_mp = pTarget->GetMP();
|
|
arDamage[i].attacker_hp = GetHP();
|
|
arDamage[i].attacker_mp = GetMP();
|
|
|
|
nHate += arDamage[i].nDamage;
|
|
|
|
onAttack( pTarget, arDamage[i].nDamage );
|
|
|
|
// 명중
|
|
if( bSuccess )
|
|
{
|
|
// 추가타인 경우는 각종 발동이 일어나지 않게 하려는 의도
|
|
// 이도에 추가타가 붙은 경우, 오른손, 왼손, 오른손 추가타, 왼손 추가타 순서이다.
|
|
if( !bIsDoubleAttack || ( bIsDoubleAttack && i < nAttackCount / 2 ) )
|
|
OnAttack( pTarget, arDamage[i].nDamage, StructState::NormalAttack, Elemental::TYPE_NONE );
|
|
}
|
|
|
|
// 크리티컬/블럭/퍼펙트블럭/회피
|
|
if( arDamage[i].bCritical ) OnCritical( pTarget, arDamage[i].nDamage, StructState::NormalAttack, Elemental::TYPE_NONE );
|
|
if( arDamage[i].bBlock ) pTarget->OnBlock( this, arDamage[i].nDamage, StructState::NormalAttack, Elemental::TYPE_NONE );
|
|
if( arDamage[i].bPerfectBlock ) pTarget->OnPerfectBlock( this, StructState::NormalAttack, Elemental::TYPE_NONE );
|
|
if( arDamage[i].bMiss ) pTarget->OnAvoid( this, StructState::NormalAttack, Elemental::TYPE_NONE );
|
|
}
|
|
|
|
if( pTarget->IsMonster() )
|
|
{
|
|
bool bRange = ( IsUsingBow() || IsUsingCrossBow() ) && IsPlayer();
|
|
|
|
std::pair< float, int > HateMod = GetHateMod( 3, true );
|
|
|
|
nHate += HateMod.second;
|
|
nHate *= HateMod.first;
|
|
|
|
if( bRange )
|
|
{
|
|
static_cast< StructMonster * >( pTarget )->AddHate( GetHandle(), m_fHateRatio * nHate * m_RangeStateAdvantage.fHate * pTarget->m_RangeStatePenalty.fHate );
|
|
}
|
|
else
|
|
{
|
|
static_cast< StructMonster * >( pTarget )->AddHate( GetHandle(), m_fHateRatio * nHate * m_NormalStateAdvantage.fHate * pTarget->m_NormalStatePenalty.fHate );
|
|
}
|
|
}
|
|
else if( pTarget->IsNPC() )
|
|
{
|
|
static_cast< StructNPC * >( pTarget )->SetAttacker( pTarget );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void StructCreature::broadcastAttackMessage( StructCreature *pTarget, struct StructCreature::_ATTACK_INFO * arDamage, int tm, int delay, bool bIsDoubleAttack, bool bIsAiming, bool bEndAttack, bool bCancelAttack )
|
|
{
|
|
char buf[ sizeof( TS_ATTACK_EVENT ) + sizeof( TS_ATTACK_EVENT::ATTACK_INFO ) * 4 ]; // 최대 4개라서 이리 했음. 나중에 또 추가되면 또 늘려야 함.
|
|
|
|
TS_ATTACK_EVENT * pMsg = new ( buf ) TS_ATTACK_EVENT();
|
|
|
|
int nAttackCount = 1;
|
|
|
|
if( bEndAttack || bCancelAttack )
|
|
nAttackCount = 0;
|
|
|
|
if( !IsFormChanged() )
|
|
{
|
|
if( IsUsingDoubleWeapon() )
|
|
nAttackCount *= 2;
|
|
|
|
if( bIsDoubleAttack )
|
|
nAttackCount *= 2;
|
|
}
|
|
|
|
pMsg->size += sizeof( TS_ATTACK_EVENT::ATTACK_INFO ) * nAttackCount;
|
|
|
|
pMsg->attack_flag = 0;
|
|
|
|
if( !IsFormChanged() )
|
|
{
|
|
if( bIsDoubleAttack ) pMsg->attack_flag |= TS_ATTACK_EVENT::ATTACK_FLAG_DOUBLE_ATTACK;
|
|
if( IsUsingDoubleWeapon() ) pMsg->attack_flag |= TS_ATTACK_EVENT::ATTACK_FLAG_DOUBLE_WEAPON;
|
|
if( IsUsingBow() && IsPlayer() ) pMsg->attack_flag |= TS_ATTACK_EVENT::ATTACK_FLAG_BOW;
|
|
if( IsUsingCrossBow() && IsPlayer() ) pMsg->attack_flag |= TS_ATTACK_EVENT::ATTACK_FLAG_CROSS_BOW;
|
|
}
|
|
|
|
pMsg->attack_action = TS_ATTACK_EVENT::ATTACK_ATTACK;
|
|
if( bIsAiming ) pMsg->attack_action = TS_ATTACK_EVENT::ATTACK_AIMING;
|
|
else if( bEndAttack ) pMsg->attack_action = TS_ATTACK_EVENT::ATTACK_END;
|
|
else if( bCancelAttack ) pMsg->attack_action = TS_ATTACK_EVENT::ATTACK_CANCEL;
|
|
|
|
pMsg->attack_speed = tm;
|
|
pMsg->attack_delay = delay;
|
|
pMsg->count = nAttackCount;
|
|
pMsg->attacker_handle = GetHandle();
|
|
|
|
if( pTarget )
|
|
{
|
|
pMsg->target_handle = pTarget->GetHandle(); // 타겟
|
|
}
|
|
else
|
|
{
|
|
pMsg->target_handle = 0; // 타겟
|
|
}
|
|
|
|
|
|
TS_ATTACK_EVENT::ATTACK_INFO * pAttackInfo = reinterpret_cast< TS_ATTACK_EVENT::ATTACK_INFO * >( pMsg + 1 );
|
|
|
|
for( int i = 0; i < nAttackCount; ++i )
|
|
{
|
|
pAttackInfo[i].damage = arDamage[i].nDamage;
|
|
pAttackInfo[i].mp_damage = arDamage[i].mp_damage;
|
|
pAttackInfo[i].attacker_damage = arDamage[i].attacker_damage;
|
|
pAttackInfo[i].attacker_mp_damage = arDamage[i].attacker_mp_damage;
|
|
|
|
pAttackInfo[i].target_hp = arDamage[i].target_hp;
|
|
pAttackInfo[i].target_mp = arDamage[i].target_mp;
|
|
pAttackInfo[i].attacker_hp = arDamage[i].attacker_hp;
|
|
pAttackInfo[i].attacker_mp = arDamage[i].attacker_mp;
|
|
|
|
pAttackInfo[i].flag = 0;
|
|
|
|
// 플래그 설정
|
|
if( arDamage[i].bPerfectBlock ) pAttackInfo[i].flag |= TS_ATTACK_EVENT::FLAG_PERFECT_BLOCK;
|
|
if( arDamage[i].bBlock ) pAttackInfo[i].flag |= TS_ATTACK_EVENT::FLAG_BLOCK;
|
|
if( arDamage[i].bMiss ) pAttackInfo[i].flag |= TS_ATTACK_EVENT::FLAG_MISS;
|
|
if( arDamage[i].bCritical ) pAttackInfo[i].flag |= TS_ATTACK_EVENT::FLAG_CRITICAL;
|
|
|
|
// 루프 펼치기 신공. 이게 더 빠르거든. -_-
|
|
pAttackInfo[i].elemental_damage[0] = arDamage[i].elemental_damage[0];
|
|
pAttackInfo[i].elemental_damage[1] = arDamage[i].elemental_damage[1];
|
|
pAttackInfo[i].elemental_damage[2] = arDamage[i].elemental_damage[2];
|
|
pAttackInfo[i].elemental_damage[3] = arDamage[i].elemental_damage[3];
|
|
pAttackInfo[i].elemental_damage[4] = arDamage[i].elemental_damage[4];
|
|
pAttackInfo[i].elemental_damage[5] = arDamage[i].elemental_damage[5];
|
|
pAttackInfo[i].elemental_damage[6] = arDamage[i].elemental_damage[6];
|
|
}
|
|
// 방송
|
|
ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), pMsg );
|
|
}
|
|
|
|
int StructCreature::GetCriticalDamage( int damage, float critical_amp, int critical_bonus )
|
|
{
|
|
// 크리티컬
|
|
if( XRandom( 0, 99 ) <= ( critical_amp * GetCritical() + critical_bonus ) )
|
|
{
|
|
return ( damage * ( GetCriticalPower() / 100.0f ) );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool StructCreature::StartAttack( AR_HANDLE target, bool bNeedFastReaction )
|
|
{
|
|
if( IsDead() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
// AziaMafia Fix Skill
|
|
/*
|
|
if( IsAttacking() )
|
|
{
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
m_hEnemy = target;
|
|
m_StatusFlag.Off( STATUS_ATTACK_STARTED );
|
|
|
|
ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_HIGHEST );
|
|
|
|
/*
|
|
if( ( IsUsingBow() || IsUsingCrossBow() ) && IsPlayer() )
|
|
{
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
}
|
|
*/
|
|
|
|
if( bNeedFastReaction ) onAttackAndSkillProcess();
|
|
|
|
return true;
|
|
}
|
|
|
|
void StructCreature::CancelAttack()
|
|
{
|
|
|
|
if( ( IsUsingBow() || IsUsingCrossBow() ) && IsPlayer() )
|
|
{
|
|
if( m_nNextAttackMode == StructCreature::AM_ATTACK )
|
|
{
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
// 조준 시간 초기화.
|
|
SetNextAttackableTime( GetArTime() );
|
|
}
|
|
}
|
|
|
|
if( isAttackStarted() )
|
|
{
|
|
|
|
StructCreature::iterator it = StructCreature::get( m_hEnemy );
|
|
StructCreature * pCreature = (*it);
|
|
|
|
_ATTACK_INFO info[4];
|
|
|
|
broadcastAttackMessage( pCreature, info, 0, 0, false, false, false, true );
|
|
}
|
|
|
|
m_hEnemy = 0;
|
|
|
|
m_StatusFlag.On( STATUS_FIRST_ATTACK );
|
|
}
|
|
void StructCreature::EndAttack()
|
|
{
|
|
if( ( IsUsingBow() || IsUsingCrossBow() ) && IsPlayer() )
|
|
{
|
|
if( m_nNextAttackMode == StructCreature::AM_ATTACK )
|
|
{
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
// 조준 시간 초기화.
|
|
SetNextAttackableTime( GetArTime() );
|
|
}
|
|
}
|
|
|
|
if( isAttackStarted() )
|
|
{
|
|
|
|
StructCreature::iterator it = StructCreature::get( m_hEnemy );
|
|
StructCreature * pCreature = (*it);
|
|
|
|
_ATTACK_INFO info[4];
|
|
|
|
if( ( IsPlayer() || IsSummon() ) && pCreature )
|
|
broadcastAttackMessage( pCreature, info, 0, 0, false, false, true );
|
|
}
|
|
|
|
m_hEnemy = 0;
|
|
|
|
m_StatusFlag.On( STATUS_FIRST_ATTACK );
|
|
}
|
|
|
|
void StructCreature::ProcessAttack()
|
|
{
|
|
if( IsAttacking() )
|
|
{
|
|
processAttack();
|
|
}
|
|
}
|
|
|
|
void StructCreature::onAttackAndSkillProcess()
|
|
{
|
|
if( IsUsingSkill() )
|
|
{
|
|
processSkill();
|
|
}
|
|
else if( IsAttacking() )
|
|
{
|
|
processAttack();
|
|
}
|
|
|
|
}
|
|
|
|
void StructCreature::processSkill()
|
|
{
|
|
// m_pCastSkill 멤버가 지역락의 보호를 받아야 하지만 StructSkill::ProcSkill은 지역락을 걸지 않고 호출해야 하므로...
|
|
StructSkill * pCastSkill = NULL;
|
|
{
|
|
ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( this ) );
|
|
|
|
pCastSkill = m_pCastSkill;
|
|
}
|
|
|
|
if( pCastSkill )
|
|
{
|
|
pCastSkill->ProcSkill();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void StructCreature::OnAttack( StructCreature *pTarget, const int nDamage, const DWORD nAttackType, const int nElementalType, const int nSkillId )
|
|
{
|
|
bool bIsAttacking = false;
|
|
|
|
// AziaMafia TryFix
|
|
ProcByAttack( pTarget, nDamage, true, nAttackType, nElementalType );
|
|
|
|
if( pTarget )
|
|
{
|
|
bIsAttacking = true;
|
|
pTarget->ProcByAttack( this, nDamage, false, nAttackType, nElementalType );
|
|
}
|
|
|
|
// 스킬 아이디를 기준으로 핸들러 호출
|
|
// 현재는 특정 스킬 피격 시에 대한 유형은 존재하지 않음
|
|
if( nSkillId )
|
|
{
|
|
ProcBySkillId( pTarget, nDamage, true, nSkillId );
|
|
}
|
|
|
|
if( bIsAttacking )
|
|
{
|
|
StructState::StateCode nCode = static_cast<StructState::StateCode>( 9903 );
|
|
|
|
if( m_nLuna && !pTarget->GetState( nCode ) && IsEnemy(pTarget, false))
|
|
{
|
|
pTarget->AddState( nCode, GetHandle(), 1, GetArTime(), GetArTime() + 18000 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::OnKill( StructCreature *pTarget )
|
|
{
|
|
ProcByKill( pTarget, true );
|
|
if( pTarget )
|
|
pTarget->ProcByKill( this, false );
|
|
}
|
|
|
|
void StructCreature::OnCritical( StructCreature *pTarget, const int nDamage, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
ProcByCritical( pTarget, nDamage, true, nAttackType, nElementalType );
|
|
if( pTarget )
|
|
pTarget->ProcByCritical( this, nDamage, false, nAttackType, nElementalType );
|
|
|
|
// 기존 유형 유지
|
|
ProcessAddHPMPOnCritical();
|
|
}
|
|
|
|
void StructCreature::OnAvoid( StructCreature *pFrom, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
ProcByAvoid( pFrom, nAttackType, nElementalType );
|
|
}
|
|
|
|
void StructCreature::OnBlock( StructCreature *pFrom, const int nDamage, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
ProcByBlock( pFrom, nDamage, nAttackType, nElementalType );
|
|
|
|
// 기존 유형 유지
|
|
AR_TIME t = GetArTime();
|
|
for( std::vector< StateReflectInfo >::iterator it = m_vStateReflectInfo.begin() ; it != m_vStateReflectInfo.end() ; ++it )
|
|
{
|
|
if( !pFrom->IsNPC() )
|
|
pFrom->AddState( (*it).nCode, GetHandle(), (*it).nLevel, t, t + (*it).nDuration );
|
|
}
|
|
}
|
|
|
|
void StructCreature::OnPerfectBlock( StructCreature *pFrom, const DWORD nAttackType, const int nElementalType )
|
|
{
|
|
ProcByPerfectBlock( pFrom, nAttackType, nElementalType );
|
|
}
|
|
|
|
void StructCreature::processAttack()
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
// 행동 못하면 KIN
|
|
if( !IsAttackable() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool bIsUsingBow = IsUsingBow();
|
|
bool bIsUsingCrossBow = IsUsingCrossBow();
|
|
|
|
// 공격 가능 시간 안되었다면 KIN
|
|
if( GetNextAttackableTime() > t )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( ( bIsUsingBow || bIsUsingCrossBow ) && IsPlayer() )
|
|
{
|
|
// 화살 없으면 KIN
|
|
if( GetBulletCount() < 1 )
|
|
{
|
|
// AziaMafia No Need Bullet
|
|
//EndAttack();
|
|
//return;
|
|
}
|
|
}
|
|
|
|
// 적 포인터를 얻어옴
|
|
StructCreature::iterator it = StructCreature::get( m_hEnemy );
|
|
StructCreature *pEnemy = *it;
|
|
|
|
// 근처 범위 Lock
|
|
ArcadiaAutoLock _lock;
|
|
|
|
if( pEnemy )
|
|
{
|
|
_lock.set( ArcadiaServer::Instance().LockObjects( this, pEnemy ), __FILE__, __LINE__ );
|
|
}
|
|
else
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
SendCantAttackMsg( static_cast< StructPlayer * >( this ), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
SendCantAttackMsg( static_cast< StructSummon * >( this )->GetMaster(), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
}
|
|
|
|
EndAttack();
|
|
|
|
return;
|
|
}
|
|
|
|
if( IsDead() )
|
|
{
|
|
CancelAttack();
|
|
return;
|
|
}
|
|
|
|
// 이동중이라면 KIN
|
|
if( IsMoving( t ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 공격중이 아니라면 KIN
|
|
if( !IsAttacking() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 적이 유효하지 않다면 KIN
|
|
if( !pEnemy || !IsEnemy( pEnemy ) || pEnemy->IsDead() || !pEnemy->IsInWorld() || !IsVisibleRegion( GetRX(), GetRY(), pEnemy->GetRX(), pEnemy->GetRY() ) )
|
|
{
|
|
if( IsPlayer() )
|
|
SendCantAttackMsg( static_cast< StructPlayer * >( this ), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
else if( IsSummon() )
|
|
SendCantAttackMsg( static_cast< StructSummon * >( this )->GetMaster(), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
|
|
EndAttack();
|
|
return;
|
|
}
|
|
|
|
if( isFirstAttack() )
|
|
{
|
|
pEnemy->OnUpdate();
|
|
|
|
m_StatusFlag.Off( STATUS_FIRST_ATTACK );
|
|
}
|
|
|
|
if( pEnemy->IsDead() )
|
|
{
|
|
if( IsPlayer() )
|
|
SendCantAttackMsg( static_cast< StructPlayer * >( this ), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
else if( IsSummon() )
|
|
SendCantAttackMsg( static_cast< StructSummon * >( this )->GetMaster(), GetHandle(), m_hEnemy, RESULT_NOT_EXIST );
|
|
|
|
EndAttack();
|
|
return;
|
|
}
|
|
|
|
// 내위치, 상대위치, 거리 얻자
|
|
ArPosition enemyPosition = pEnemy->GetCurrentPosition( t );
|
|
ArPosition myPosition = GetCurrentPosition( t );
|
|
AR_UNIT distance = myPosition.GetDistance( enemyPosition );
|
|
distance -= ( pEnemy->GetUnitSize()/2 + GetUnitSize()/2 );
|
|
AR_UNIT attack_range = GetRealAttackRange();
|
|
|
|
// 타겟 방향을 향하도록..
|
|
SetDirection( enemyPosition );
|
|
|
|
{
|
|
if( pEnemy->IsMoving() )
|
|
attack_range *= 1.5f;
|
|
else
|
|
attack_range *= 1.2f;
|
|
}
|
|
|
|
// 변수
|
|
_ATTACK_INFO Damages[4];
|
|
bool bIsDoubleAttack = false;
|
|
|
|
int nAttackTime = GetAttackInterval(); // 순수 공격에만 소요되는 시간
|
|
int nAttackInterval = GetAttackInterval(); // 다음번 공격까지의 interval
|
|
|
|
// 이번에 수행할 공격 모드 저장
|
|
int nCurrentAttackMode = m_nNextAttackMode;
|
|
|
|
// 사거리에 못미친다면..
|
|
if( distance > attack_range )
|
|
{
|
|
onCantAttack( pEnemy->GetHandle(), t );
|
|
return;
|
|
}
|
|
|
|
// AziaMafia TryFix if( ( bIsUsingBow || bIsUsingCrossBow ) && IsPlayer() )
|
|
|
|
/*
|
|
if( ( bIsUsingBow ) && IsPlayer() )
|
|
{
|
|
// 장전 처리를 해야 한다면
|
|
if( nCurrentAttackMode == StructCreature::AM_AIMING )
|
|
{
|
|
nAttackTime = GetBowAttackInterval() * GameRule::BOW_AIMING_TIME_RATIO;
|
|
// 장전시간 설정
|
|
nAttackInterval = nAttackTime;
|
|
|
|
SetNextAttackableTime( t + nAttackInterval );
|
|
|
|
// 다음번에는 공격하세~
|
|
m_nNextAttackMode = StructCreature::AM_ATTACK;
|
|
}
|
|
else
|
|
{
|
|
nAttackTime = GetBowAttackInterval() * ( 1.0f - GameRule::BOW_AIMING_TIME_RATIO );
|
|
nAttackInterval = nAttackTime + GetBowInterval();
|
|
|
|
// 다음번에는 장전하세~
|
|
m_nNextAttackMode = StructCreature::AM_AIMING;
|
|
}
|
|
} else nCurrentAttackMode = StructCreature::AM_ATTACK;
|
|
|
|
NEVER AIM AziaMafia */
|
|
nCurrentAttackMode = StructCreature::AM_ATTACK;
|
|
// NEVER AIM AziaMafia
|
|
|
|
// 공격 모드라면 두들겨 패자~~
|
|
if( nCurrentAttackMode == StructCreature::AM_ATTACK )
|
|
{
|
|
|
|
//AziaMafia Double Arba
|
|
//if ((bIsUsingBow || bIsUsingCrossBow) && IsPlayer())
|
|
/*
|
|
if( ( bIsUsingBow ) && IsPlayer() )
|
|
{
|
|
static_cast< StructPlayer * >( this )->EraseBullet( 1 );
|
|
}
|
|
*/
|
|
|
|
SetMovableTime( t + nAttackTime );
|
|
Attack( pEnemy, t, nAttackInterval, Damages, bIsDoubleAttack );
|
|
}
|
|
|
|
m_StatusFlag.On( STATUS_ATTACK_STARTED );
|
|
|
|
if( IsFormChanged() )
|
|
{
|
|
// sum all damage info
|
|
|
|
int nAttackCount = 1;
|
|
if( IsUsingDoubleWeapon() ) nAttackCount = 2;
|
|
|
|
if( bIsDoubleAttack ) nAttackCount *= 2;
|
|
|
|
for( int i = 1; i < nAttackCount; ++i )
|
|
{
|
|
// damage는 더하고
|
|
Damages[0].nDamage += Damages[i].nDamage;
|
|
Damages[0].mp_damage += Damages[i].mp_damage;
|
|
Damages[0].attacker_damage += Damages[i].attacker_damage;
|
|
Damages[0].attacker_mp_damage += Damages[i].attacker_mp_damage;
|
|
|
|
// 체력등의 결과는 최종 버전으로
|
|
Damages[0].target_hp = Damages[i].target_hp;
|
|
Damages[0].target_mp = Damages[i].target_mp;
|
|
Damages[0].attacker_hp = Damages[i].attacker_hp;
|
|
Damages[0].attacker_mp = Damages[i].attacker_mp;
|
|
|
|
// 플래그는 적당히 합치고...
|
|
Damages[0].bPerfectBlock |= Damages[i].bPerfectBlock;
|
|
Damages[0].bBlock |= Damages[i].bBlock;
|
|
Damages[0].bMiss &= Damages[i].bMiss; // 미스는 모두 미스일때만
|
|
Damages[0].bCritical |= Damages[i].bCritical;
|
|
|
|
|
|
// 루프 펼치기 신공. 이게 더 빠르거든. -_-
|
|
Damages[0].elemental_damage[0] += Damages[i].elemental_damage[0];
|
|
Damages[0].elemental_damage[1] += Damages[i].elemental_damage[1];
|
|
Damages[0].elemental_damage[2] += Damages[i].elemental_damage[2];
|
|
Damages[0].elemental_damage[3] += Damages[i].elemental_damage[3];
|
|
Damages[0].elemental_damage[4] += Damages[i].elemental_damage[4];
|
|
Damages[0].elemental_damage[5] += Damages[i].elemental_damage[5];
|
|
Damages[0].elemental_damage[6] += Damages[i].elemental_damage[6];
|
|
}
|
|
}
|
|
|
|
// 메세지 방송
|
|
if( !IsFormChanged() || nCurrentAttackMode != StructCreature::AM_AIMING )
|
|
broadcastAttackMessage( pEnemy, Damages, nAttackTime * 10, ( GetNextAttackableTime() - t ) * 10, bIsDoubleAttack, nCurrentAttackMode == StructCreature::AM_AIMING );
|
|
}
|
|
|
|
unsigned short StructCreature::onItemUseEffect( struct StructCreature *pCaster, struct StructItem* pItem, int type, c_fixed10 var1, c_fixed10 var2, const char *szParameter )
|
|
{
|
|
unsigned short nRet = RESULT_SUCCESS;
|
|
|
|
switch( type )
|
|
{
|
|
case ITEM_EFFECT_INSTANT::INC_HP :
|
|
{
|
|
int prev_hp = GetHP();
|
|
HealByItem( var1 );
|
|
BroadcastHPMPMsg( this, GetHP() - prev_hp, 0 );
|
|
break;
|
|
}
|
|
case ITEM_EFFECT_INSTANT::INC_MP :
|
|
{
|
|
int prev_mp = GetMP();
|
|
MPHealByItem( var1 );
|
|
BroadcastHPMPMsg( this, 0, GetMP() - prev_mp );
|
|
|
|
break;
|
|
}
|
|
case ITEM_EFFECT_INSTANT::INC_HP_PERCENT:
|
|
{
|
|
int prev_hp = GetHP();
|
|
HealByItem( var1 * GetMaxHP() );
|
|
BroadcastHPMPMsg( this, GetHP() - prev_hp, 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::INC_MP_PERCENT:
|
|
{
|
|
int prev_mp = GetMP();
|
|
MPHealByItem( var1 * GetMaxMP() );
|
|
BroadcastHPMPMsg( this, 0, GetMP() - prev_mp );
|
|
|
|
break;
|
|
}
|
|
case ITEM_EFFECT_INSTANT::INC_STAMINA :
|
|
case ITEM_EFFECT_INSTANT::INC_STAMINA_EX:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
static_cast< StructPlayer * >( this )->AddStamina( var1 );
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::RESURECTION :
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
// 자신에게는 못씀
|
|
if( pItem->GetOwnerHandle() == GetHandle() )
|
|
break;
|
|
|
|
// 안죽었으면 못씀
|
|
if( IsAlive() ) break;
|
|
|
|
// 죽었더라도 내구도가 다한 소환수는 살릴 수 없음
|
|
if( IsSummon() )
|
|
{
|
|
StructItem *pCardItem = static_cast< StructSummon * >( this )->GetParentCard();
|
|
|
|
if( pCardItem && pCardItem->GetMaxEtherealDurability() && !pCardItem->GetCurrentEtherealDurability() )
|
|
break;
|
|
}
|
|
|
|
if( !pCaster->IsAlly( this ) )
|
|
break;
|
|
|
|
int prev_hp = GetHP();
|
|
AddHP( GetMaxHP() * 0.2f );
|
|
BroadcastHPMPMsg( this, GetHP() - prev_hp, 0 );
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
ClearRemovedStateByDead();
|
|
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >(this);
|
|
StructPlayer *pCastPlayer = ( pCaster->IsPlayer() ) ? static_cast< StructPlayer * >( pCaster ) : NULL;
|
|
|
|
if( pPlayer->IsCompeteDead() )
|
|
pPlayer->SetCompeteDead( false );
|
|
|
|
LOG::Log11N4S( LM_CHARACTER_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(),
|
|
CRT_ITEM, ( pCastPlayer ) ? pCastPlayer->GetAccountID() : 0, ( pCastPlayer ) ? pCastPlayer->GetPlayerUID() : 0, 0, pPlayer->GetX(), pPlayer->GetY(), pPlayer->GetLayer(), 0, pPlayer->GetEXP(),
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, ( pCastPlayer ) ? pCastPlayer->GetAccountName() : "", LOG::STR_NTS, ( pCastPlayer ) ? pCastPlayer->GetName() : "" , LOG::STR_NTS );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
StructSummon *pSummon = static_cast< StructSummon * >(this);
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >(pSummon->GetMaster());
|
|
LOG::Log11N4S( LM_SUMMON_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(), pSummon->GetSID(), 0, 0, 0, 0, 0, 0, 0, pSummon->GetEXP(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", LOG::STR_NTS, "", LOG::STR_NTS );
|
|
}
|
|
|
|
nRet = RESULT_SUCCESS;
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::WARP :
|
|
{
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::SKILL : // 스킬 호출
|
|
{
|
|
AR_HANDLE hTarget = GetHandle();
|
|
|
|
// 귀환/복귀의 깃털 스킬일 경우 타겟을 아이템 핸들로 대체(소켓에 이동할 좌표가 들어있으므로)
|
|
if( var1 == StructSkill::SKILL_RETURN_FEATHER || var1 == StructSkill::SKILL_RETURN_BACK_FEATHER )
|
|
hTarget = pItem->GetHandle();
|
|
|
|
nRet = pCaster->CastSkill( var1, var2, hTarget, ArPosition(), GetLayer(), pItem->GetHandle() );
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::ADD_STATE : // 지속효과 호출
|
|
case ITEM_EFFECT_INSTANT::ADD_STATE_EX : // 확장 지속효과 호출
|
|
{
|
|
StructState::StateCode eCode = static_cast< StructState::StateCode >( ( type == ITEM_EFFECT_INSTANT::ADD_STATE ) ? pItem->GetStateCode() : (int)var1 );
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >( this );
|
|
const StateInfo * pStateInfo = GameContent::GetStateInfo( eCode );
|
|
|
|
if( !pStateInfo )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE;
|
|
break;
|
|
}
|
|
|
|
if( pStateInfo->effect_type == StructState::EF_RIDING )
|
|
{
|
|
if( pPlayer->IsRiding() || pPlayer->HasRidingState() || !pPlayer->IsMountable( true ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( eCode == StructState::STAMINA_SAVE )
|
|
{
|
|
// 스테미너 효과가 더블 플러스 PC방에서 적용되지 않는 경우는 스테미너 세이버(비매품 포함)는 프리미엄 PC방에서는 사용 불가
|
|
if( pPlayer->GetPCBangMode() == GameRule::PCBANG_PREMIUM_BONUS && !GameRule::bApplyStaminaBonusInPremiumPCBang )
|
|
{
|
|
nRet = RESULT_ALREADY_STAMINA_SAVED;
|
|
break;
|
|
}
|
|
|
|
// 게임 중독 방지 시스템 관련 스테미너 세이버 사용 방지 체크
|
|
if( pPlayer->IsGameTimeLimited() )
|
|
{
|
|
if( pPlayer->GetContinuousPlayTime() >= GameRule::nMaxTiredGameTime )
|
|
{
|
|
nRet = RESULT_GAMETIME_HARMFUL_STAMINA_SAVER;
|
|
break;
|
|
}
|
|
else if( pPlayer->GetContinuousPlayTime() >= GameRule::nMaxHealthyGameTime )
|
|
{
|
|
nRet = RESULT_GAMETIME_TIRED_STAMINA_SAVER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 스태미너 세이버 효과가 있는 상태라면 사용 불가
|
|
if( pPlayer->GetState( StructState::STAMINA_SAVE ) )
|
|
{
|
|
nRet = RESULT_ALREADY_STAMINA_SAVED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( eCode == StructState::SUPER_SAVE_0 ||
|
|
eCode == StructState::SUPER_SAVE_1 ||
|
|
eCode == StructState::SUPER_SAVE_2 ||
|
|
eCode == StructState::SUPER_SAVE_3 )
|
|
{
|
|
// 게임 중독 방지 시스템 관련 성장의 물약(구 슈퍼 세이버) 사용 방지 체크
|
|
if( pPlayer->IsGameTimeLimited() )
|
|
{
|
|
if( pPlayer->GetContinuousPlayTime() >= GameRule::nMaxTiredGameTime )
|
|
{
|
|
nRet = RESULT_GAMETIME_HARMFUL_SUPER_SAVER;
|
|
break;
|
|
}
|
|
else if( pPlayer->GetContinuousPlayTime() >= GameRule::nMaxHealthyGameTime )
|
|
{
|
|
nRet = RESULT_GAMETIME_TIRED_SUPER_SAVER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 성장의 물약(구 슈퍼 세이버)는 중첩 불가
|
|
if( pPlayer->GetState( eCode ) )
|
|
{
|
|
nRet = RESULT_ALREADY_SUPER_SAVER;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
AR_TIME t = GetArTime();
|
|
int nLevel = ( type == ITEM_EFFECT_INSTANT::ADD_STATE ) ? pItem->GetStateLevel() : var2;
|
|
nRet = AddState( static_cast< StructState::StateCode >( eCode ), pItem->GetOwnerHandle(), nLevel, t, t + pItem->GetStateTime()*100 );
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::REMOVE_STATE : // 지속효과 제거
|
|
{
|
|
RemoveState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetStateLevel() );
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::TOGGLE_STATE :
|
|
{
|
|
StructItem *pWearingRideItem = GetWearedItem( ItemBase::WEAR_RIDE_ITEM );
|
|
|
|
// 내리기는 탑승시 사용한 아이템(장착되어 있음)으로만 가능
|
|
if( GetState( static_cast< StructState::StateCode >( pItem->GetStateCode() ) ) && pWearingRideItem == pItem )
|
|
{
|
|
RemoveState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetStateLevel() );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >( this );
|
|
if( pPlayer->IsRiding() || pPlayer->HasRidingState() || !pPlayer->IsMountable( true ) )
|
|
{
|
|
const StateInfo * pStateInfo = GameContent::GetStateInfo( pItem->GetStateCode() );
|
|
|
|
if( pStateInfo->effect_type == StructState::EF_RIDING )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( pWearingRideItem )
|
|
{
|
|
if( pWearingRideItem != pItem && ( pPlayer->Putoff( ItemBase::WEAR_RIDE_ITEM ) != RESULT_SUCCESS || pPlayer->Puton( ItemBase::WEAR_RIDE_ITEM, pItem ) != RESULT_SUCCESS ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
else if( pPlayer->Puton( ItemBase::WEAR_RIDE_ITEM, pItem ) != RESULT_SUCCESS )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
AR_TIME t = GetArTime();
|
|
nRet = AddState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetOwnerHandle(), pItem->GetStateLevel(), t, -1, true );
|
|
break;
|
|
}
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::GENERATE_ITEM : // 아이템 생성
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( var1 == 0 )
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
if( pPlayer->ChangeGold( pPlayer->GetGold() + var2.GetAsInt64() ) != RESULT_SUCCESS )
|
|
{
|
|
nRet = RESULT_TOO_MUCH_MONEY;
|
|
break;
|
|
}
|
|
|
|
LOG::Log11N4S( LM_ITEM_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, 0, 0, 0, var2, pPlayer->GetGold().GetRawData(), pPlayer->GetX(), pPlayer->GetY(), 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "IGEN", LOG::STR_NTS );
|
|
}
|
|
else
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
// 일반 아이템 생성이면 그 아이템을 var2개 만큼 생성, 드랍 그룹 아이템 생성이면 var2 횟수만큼 드랍 그룹 반복 선택
|
|
int nGenCount = ( var1 >= 0 ) ? 1 : var2;
|
|
//bool bIsBlank = true;
|
|
|
|
for( int i = 0 ; i < nGenCount ; ++i )
|
|
{
|
|
ItemBase::ItemCode nItemID = var1;
|
|
__int64 nItemCount = var2;
|
|
|
|
while( nItemID < 0 )
|
|
{
|
|
GameContent::SelectItemIDFromDropGroup( nItemID, nItemID, nItemCount );
|
|
}
|
|
|
|
if( nItemID )
|
|
{
|
|
//bIsBlank = true;
|
|
|
|
StructItem *pItem = StructItem::AllocItem( 0, nItemID, nItemCount, ItemInstance::BY_ITEM );
|
|
|
|
// 아이템 획득 메시지를 보여주기 위해 그냥 보내주기
|
|
StructItem *pNewItem = static_cast< StructPlayer *>( this )->PushItem( pItem, pItem->GetCount() );
|
|
|
|
if( pNewItem )
|
|
{
|
|
SendResult( this, TM_CS_TAKE_ITEM, RESULT_SUCCESS, pNewItem->GetHandle() );
|
|
LOG::Log11N4S( LM_ITEM_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), pItem->GetItemEnhance() * 100 + pItem->GetItemLevel(), pItem->GetItemCode(), pItem->GetCount(), pNewItem ? pNewItem->GetCount() : 0, 0, 0, pPlayer->GetX(), pPlayer->GetY(), pItem->GetItemUID(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "IGEN", LOG::STR_NTS );
|
|
}
|
|
|
|
if( pNewItem != pItem )
|
|
{
|
|
StructItem::PendFreeItem( pItem );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG::Log11N4S( LM_ITEM_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, 0, 0, 0, 0, pPlayer->GetGold().GetRawData(), pPlayer->GetX(), pPlayer->GetY(), 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "IGEN", LOG::STR_NTS );
|
|
}
|
|
}
|
|
|
|
// 2008.12.02 꽝 처리 일시적으로 제거(2008년 크리스마스 이벤트 관련)
|
|
// 아이템 사용함으로 인해 아이템이 하나도 안 나온 경우에만 꽝 메시지 출력
|
|
// 아이템 하나에서 드랍그룹 2개 이상 사용 시에 아이템을 1개는 얻었고 나머지 드랍 그룹에서는 꽝이 나와도 꽝은 아니므로...
|
|
//if( bIsBlank )
|
|
//{
|
|
// PrintfChatMessage( false, CHAT_ITEM, "@SYSTEM", pPlayer, "@6696" );
|
|
//}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::INC_GOLD:
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
StructGold nIncGold( XRandom( var1, var2 ) );
|
|
|
|
if( pPlayer->ChangeGold( pPlayer->GetGold() + nIncGold ) != RESULT_SUCCESS )
|
|
{
|
|
nRet = RESULT_TOO_MUCH_MONEY;
|
|
break;
|
|
}
|
|
|
|
LOG::Log11N4S( LM_ITEM_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, 0, 0, 0, nIncGold.GetRawData(), pPlayer->GetGold().GetRawData(), pPlayer->GetX(), pPlayer->GetY(), 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "IGEN", LOG::STR_NTS );
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::INC_HUNTAHOLIC_POINT:
|
|
{
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
int nIncHuntaholicPoint( XRandom( var1, var2 ) );
|
|
|
|
pPlayer->SetHuntaholicPoint( pPlayer->GetHuntaholicPoint() + nIncHuntaholicPoint );
|
|
|
|
LOG::Log11N4S( LM_ITEM_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, ItemBase::ITEM_CODE_HUNTAHOLIC_POINT_TICKET, nIncHuntaholicPoint, pPlayer->GetHuntaholicPoint(), 0, pPlayer->GetGold().GetRawData(), pPlayer->GetX(), pPlayer->GetY(), 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "IGEN", LOG::STR_NTS );
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::RESET_SKILL: // 리트레이닝 포션
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( GetJobDepth() < var1 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
nRet = ResetSkill( SRM_ITEM ) ? RESULT_SUCCESS : RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
case ITEM_EFFECT_INSTANT::RESET_JOB:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( GetJobDepth() < var1 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
nRet = static_cast< StructPlayer * >( this )->ResetJob( 0 ) ? RESULT_SUCCESS : RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::RESET_SUMMON_SKILL:
|
|
{
|
|
if( !IsSummon() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
// 랜덤 스킬 초기화 유형은 랜덤스킬을 가진 소울 크리처에만 사용 가능하다.
|
|
// IsSoulCreature 함수의 인자를 위해 기본형의 소환수 코드를 가져온다.
|
|
StructSummon * pSummon = static_cast< StructSummon * >( this );
|
|
int nBasicSummonCode = pSummon->GetSummonCode();
|
|
if( pSummon->GetTransformLevel() == SummonBase::EVOLVE_GROWTH || pSummon->GetTransformLevel() == SummonBase::EVOLVE_EVOLVE )
|
|
{
|
|
nBasicSummonCode = pSummon->GetPrevJobId( 0 );
|
|
}
|
|
|
|
if( !IsInWorld() || IsDead() ||
|
|
static_cast< StructSummon * >( this )->GetMaster() != pCaster )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
nRet = ResetSkill( SRM_ITEM, 0, int(var1) ) ? RESULT_SUCCESS : RESULT_ACCESS_DENIED;
|
|
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::RECALL:
|
|
{
|
|
if( !IsPlayer() || !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer * pThisPlayer = static_cast< StructPlayer * >( this );
|
|
StructPlayer * pCastPlayer = static_cast< StructPlayer * >( pCaster );
|
|
|
|
// 시크루트는 들어가도 아무것도 못하므로 그냥 놔두기
|
|
if( pCastPlayer->IsInSiegeOrRaidDungeon() )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE_HERE;
|
|
break;
|
|
}
|
|
|
|
if( pCastPlayer->IsInInstanceDungeon() )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE_IN_INSTANCE_DUNGEON;
|
|
break;
|
|
}
|
|
|
|
char szBuf[255];
|
|
s_sprintf( szBuf, _countof( szBuf ), "recall_feather( %f, %f, %d )", pCastPlayer->GetX(), pCastPlayer->GetY(), pCastPlayer->GetLayer() );
|
|
|
|
if( var1 == 1.0f ) // 한 사람만 호출
|
|
{
|
|
// 시체거나, 파티원이 아니거나 창고 사용 중, 혹은 자신이면 사용 실패
|
|
if( pThisPlayer->IsDead() || !pThisPlayer->GetPartyID() || pThisPlayer->GetPartyID() != pCastPlayer->GetPartyID()
|
|
|| pThisPlayer->IsUsingStorage() || pCastPlayer == pThisPlayer )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
// 일반 던전일 경우 레벨 제한 체크
|
|
if( pCastPlayer->IsInDungeon() )
|
|
{
|
|
int nDungeonID = DungeonManager::Instance().GetDungeonID( pCastPlayer->GetX(), pCastPlayer->GetY() );
|
|
if( nDungeonID && DungeonManager::IsRestrictedToEnter( DungeonManager::Instance().GetDungeonLevel( nDungeonID ), pThisPlayer->GetLevel() ) )
|
|
{
|
|
// 이 곳으로 소환하기엔 레벨이 딸립니다.
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", pCastPlayer, "@563\v#@player_name@#\v%s", pThisPlayer->GetName() );
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", pThisPlayer, "@563\v#@player_name@#\v%s", pThisPlayer->GetName() );
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pThisPlayer->SetFixedDialogTrigger( szBuf );
|
|
pThisPlayer->SetNonNPCDialog( true );
|
|
|
|
SendWindowMessage( pThisPlayer, "recall_feather_confirm_window", pCastPlayer->GetName(), szBuf );
|
|
|
|
LOG::Log11N4S( LM_ITEM_RECALL_FEATHER_REQUEST, pCastPlayer->GetAccountID(), pCastPlayer->GetSID(), pCastPlayer->GetPartyID(),
|
|
pCastPlayer->GetX(), pCastPlayer->GetY(), pCastPlayer->GetLayer(),
|
|
pThisPlayer->GetAccountID(), pThisPlayer->GetSID(), pThisPlayer->GetX(), pThisPlayer->GetY(), pThisPlayer->GetLayer(),
|
|
pCastPlayer->GetAccountName(), LOG::STR_NTS, pCastPlayer->GetName(), LOG::STR_NTS, pThisPlayer->GetAccountName(), LOG::STR_NTS, pThisPlayer->GetName(), LOG::STR_NTS );
|
|
}
|
|
else // 파티 전체 호출, 실제 var1 은 8이어야 함. ItemDB 참조.
|
|
{
|
|
if( !pCastPlayer->GetPartyID() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
struct RecallFeatherCheckFunctor : PartyManager::PartyFunctor
|
|
{
|
|
RecallFeatherCheckFunctor( StructPlayer * pCaster, StructItem *pItem ) : m_pCaster( pCaster ), m_pItem( pItem ), m_nResult( RESULT_SUCCESS ) {};
|
|
|
|
virtual bool operator()( AR_HANDLE handle )
|
|
{
|
|
if( m_nResult != RESULT_SUCCESS )
|
|
return false;
|
|
|
|
StructPlayer::iterator pit = StructPlayer::get( handle );
|
|
StructPlayer *pPlayer = *pit;
|
|
|
|
if( pPlayer == m_pCaster )
|
|
return true;
|
|
|
|
if( pPlayer->IsInEventmap() )
|
|
{
|
|
m_nResult = RESULT_TARGET_IN_EVENTMAP;
|
|
return false;
|
|
}
|
|
|
|
if( HuntaholicManager::Instance().GetHuntaholicID( pPlayer->GetPos() ) )
|
|
{
|
|
m_nResult = RESULT_TARGET_IN_HUNTAHOLIC;
|
|
return false;
|
|
}
|
|
|
|
if( !pPlayer || !pPlayer->GetPartyID() || pPlayer->GetPartyID() != m_pCaster->GetPartyID() || pPlayer->IsUsingStorage() )
|
|
{
|
|
m_nResult = RESULT_NOT_ACTABLE;
|
|
return false;
|
|
}
|
|
|
|
if( m_pCaster->IsInDungeon() )
|
|
{
|
|
int nDungeonID = DungeonManager::Instance().GetDungeonID( m_pCaster->GetX(), m_pCaster->GetY() );
|
|
if( nDungeonID && DungeonManager::IsRestrictedToEnter( DungeonManager::Instance().GetDungeonLevel( nDungeonID ), pPlayer->GetLevel() ) )
|
|
{
|
|
// 이 곳으로 소환하기엔 레벨이 딸립니다.
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", m_pCaster, "@563\v#@player_name@#\v%s", pPlayer->GetName() );
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", pPlayer, "@563\v#@player_name@#\v%s", pPlayer->GetName() );
|
|
m_nResult = RESULT_ACCESS_DENIED;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
StructPlayer * m_pCaster;
|
|
StructItem *m_pItem;
|
|
int m_nResult;
|
|
} foChecker( pCastPlayer, pItem );
|
|
|
|
size_t nCount = PartyManager::GetInstance().DoEachMember( pCastPlayer->GetPartyID(), foChecker );
|
|
|
|
// 아이템을 사용한 플레이어를 제외하고 한 명 이상의 플레이어가 로그인되어 있어야 한다.(최소 두 명)
|
|
if( nCount < 2 )
|
|
{
|
|
nRet = RESULT_NOT_EXIST;
|
|
break;
|
|
}
|
|
|
|
if( foChecker.m_nResult != RESULT_SUCCESS )
|
|
{
|
|
nRet = foChecker.m_nResult;
|
|
break;
|
|
}
|
|
|
|
struct RecallFeatherFunctor : PartyManager::PartyFunctor
|
|
{
|
|
RecallFeatherFunctor( StructPlayer * pCaster, const char * _szTrigger ) : m_pCaster( pCaster ), szTrigger( _szTrigger ) {};
|
|
|
|
virtual bool operator()( AR_HANDLE handle )
|
|
{
|
|
StructPlayer::iterator pit = StructPlayer::get( handle );
|
|
StructPlayer *pPlayer = *pit;
|
|
|
|
if( !pPlayer || pPlayer->IsDead() || pPlayer == m_pCaster
|
|
|| !pPlayer->GetPartyID() || pPlayer->GetPartyID() != m_pCaster->GetPartyID() || pPlayer->IsUsingStorage() )
|
|
return true;
|
|
|
|
pPlayer->SetFixedDialogTrigger( szTrigger );
|
|
pPlayer->SetNonNPCDialog( true );
|
|
|
|
SendWindowMessage( pPlayer, "recall_feather_confirm_window", m_pCaster->GetName(), szTrigger );
|
|
|
|
LOG::Log11N4S( LM_ITEM_RECALL_FEATHER_REQUEST, m_pCaster->GetAccountID(), m_pCaster->GetSID(), m_pCaster->GetPartyID(),
|
|
m_pCaster->GetX(), m_pCaster->GetY(), m_pCaster->GetLayer(),
|
|
pPlayer->GetAccountID(), pPlayer->GetSID(), pPlayer->GetX(), pPlayer->GetY(), pPlayer->GetLayer(),
|
|
m_pCaster->GetAccountName(), LOG::STR_NTS, m_pCaster->GetName(), LOG::STR_NTS, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS );
|
|
|
|
return true;
|
|
}
|
|
|
|
StructPlayer * m_pCaster;
|
|
const char * szTrigger;
|
|
} fo( pCastPlayer, szBuf );
|
|
|
|
PartyManager::GetInstance().DoEachMember( pCastPlayer->GetPartyID(), fo );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::ADD_IMMORAL_POINT:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >(this);
|
|
|
|
// 모럴 상태에서는 아이템을 사용할 수 없으며, 이모럴일 때에는 이모럴 수치가 깎일 수치보다 적다고 해도 그냥 적용
|
|
if( pPlayer->GetImmoralPoint() <= 0 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
pPlayer->SetImmoralPoint( std::max( 0.0, static_cast< double >( pPlayer->GetImmoralPoint() ) + var1 ) );
|
|
BroadcastStatusMessage( pPlayer );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::SET_IMMORAL_POINT:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >(this);
|
|
|
|
// 세팅하려는 수치보다 이모럴 포인트가 같거나 낮은 상태에서는 아이템을 사용할 수 없음
|
|
if( pPlayer->GetImmoralPoint() <= var1 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
pPlayer->SetImmoralPoint( std::max( 0.0, double(var1) ) );
|
|
BroadcastStatusMessage( pPlayer );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::RENAME_SUMMON:
|
|
{
|
|
if( !IsSummon() || static_cast< StructSummon * >(this)->GetRidingInfo() == SummonBase::RIDING_LENT )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructSummon *pSummon = static_cast< StructSummon * >( this );
|
|
StructPlayer *pPlayer = pSummon->GetMaster();
|
|
|
|
// pPlayer->GetSubSummon 테스트는 2마리의 크리처가 소환되어 있는지 확인하기 위함.
|
|
// 2마리 소환 상태에서는 사용 불가능
|
|
if( !pSummon->IsInWorld() || !pPlayer || pPlayer != pCaster || !pPlayer->IsInWorld() || ( pPlayer->GetSubSummon() && pPlayer->GetSubSummon()->IsInWorld() ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
// 이름 미지정(szParameter가 NULL이 되는 경우는 없지만...) 또는 길이 부족
|
|
int code_page = ENV().GetInt( "CodePage", CP_ACP );
|
|
if( !szParameter || strlen( szParameter ) < 4 )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
// 같은 이름 사용 불가
|
|
else if( !strncmp( szParameter, pSummon->GetName(), std::max( strlen( szParameter ), strlen( pSummon->GetName() ) ) ) )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
else if( !GameRule::IsValidName( code_page, szParameter, (int)strlen( szParameter ) + 1, 4, 18 ) || // IsValidName에서 소환수 이름은 최대 길이 19 Byte이므로 버퍼 제한 18로 고정
|
|
GameContent::IsBannedWord( code_page, szParameter ) )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
|
|
LOG::Log11N4S( LM_SUMMON_CHANGE_NAME, pPlayer->GetAccountID(), pPlayer->GetPlayerUID(), pSummon->GetSID(), 0, 0, 0, 0, 0, 0, 0, pSummon->GetParentCard()->GetItemUID(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, pSummon->GetName(), LOG::STR_NTS, szParameter, LOG::STR_NTS );
|
|
|
|
pSummon->SetName( szParameter );
|
|
|
|
// 각종 UI에 이름 변경을 알려주기 위함
|
|
SendPropertyMessage( pPlayer, pSummon->GetHandle(), "name", pSummon->GetName() );
|
|
|
|
// 주변 사람들에게 바뀐 이름 보이게 하기 위함
|
|
TS_SC_CHANGE_NAME msg;
|
|
msg.handle = pSummon->GetHandle();
|
|
s_strcpy( msg.name, _countof( msg.name ), szParameter );
|
|
|
|
ArcadiaServer::Instance().Broadcast( pSummon->GetRX(), pSummon->GetRY(), pSummon->GetLayer(), &msg );
|
|
|
|
// 소환수가 월드에 있을 때만 처리되므로 SetNeedCalculateStat으로만 처리하면 됨.
|
|
// 없을 경우에는 CalculateStat 바로 호출해도 됨.
|
|
pSummon->SetNeedCalculateStat();
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::RENAME_CHARACTER:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer * pCastPlayer = static_cast< StructPlayer * >( pCaster );
|
|
|
|
if( !pCastPlayer->ChangeName( szParameter, var1, true, pItem->GetHandle() ) )
|
|
{
|
|
// 아이템을 사용하지 못했다는 내용에 대한 시스템 메시지를 출력하지 않도록 정의되지 않은 오류 코드를 반환
|
|
nRet = RESULT_UNKNOWN;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::RENAME_PET:
|
|
{
|
|
if( !IsPet() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPet *pPet = static_cast< StructPet * >( this );
|
|
StructPlayer *pPlayer = pPet->GetMaster();
|
|
|
|
if( !pPet->IsInWorld() || !pPlayer || pPlayer != pCaster || !pPlayer->IsInWorld() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( !pPet->GetParentCage() || pPet->GetParentCage()->IsExpireItem() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
// 이름 미지정(szParameter가 NULL이 되는 경우는 없지만...) 또는 길이 부족
|
|
int code_page = ENV().GetInt( "CodePage", CP_ACP );
|
|
if( !szParameter || strlen( szParameter ) < 4 )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
// 같은 이름 사용 불가
|
|
else if( !strncmp( szParameter, pPet->GetName(), std::max( strlen( szParameter ), strlen( pPet->GetName() ) ) ) )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
else if( !GameRule::IsValidName( code_page, szParameter, (int)strlen( szParameter ) + 1, 4, 18 ) || // IsValidName에서 펫 이름은 최대 길이 19 Byte이므로 버퍼 제한 18로 고정
|
|
GameContent::IsBannedWord( code_page, szParameter ) )
|
|
{
|
|
nRet = RESULT_INVALID_TEXT;
|
|
break;
|
|
}
|
|
|
|
LOG::Log11N4S( LM_PET_CHANGE_NAME, pPlayer->GetAccountID(), pPlayer->GetPlayerUID(), pPet->GetSID(), 0, 0, 0, 0, 0, 0, 0, pPet->GetParentCage()->GetItemUID(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, pPet->GetName(), LOG::STR_NTS, szParameter, LOG::STR_NTS );
|
|
|
|
nRet = pPet->ChangeName( szParameter, true );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::WARP_TO_SPECIAL_POSITION:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pCastPlayer = static_cast< StructPlayer * >( pCaster );
|
|
|
|
unsigned char layer = 0;
|
|
|
|
int current_channel = ChannelManager::GetChannelId( pCastPlayer->GetX(), pCastPlayer->GetY() );
|
|
int target_channel = ChannelManager::GetChannelId( var1, var2 );
|
|
|
|
if( current_channel && current_channel == target_channel )
|
|
{
|
|
layer = pCastPlayer->GetLayer();
|
|
}
|
|
else if( target_channel )
|
|
{
|
|
layer = ChannelManager::GetProperLayer( var1, var2 );
|
|
}
|
|
|
|
pCastPlayer->PendWarp( var1, var2, layer );
|
|
ArcadiaServer::Instance().SetObjectPriority( pCastPlayer, ArSchedulerObject::UPDATE_PRIORITY_HIGHEST );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::WARP_TO_PLAYER:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pCastPlayer = static_cast< StructPlayer * >( pCaster );
|
|
|
|
if( !szParameter )
|
|
{
|
|
nRet = RESULT_INVALID_ARGUMENT;
|
|
break;
|
|
}
|
|
|
|
StructPlayer::iterator pit = StructPlayer::get( StructPlayer::FindPlayer( szParameter ) );
|
|
StructPlayer *pTarget = *pit;
|
|
|
|
if( !pTarget || !pTarget->IsInWorld() || !pTarget->IsLogin() || !pTarget->IsLoginComplete() || pTarget == this )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInSecroute() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_SECROUTE;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInSiegeOrRaidDungeon() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_SIEGE_OR_RAID;
|
|
break;
|
|
}
|
|
|
|
// 값 2의 값이 0이면 숨겨진 던전 내의 대상을 향해 워프 불가, 1이면(0 외의 경우) 가능
|
|
assert( var2 == 0 || var2 == 1 );
|
|
if( var2 == 0 && pTarget->IsInSecretDungeon() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_SECRET_DUNGEON;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInInstanceDungeon() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_INSTANCE_DUNGEON;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInDungeon() )
|
|
{
|
|
int nDungeonID = DungeonManager::Instance().GetDungeonID( pTarget->GetX(), pTarget->GetY() );
|
|
if( nDungeonID && DungeonManager::IsRestrictedToEnter( DungeonManager::Instance().GetDungeonLevel( nDungeonID ), pCaster->GetLevel() ) )
|
|
{
|
|
// 이 곳으로 워프하기엔 레벨이 딸립니다.
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", pTarget, "@563\v#@player_name@#\v%s", pCaster->GetName() );
|
|
PrintfChatMessage( false, CHAT_NOTICE, "@NOTICE", static_cast< StructPlayer* >( pCaster ), "@563\v#@player_name@#\v%s", pCaster->GetName() );
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( pTarget->IsInDeathmatch() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_DEATHMATCH;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInEventmap() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_EVENTMAP;
|
|
break;
|
|
}
|
|
|
|
if( pTarget->IsInBattleArena() )
|
|
{
|
|
nRet = RESULT_TARGET_IN_BATTLE_ARENA;
|
|
break;
|
|
}
|
|
|
|
if( HuntaholicManager::Instance().GetHuntaholicID( pTarget->GetPos() ) )
|
|
{
|
|
nRet = RESULT_TARGET_IN_HUNTAHOLIC;
|
|
break;
|
|
}
|
|
|
|
// 파티원, 길드원, 길드 연합원만 가능
|
|
int nPartyID = pTarget->GetPartyID();
|
|
if( !nPartyID || nPartyID != pCastPlayer->GetPartyID() )
|
|
{
|
|
int nGuildId = pTarget->GetGuildID();
|
|
int nCasterGuildID = pCastPlayer->GetGuildID();
|
|
if( !nGuildId || nGuildId != nCasterGuildID )
|
|
{
|
|
int nAllianceID = GuildManager::GetInstance().GetAllianceID( nGuildId );
|
|
if( !nAllianceID || nAllianceID != GuildManager::GetInstance().GetAllianceID( nCasterGuildID ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pCastPlayer->PendWarp( pTarget->GetX(), pTarget->GetY(), pTarget->GetLayer() );
|
|
ArcadiaServer::Instance().SetObjectPriority( pCastPlayer, ArSchedulerObject::UPDATE_PRIORITY_HIGHEST );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::SUMMON_PET:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPet *pPet = pItem->GetPetStruct();
|
|
if( !pItem->IsPetCage() || !pItem->GetInstanceFlag().IsOn( ItemInstance::ITEM_FLAG_CONTAIN_PET ) )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pCastPlayer = static_cast< StructPlayer * >( pCaster );
|
|
|
|
// 테이밍 되어있는데 펫 구조체가 없을 경우 새로 할당
|
|
if( !pPet )
|
|
{
|
|
// 자동 테이밍 처리 가능 아이템 체크(GetSummonCode를 펫 우리의 경우 자동 테이밍 종류 펫으로 사용)
|
|
if( !pItem->GetSummonCode() )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE;
|
|
break;
|
|
}
|
|
|
|
pPet = AllocNewPet( pCastPlayer, pItem, pItem->GetSummonCode() );
|
|
|
|
// 잘못된 펫 코드일 가능성 높음
|
|
if( !pPet )
|
|
{
|
|
assert( 0 );
|
|
nRet = RESULT_NOT_ACTABLE;
|
|
break;
|
|
}
|
|
|
|
// 클라한테 추가 펫 정보 송신
|
|
pCastPlayer->AddPet( pPet, false );
|
|
|
|
// DB에 신규 펫 정보 추가, 펫 우리 아이템 업데이트
|
|
pPet->DBQuery( new DB_InsertPet( pPet ) );
|
|
pItem->DBQuery( new DB_UpdateItem( pItem ) );
|
|
}
|
|
|
|
if( !pCastPlayer->IsInWorld() || pCastPlayer->IsDead() || pCastPlayer->IsUsingStorage() ||
|
|
pCastPlayer->IsBoothOpen() || pCastPlayer->IsBoothWatching() || pCastPlayer->IsTrading() ||
|
|
pCastPlayer->IsUsingSkill() || pCastPlayer->IsRiding() || pCastPlayer->HasRidingState() )
|
|
{
|
|
nRet = RESULT_NOT_ACTABLE;
|
|
break;
|
|
}
|
|
|
|
if( pPet->IsNameChanged() )
|
|
{
|
|
// 이미 소환된 펫이 있으면 역소환
|
|
if( pCastPlayer->GetSummonedPet() )
|
|
{
|
|
// 사용된 아이템의 펫과 같다면 역소환만 함
|
|
bool bUnsummonOnly = false;
|
|
if( pCastPlayer->GetSummonedPet() == pItem->GetPetStruct() )
|
|
bUnsummonOnly = true;
|
|
|
|
// 역소환
|
|
pCastPlayer->UnSummonPet();
|
|
|
|
if( bUnsummonOnly )
|
|
break;
|
|
}
|
|
|
|
// 이름 변경 불가면 바로 소환
|
|
pCastPlayer->SummonPet( pItem->GetPetStruct() );
|
|
}
|
|
else
|
|
{
|
|
// 이름을 변경해야 하면 이름 변경 메시지 송신
|
|
TS_SC_SHOW_SET_PET_NAME msg;
|
|
|
|
msg.handle = pPet->GetHandle();
|
|
|
|
PendMessage( pCastPlayer, &msg );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::ADD_CASH: // 인포인트 아이템, 캐시 증가
|
|
{
|
|
if( pItem->GetItemCode() != ItemBase::ITEM_CODE_INGAME_POINT &&
|
|
pItem->GetItemCode() != ItemBase::ITEM_CODE_INGAME_POINT2 &&
|
|
pItem->GetItemCode() != ItemBase::ITEM_CODE_INGAME_POINT3 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >( this );
|
|
pPlayer->DBQuery( new DB_InsertCash( pPlayer, pPlayer->GetAccountName(), pPlayer->GetAccountID(), pItem->GetItemCode(), pItem->GetItemUID() ) );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::HAIR_DYEING:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
// If the item's additional effect includes a hair style change effect, do not perform any checks (the necessary checks are already handled by the hair style change effect itself).
|
|
// If the item's additional effect does not include a hair style change effect, then attempting to change to the same color should fail
|
|
int nIdx = 0;
|
|
const ItemBaseServer & itemBase = pItem->GetItemBase();
|
|
for( nIdx = 0 ; nIdx < ItemBase::MAX_OPTION_NUMBER ; ++nIdx )
|
|
{
|
|
if( itemBase.nOptType[ nIdx ] != ITEM_EFFECT_INSTANT::SET_HAIR_STYLE )
|
|
continue;
|
|
|
|
break;
|
|
}
|
|
|
|
// If the item does not include a hair style change effect
|
|
if( nIdx >= ItemBase::MAX_OPTION_NUMBER )
|
|
{
|
|
// Fail if trying to change to the same color as the current one
|
|
if( pPlayer->GetHairColorIndex() == var1 && pPlayer->GetHairColorRGB() == var2 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pPlayer->SetHairColorIndex( var1 );
|
|
pPlayer->SetHairColorRGB( var2 );
|
|
|
|
// Broadcast the hair style change packet and save it to the DB
|
|
BroadcastHairInfo( pPlayer );
|
|
pPlayer->DBQuery( new DB_UpdateCharacterHair( pPlayer ) );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::SET_HAIR_STYLE:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
// 아이템의 추가 성능에 염색 성능이 포함되어 있을 경우에는 같은 스타일/색상으로 변경하려는 거면 실패
|
|
// 아이템의 추가 성능에 염색 성능이 포함되어 있지 않은 경우에는 같은 스타일로 변경하려는 거면 실패
|
|
int nIdx = ItemBase::MAX_OPTION_NUMBER - 1;
|
|
const ItemBaseServer & itemBase = pItem->GetItemBase();
|
|
for( ; nIdx >= 0 ; --nIdx )
|
|
{
|
|
if( itemBase.nOptType[ nIdx ] != ITEM_EFFECT_INSTANT::HAIR_DYEING )
|
|
continue;
|
|
|
|
if( itemBase.fOptVar1[ nIdx ] == pPlayer->GetHairColorIndex() && itemBase.fOptVar2[ nIdx ] == pPlayer->GetHairColorRGB() &&
|
|
var1 == pPlayer->GetBaseModelId( 0 ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// 윗 단계의 체크 중에 오류 코드가 세팅된 경우 처리 중지(오류 코드가 세팅되지 않았다면 nRet가 초기값인 RESULT_SUCCESS인 상태가 됨)
|
|
if( nRet != RESULT_SUCCESS )
|
|
break;
|
|
|
|
// 염색 성능이 없는 헤어 스타일 변경 아이템일 경우 현재 스타일로 변경하려는 건지 체크
|
|
if( nIdx < 0 && var1 == pPlayer->GetBaseModelId( 0 ) )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
pPlayer->SetBaseModelId( 0, var1 );
|
|
|
|
// 염색 성능이 없는 헤어 스타일 변경 아이템일 경우에만 방송 및 DB 저장(염색 성능이 있는 아이템이면 염색 성능 처리 후에 저장 및 방송됨)
|
|
if( nIdx < 0 )
|
|
{
|
|
BroadcastHairInfo( pPlayer );
|
|
pPlayer->DBQuery( new DB_UpdateCharacterHair( pPlayer ) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::SET_SKIN_COLOR:
|
|
{
|
|
if( !IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
StructPlayer * pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
// 같은 색상으로 변경하려는 경우 실패
|
|
if( pPlayer->GetSkinColor() == var1 )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
// 색깔 바꾸고 방송하고 디비 저장.
|
|
pPlayer->SetSkinColor( var1 );
|
|
BroadcastSkinInfo( pPlayer );
|
|
pPlayer->DBQuery( new DB_UpdateCharacterSkin( pPlayer ) );
|
|
}
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::CAST_WORLD_STATE:
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if ( !static_cast< StructPlayer* >( pCaster )->PendWorldState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetStateLevel(), pItem->GetStateTime() * 100, var1 * 100, pItem->GetItemCode() ) )
|
|
{
|
|
nRet = RESULT_COOL_TIME;
|
|
}
|
|
|
|
break;
|
|
|
|
case ITEM_EFFECT_INSTANT::CAST_PARTY_STATE:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if ( !static_cast< StructPlayer* >( pCaster )->PendPartyState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetStateLevel(), pItem->GetStateTime() * 100, var1 * 100, pItem->GetItemCode() ) )
|
|
{
|
|
nRet = RESULT_COOL_TIME;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ITEM_EFFECT_INSTANT::CAST_GUILD_STATE:
|
|
{
|
|
if( !pCaster->IsPlayer() )
|
|
{
|
|
nRet = RESULT_ACCESS_DENIED;
|
|
break;
|
|
}
|
|
|
|
if ( !static_cast< StructPlayer* >( pCaster )->PendGuildState( (StructState::StateCode)pItem->GetStateCode(), pItem->GetStateLevel(), pItem->GetStateTime() * 100, var1 * 100, pItem->GetItemCode() ) )
|
|
{
|
|
nRet = RESULT_COOL_TIME;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: break;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
bool StructCreature::TurnOnAura( struct StructSkill * pSkill )
|
|
{
|
|
int nToggleGroup = pSkill->GetSkillBase()->GetToggleGroup();
|
|
|
|
if( nToggleGroup > SkillBase::MAX_TOGGLE_GROUP || nToggleGroup < 0 )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
TS_SC_AURA msg;
|
|
|
|
bool bExistSameGroup = false;
|
|
|
|
std::vector< std::pair<StructSkill *, int> >::iterator it;
|
|
|
|
for( it = m_vAura.begin(); it != m_vAura.end(); ++it )
|
|
{
|
|
if( (*it).first->GetSkillBase()->GetToggleGroup() != 0 && (*it).first->GetSkillBase()->GetToggleGroup() == nToggleGroup )
|
|
{
|
|
msg.caster = GetHandle();
|
|
msg.skill_id = (*it).first->GetSkillId();
|
|
|
|
msg.status = false;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
PendMessage( this, &msg );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
PendMessage( static_cast< StructSummon * >( this )->GetMaster(), &msg );
|
|
}
|
|
(*it) = std::pair<StructSkill *,int>( pSkill, pSkill->GetRequestedSkillLevel() );
|
|
bExistSameGroup = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !bExistSameGroup )
|
|
m_vAura.push_back( std::pair<StructSkill *,int>( pSkill, pSkill->GetRequestedSkillLevel() ) );
|
|
|
|
msg.caster = GetHandle();
|
|
msg.skill_id = pSkill->GetSkillId();
|
|
|
|
msg.status = true;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
PendMessage( this, &msg );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
PendMessage( static_cast< StructSummon * >( this )->GetMaster(), &msg );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool StructCreature::IsActiveAura( struct StructSkill * pSkill )
|
|
{
|
|
std::vector< std::pair<StructSkill *, int> >::iterator it;
|
|
|
|
for( it = m_vAura.begin(); it != m_vAura.end(); ++it )
|
|
{
|
|
if( (*it).first == pSkill )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool StructCreature::TurnOffAura( struct StructSkill * pSkill )
|
|
{
|
|
std::vector< std::pair<StructSkill *, int> >::iterator it;
|
|
|
|
for( it = m_vAura.begin(); it != m_vAura.end(); ++it )
|
|
{
|
|
if( (*it).first == pSkill )
|
|
{
|
|
TS_SC_AURA msg;
|
|
|
|
msg.caster = GetHandle();
|
|
msg.skill_id = (*it).first->GetSkillId();
|
|
|
|
msg.status = false;
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
PendMessage( this, &msg );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
PendMessage( static_cast< StructSummon * >( this )->GetMaster(), &msg );
|
|
}
|
|
vector_fast_erase( &m_vAura, it );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void StructCreature::ToggleAura( struct StructSkill * pSkill )
|
|
{
|
|
if( !TurnOffAura( pSkill ) )
|
|
TurnOnAura( pSkill );
|
|
}
|
|
|
|
|
|
void StructCreature::onDead( StructCreature *pFrom, bool decreaseEXPOnDead )
|
|
{
|
|
// 캐스팅 취소
|
|
if( IsUsingSkill() )
|
|
{
|
|
CancelSkill();
|
|
}
|
|
|
|
// 죽었으니 이동 정지
|
|
if( IsMoving() )
|
|
{
|
|
ArPosition pos = GetCurrentPosition( m_nDeadTime );
|
|
ArcadiaServer::Instance().SetMove( this, pos, pos, 0, true, GetArTime() );
|
|
|
|
if( IsPlayer() && static_cast< StructPlayer * >( this )->GetRideObject() )
|
|
{
|
|
ArcadiaServer::Instance().SetMove( static_cast< StructPlayer * >( this )->GetRideObject(), pos, pos, 0, true, GetArTime() );
|
|
}
|
|
}
|
|
|
|
if( IsAttacking() )
|
|
{
|
|
EndAttack();
|
|
}
|
|
|
|
// 오라 제거~
|
|
|
|
|
|
RemoveAllHate();
|
|
removeStateByDead();
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
//RemoveAllAura();
|
|
|
|
|
|
|
|
// 경험치 감소 여부에 관계없이 마지막에 감소되었던 경험치를 초기화하여 의도하지 않은 동작을 막는다.
|
|
// 만약 경험치 감소가 일어난다면 이후에 새로운 값이 설정될 것이며 경험치 감소가 일어나지 않는다하더라도 최종적으로는 감소된 경험치가 0으로 설정된다.
|
|
SetLastDecreasedEXP( 0 );
|
|
}
|
|
|
|
void StructCreature::RemoveAllHate()
|
|
{
|
|
// { Hate 초기화
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
|
|
std::vector< AR_HANDLE > vEnemyList = m_vEnemyList;
|
|
|
|
for( it = vEnemyList.begin(); it != vEnemyList.end(); ++it )
|
|
{
|
|
StructCreature::iterator itMonster = StructCreature::get( *it );
|
|
|
|
if( (*itMonster) && (*itMonster)->IsMonster() )
|
|
{
|
|
StructMonster * pMonster = static_cast< StructMonster * >( *itMonster );
|
|
|
|
pMonster->RemoveHate( GetHandle(), pMonster->GetHate( GetHandle() ) );
|
|
}
|
|
}
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE( m_csEnemy );
|
|
|
|
m_vEnemyList.clear();
|
|
}
|
|
// }
|
|
}
|
|
|
|
bool StructCreature::IsEnemy( StructCreature* pTarget, bool bIncludeHiding )
|
|
{
|
|
if( !pTarget )
|
|
return false;
|
|
|
|
if( !pTarget->IsInWorld() )
|
|
return false;
|
|
|
|
// 나 자신이 무적이라고 해서 적을 적이라 부르지 못하는 건 아님 2012-05-17 Synastry
|
|
//if( IsInvincible() || !isMortal() )
|
|
// return false;
|
|
|
|
if( pTarget->IsInvincible() || !pTarget->isMortal() )
|
|
return false;
|
|
|
|
if( !bIncludeHiding && !IsVisible( pTarget ) )
|
|
return false;
|
|
|
|
if( IsAlly( pTarget ) )
|
|
return false;
|
|
|
|
if( pTarget->IsPet() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StructCreature::IsAlly( StructCreature* pTarget )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const c_fixed10 StructCreature::GetAttackPointRightWithoutWeapon( Elemental::Type type, bool bPhysical, bool bBad ) const
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return GetAttackPointRightWithoutWeapon() * m_BadPhysicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
|
|
return GetAttackPointRightWithoutWeapon() * m_GoodPhysicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
}
|
|
|
|
if( bBad )
|
|
return GetAttackPointRightWithoutWeapon() * m_BadMagicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
|
|
return GetAttackPointRightWithoutWeapon() * m_GoodMagicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
}
|
|
|
|
int StructCreature::GetAttackPointRight( Elemental::Type type, bool bPhysical, bool bBad )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return GetAttackPointRight() * m_BadPhysicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
|
|
return GetAttackPointRight() * m_GoodPhysicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
}
|
|
|
|
if( bBad )
|
|
return GetAttackPointRight() * m_BadMagicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
|
|
return GetAttackPointRight() * m_GoodMagicalElementalSkillStateMod[type].fPhysicalDamage;
|
|
}
|
|
|
|
int StructCreature::GetMagicPoint( Elemental::Type type, bool bPhysical, bool bBad )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return m_Attribute.fMagicPoint * m_BadPhysicalElementalSkillStateMod[type].fMagicalDamage;
|
|
|
|
return m_Attribute.fMagicPoint * m_GoodPhysicalElementalSkillStateMod[type].fMagicalDamage;
|
|
}
|
|
|
|
if( bBad )
|
|
return m_Attribute.fMagicPoint * m_BadMagicalElementalSkillStateMod[type].fMagicalDamage;
|
|
|
|
return m_Attribute.fMagicPoint * m_GoodMagicalElementalSkillStateMod[type].fMagicalDamage;
|
|
}
|
|
|
|
float StructCreature::GetMagicalHateMod( Elemental::Type type, bool bPhysical, bool bBad )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return m_BadPhysicalElementalSkillStateMod[type].fHate;
|
|
|
|
return m_GoodPhysicalElementalSkillStateMod[type].fHate;
|
|
}
|
|
|
|
if( bBad )
|
|
return m_BadMagicalElementalSkillStateMod[type].fHate;
|
|
|
|
return m_GoodMagicalElementalSkillStateMod[type].fHate;
|
|
}
|
|
|
|
std::pair< float, int> StructCreature::GetHateMod( int nHateModType, bool bIsHarmful )
|
|
{
|
|
float fAmpValue = 1.0f;
|
|
int nIncValue = 0;
|
|
|
|
for( std::vector< HateModifier >::iterator it = m_vHateMod.begin(); it != m_vHateMod.end(); ++it )
|
|
{
|
|
bool bApply = false;
|
|
|
|
if( ( bIsHarmful && (*it).bIsApplyToHarmful ) || ( !bIsHarmful && (*it).bIsApplyToHelpful ) )
|
|
{
|
|
if( ( nHateModType == 1 && (*it).bIsApplyToPhysicalSkill )
|
|
|| ( nHateModType == 2 && (*it).bIsApplyToMagicalSkill )
|
|
|| ( nHateModType == 3 && (*it).bIsApplyToPhysicalAttack ) )
|
|
{
|
|
bApply = true;
|
|
}
|
|
}
|
|
|
|
if( bApply )
|
|
{
|
|
fAmpValue += (*it).fAmpValue;
|
|
nIncValue += (*it).nIncValue;
|
|
}
|
|
}
|
|
|
|
return std::pair< float, int >( fAmpValue, nIncValue );
|
|
}
|
|
|
|
unsigned char StructCreature::GetRealMoveSpeed() const
|
|
{
|
|
int RealMoveSpeed = GetMoveSpeed()/7;
|
|
if( RealMoveSpeed > UCHAR_MAX )
|
|
RealMoveSpeed = UCHAR_MAX;
|
|
|
|
return RealMoveSpeed;
|
|
}
|
|
|
|
unsigned char StructCreature::GetRealRidingSpeed() const
|
|
{
|
|
int RealRidingSpeed = GetRidingSpeed()/7;
|
|
if( RealRidingSpeed > UCHAR_MAX )
|
|
RealRidingSpeed = UCHAR_MAX;
|
|
|
|
return RealRidingSpeed;
|
|
}
|
|
|
|
float StructCreature::GetManaCostRatio( Elemental::Type type, bool bPhysical, bool bBad )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return m_BadPhysicalElementalSkillStateMod[type].fManaCostRatio;
|
|
|
|
return m_GoodPhysicalElementalSkillStateMod[type].fManaCostRatio;
|
|
}
|
|
|
|
if( bBad )
|
|
return m_BadMagicalElementalSkillStateMod[type].fManaCostRatio;
|
|
|
|
return m_GoodMagicalElementalSkillStateMod[type].fManaCostRatio;
|
|
}
|
|
|
|
float StructCreature::GetCastingMod( Elemental::Type type, bool bPhysical, bool bBad, AR_TIME nOriginalCoolTime )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
{
|
|
if( m_BadPhysicalElementalSkillStateMod[type].nCastingSpeedApplyTime >= nOriginalCoolTime )
|
|
{
|
|
return m_BadPhysicalElementalSkillStateMod[type].fCastingSpeed;
|
|
}
|
|
else
|
|
{
|
|
return 1.0f;
|
|
}
|
|
}
|
|
|
|
if( m_GoodPhysicalElementalSkillStateMod[type].nCastingSpeedApplyTime >= nOriginalCoolTime )
|
|
{
|
|
return m_GoodPhysicalElementalSkillStateMod[type].fCastingSpeed;
|
|
}
|
|
else
|
|
{
|
|
return 1.0f;
|
|
}
|
|
}
|
|
|
|
if( bBad )
|
|
{
|
|
if( m_BadMagicalElementalSkillStateMod[type].nCastingSpeedApplyTime >= nOriginalCoolTime )
|
|
{
|
|
return m_BadMagicalElementalSkillStateMod[type].fCastingSpeed;
|
|
}
|
|
else
|
|
{
|
|
return 1.0f;
|
|
}
|
|
}
|
|
|
|
if( m_GoodMagicalElementalSkillStateMod[type].nCastingSpeedApplyTime >= nOriginalCoolTime )
|
|
{
|
|
return m_GoodMagicalElementalSkillStateMod[type].fCastingSpeed;
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
float StructCreature::GetCoolTimeMod( Elemental::Type type, bool bPhysical, bool bBad )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bBad )
|
|
return m_BadPhysicalElementalSkillStateMod[type].fCooltime;
|
|
|
|
return m_GoodPhysicalElementalSkillStateMod[type].fCooltime;
|
|
}
|
|
|
|
if( bBad )
|
|
return m_BadMagicalElementalSkillStateMod[type].fCooltime;
|
|
|
|
return m_GoodMagicalElementalSkillStateMod[type].fCooltime;
|
|
}
|
|
|
|
bool StructCreature::SetPendingMove( const std::vector< ArPosition > & newPos, unsigned char speed )
|
|
{
|
|
if( HasPendingMove() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_PendingMovePos = newPos;
|
|
m_nPendingMoveSpeed = speed;
|
|
|
|
m_StatusFlag.On( STATUS_MOVE_PENDED );
|
|
|
|
return true;
|
|
}
|
|
|
|
void StructCreature::AddHateToEnemyList( AR_HANDLE handle, int pt )
|
|
{
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
std::vector< AR_HANDLE > vInvalidEnemy;
|
|
std::vector< AR_HANDLE > vEnemy;
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE( m_csEnemy );
|
|
|
|
for( it = m_vEnemyList.begin(); it != m_vEnemyList.end(); ++it )
|
|
{
|
|
StructCreature::iterator itEnemy = StructCreature::get( (*it) );
|
|
|
|
if( !(*itEnemy) || !(*itEnemy)->IsMonster() )
|
|
{
|
|
vInvalidEnemy.push_back( (*it) );
|
|
continue;
|
|
}
|
|
|
|
if( (*itEnemy)->GetPos().GetDistance( GetPos() ) > GameRule::VISIBLE_RANGE )
|
|
continue;
|
|
else if( static_cast< StructMonster * >(*itEnemy)->GetStatus() == StructMonster::STATUS_NORMAL )
|
|
continue;
|
|
|
|
vEnemy.push_back( *it );
|
|
}
|
|
}
|
|
|
|
for( it = vEnemy.begin(); it != vEnemy.end(); ++it )
|
|
{
|
|
StructCreature::iterator itEnemy = StructCreature::get( (*it) );
|
|
|
|
if( (*itEnemy) && (*itEnemy)->IsMonster() )
|
|
static_cast< StructMonster *>( (*itEnemy) )->AddHate( handle, m_fHateRatio * pt );
|
|
}
|
|
|
|
for( it = vInvalidEnemy.begin(); it != vInvalidEnemy.end(); ++it )
|
|
{
|
|
RemoveFromEnemyList( (*it) );
|
|
}
|
|
}
|
|
|
|
bool StructCreature::AddToEnemyList( AR_HANDLE handle )
|
|
{
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
|
|
THREAD_SYNCHRONIZE( m_csEnemy );
|
|
|
|
for( it = m_vEnemyList.begin(); it != m_vEnemyList.end(); ++it )
|
|
{
|
|
if( (*it) == handle )
|
|
return false;
|
|
}
|
|
|
|
m_vEnemyList.push_back( handle );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StructCreature::RemoveFromEnemyList( AR_HANDLE handle )
|
|
{
|
|
std::vector< AR_HANDLE >::iterator it;
|
|
|
|
THREAD_SYNCHRONIZE( m_csEnemy );
|
|
|
|
for( it = m_vEnemyList.begin(); it != m_vEnemyList.end(); ++it )
|
|
{
|
|
if( (*it) == handle )
|
|
{
|
|
vector_fast_erase( &m_vEnemyList, it );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void StructCreature::AddEnergy( int nEnergy )
|
|
{
|
|
if( m_nEnergy >= m_nMaxEnergy )
|
|
return;
|
|
|
|
AR_TIME nKeepTime = GetArTime() + m_nEnergyUpkeepTime;
|
|
|
|
for( int i = 0; i < nEnergy; ++i )
|
|
{
|
|
int pos = m_nEnergy + m_nEnergyStartPos + i;
|
|
if( pos >= GameRule::ENERGY_MAX )
|
|
{
|
|
pos -= GameRule::ENERGY_MAX;
|
|
}
|
|
|
|
m_arEnergy[pos] = nKeepTime;
|
|
|
|
++m_nEnergy;
|
|
|
|
if( m_nEnergy >= m_nMaxEnergy )
|
|
break;
|
|
}
|
|
|
|
onEnergyChange();
|
|
}
|
|
|
|
void StructCreature::RemoveEnergy( int nEnergy )
|
|
{
|
|
// 일정 확률로 기공을 소모하지 않는다.
|
|
if( XRandom( 0, 99 ) < GetEnergyUnconsumptionRate() )
|
|
return;
|
|
|
|
int nRemoveCnt = std::min( nEnergy, m_nEnergy );
|
|
|
|
if( nRemoveCnt < 1 )
|
|
return;
|
|
|
|
m_nEnergy -= nRemoveCnt;
|
|
|
|
m_nEnergyStartPos += nRemoveCnt;
|
|
|
|
if( m_nEnergyStartPos >= GameRule::ENERGY_MAX )
|
|
{
|
|
m_nEnergyStartPos -= GameRule::ENERGY_MAX;
|
|
}
|
|
|
|
onEnergyChange();
|
|
}
|
|
|
|
ItemBase::ItemClass StructCreature::GetArmorClass()
|
|
{
|
|
StructItem * pArmor = GetWearedItem( ItemBase::WEAR_ARMOR );
|
|
|
|
if( !pArmor )
|
|
return ItemBase::CLASS_ETC;
|
|
|
|
return pArmor->GetItemClass();
|
|
}
|
|
|
|
ItemBase::ItemClass StructCreature::GetWeaponClass()
|
|
{
|
|
StructItem * pWeapon = GetWearedItem( ItemBase::WEAR_WEAPON );
|
|
|
|
if( !pWeapon )
|
|
return ItemBase::CLASS_ETC;
|
|
|
|
if( IsUsingDoubleWeapon() )
|
|
{
|
|
StructItem * pLeftWeapon = GetWearedItem( ItemBase::WEAR_LEFTHAND );
|
|
|
|
if( pWeapon->GetItemClass() == ItemBase::CLASS_ONEHAND_SWORD && pLeftWeapon->GetItemClass() == ItemBase::CLASS_ONEHAND_SWORD )
|
|
{
|
|
return ItemBase::CLASS_DOUBLE_SWORD;
|
|
}
|
|
else if( pWeapon->GetItemClass() == ItemBase::CLASS_DAGGER && pLeftWeapon->GetItemClass() == ItemBase::CLASS_DAGGER )
|
|
{
|
|
return ItemBase::CLASS_DOUBLE_DAGGER;
|
|
}
|
|
else if( pWeapon->GetItemClass() == ItemBase::CLASS_ONEHAND_AXE && pLeftWeapon->GetItemClass() == ItemBase::CLASS_ONEHAND_AXE )
|
|
{
|
|
return ItemBase::CLASS_DOUBLE_AXE;
|
|
}
|
|
<<<<<<< HEAD
|
|
else if (pWeapon->GetItemClass() == ItemBase::CLASS_CROSSBOW && pLeftWeapon->GetItemClass() == ItemBase::CLASS_CROSSBOW) // Double Crossbow
|
|
{
|
|
return ItemBase::CLASS_DOUBLE_CROSSBOW;
|
|
=======
|
|
else if (pWeapon->GetItemClass() == ItemBase::CLASS_CROSSBOW && pLeftWeapon->GetItemClass() == ItemBase::CLASS_CROSSBOW) // ZONE DOUBLE CROSSBOW
|
|
{
|
|
return ItemBase::CLASS_DOUBLE_CROSSBOW; // From ZONE source; dual crossbows
|
|
>>>>>>> a34328224e914a577b99c79ec6e8ffbcea554a05
|
|
}
|
|
}
|
|
|
|
return pWeapon->GetItemClass();
|
|
}
|
|
|
|
unsigned short StructCreature::putoffItem( StructCreature * pCreature, ItemBase::ItemWearType pos )
|
|
{
|
|
return pCreature->putoffItem( pos );
|
|
}
|
|
|
|
int StructCreature::onDamage( StructCreature * pFrom, Elemental::Type elementalType, DamageType damageType, int nDamage, bool bCritical )
|
|
{
|
|
// 일반 공격의 하보크 처리는 Attack 함수에서 처리(블럭, 퍼펙트 블럭, 미스 판정 여부를 알아야 함)
|
|
|
|
// 불사신 효과는 데미지는 받지만 죽지 않는 상태이므로 패스데미지/데미지 반사 등의 처리가 모두 된 이후에 실제 데미지가 들어가지 않도록 한다.
|
|
int nMinHP = m_fMinHP * GetMaxHP();
|
|
if( nMinHP < m_nMinHP )
|
|
nMinHP = m_nMinHP;
|
|
|
|
if( m_nHP <= nMinHP )
|
|
nDamage = 0;
|
|
else if( m_nHP - nDamage < nMinHP )
|
|
nDamage = m_nHP - nMinHP;
|
|
|
|
return nDamage;
|
|
}
|
|
|
|
void StructCreature::EnumActiveSkill( SKILL_POINTER_FUNCTOR & _fo )
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
|
|
for( it = m_vActiveSkillList.begin(); it != m_vActiveSkillList.end(); ++it )
|
|
{
|
|
_fo.onSkill( (*it) );
|
|
}
|
|
}
|
|
|
|
void StructCreature::EnumPassiveSkill( SKILL_POINTER_FUNCTOR & _fo )
|
|
{
|
|
std::vector< StructSkill * >::const_iterator it;
|
|
|
|
for( it = m_vPassiveSkillList.begin(); it != m_vPassiveSkillList.end(); ++it )
|
|
{
|
|
_fo.onSkill( (*it) );
|
|
}
|
|
}
|
|
|
|
void StructCreature::EnumAddedSkill( ADDED_SKILL_FUNCTOR & _fo ) const
|
|
{
|
|
std::vector< std::pair< int, int > >::const_iterator it;
|
|
|
|
for( it = m_vAddedSkillBySkillId.begin(); it != m_vAddedSkillBySkillId.end(); it++ )
|
|
{
|
|
_fo.onSkill( (*it).first, false, (*it).second );
|
|
}
|
|
|
|
for( it = m_vAddedSkillBySkillType.begin(); it != m_vAddedSkillBySkillType.end(); it++ )
|
|
{
|
|
_fo.onSkill( (*it).first, true, (*it).second );
|
|
}
|
|
}
|
|
|
|
void StructCreature::removeStateByDead()
|
|
{
|
|
ClearRemovedStateByDead();
|
|
|
|
std::vector< StructState > removedStates;
|
|
RemoveStateIf( StateFlagChecker( StateInfo::ERASE_ON_DEAD ), &removedStates, true );
|
|
|
|
// m_vStateListRemovedByDeath 변수는 StructCreature에 선언되어있지만 StructPlayer 밖에 사용할 수가 없다.
|
|
if( IsPlayer() )
|
|
{
|
|
for ( std::vector< StructState >::iterator it = removedStates.begin(); it != removedStates.end(); ++it )
|
|
{
|
|
// 크루 아이템을 통한 부활시 없어진 지속효과 복구를 위해 임시 보관
|
|
// 해당 리스트에서 StructState를 다시 꺼내서 걸 경우 시작 시간, 끝 시간을 조정해야 함
|
|
if( !it->IsHarmful() )
|
|
{
|
|
(*it).SaveByDead( this );
|
|
|
|
m_vStateListRemovedByDeath.push_back( *it );
|
|
}
|
|
else
|
|
{
|
|
(*it).Expire( this );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void StructCreature::removeStateWithFlag( const int & nFlag )
|
|
{
|
|
RemoveStateIf( StateFlagChecker( nFlag ) );
|
|
}
|
|
|
|
void StructCreature::processPendingMove()
|
|
{
|
|
// { pending move
|
|
do
|
|
{
|
|
if( HasPendingMove() && GetMovableTime() < GetArTime() )
|
|
{
|
|
m_StatusFlag.Off( STATUS_MOVE_PENDED );
|
|
|
|
if( IsActable() && IsMovable() )
|
|
{
|
|
AR_TIME tm = GetArTime();
|
|
ArPosition pos = GetCurrentPosition( tm );
|
|
|
|
ArcadiaServer::Instance().SetMultipleMove( this, pos, m_PendingMovePos, m_nPendingMoveSpeed, true, tm );
|
|
|
|
if( IsPlayer() && static_cast< StructPlayer * >( this )->IsRiding() )
|
|
{
|
|
ArcadiaServer::Instance().SetMultipleMove( static_cast< StructPlayer * >( this )->GetRideObject(), pos, m_PendingMovePos, m_nPendingMoveSpeed, true, tm );
|
|
}
|
|
|
|
if( IsSummon() )
|
|
{
|
|
ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_NORMAL );
|
|
}
|
|
}
|
|
}
|
|
} while( false );
|
|
// } pending move
|
|
}
|
|
|
|
void StructCreature::procMoveSpeedChangement()
|
|
{
|
|
if( !IsMoving() )
|
|
return;
|
|
|
|
ArPosition pos = GetCurrentPosition( GetArTime() );
|
|
|
|
// 이동 불가가 되었다면 현재 위치에 정지
|
|
if( !IsMovable() )
|
|
{
|
|
ArcadiaServer::Instance().SetMove( this, pos, pos, 0, true, GetArTime() );
|
|
}
|
|
// 이동 중이었고 이동 가능 상태라면 현재 이동 속도와 스텟상의 이동 속도가 다를 경우 다시 이동 시킴
|
|
else if( GetSpeed() != GetRealMoveSpeed() )
|
|
{
|
|
const std::vector< ArMoveVector::MOVE_INFO > & vMoveVector( GetTargetPosList() );
|
|
std::vector< ArPosition > vMovePos;
|
|
|
|
for( std::vector< ArMoveVector::MOVE_INFO >::const_iterator it = vMoveVector.begin() ; it != vMoveVector.end() ; ++it )
|
|
vMovePos.push_back( (*it).end );
|
|
|
|
ArcadiaServer::Instance().SetMultipleMove( this, pos, vMovePos, GetRealMoveSpeed(), true, GetArTime() );
|
|
}
|
|
}
|
|
|
|
void StructCreature::PrepareRemoveExhaustiveSkillStateMod( bool bPhysical, bool bHarmful, int nElementalType, AR_TIME nOriginalCastingDelay )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bHarmful )
|
|
{
|
|
m_BadPhysicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCodeForDelete = m_BadPhysicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCode;
|
|
}
|
|
else
|
|
{
|
|
m_GoodPhysicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCodeForDelete = m_GoodPhysicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCode;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( bHarmful )
|
|
{
|
|
m_BadMagicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCodeForDelete = m_BadMagicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCode;
|
|
}
|
|
else
|
|
{
|
|
m_GoodMagicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCodeForDelete = m_GoodMagicalElementalSkillStateMod[ nElementalType ].vExhaustiveStateCode;
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::RemoveExhaustiveSkillStateMod( bool bPhysical, bool bHarmful, int nElementalType, AR_TIME nOriginalCastingDelay )
|
|
{
|
|
if( bPhysical )
|
|
{
|
|
if( bHarmful )
|
|
{
|
|
removeExhaustiveSkillStateMod( &m_BadPhysicalElementalSkillStateMod[ nElementalType ], nOriginalCastingDelay );
|
|
}
|
|
else
|
|
{
|
|
removeExhaustiveSkillStateMod( &m_GoodPhysicalElementalSkillStateMod[ nElementalType ], nOriginalCastingDelay );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( bHarmful )
|
|
{
|
|
removeExhaustiveSkillStateMod( &m_BadMagicalElementalSkillStateMod[ nElementalType ], nOriginalCastingDelay );
|
|
}
|
|
else
|
|
{
|
|
removeExhaustiveSkillStateMod( &m_GoodMagicalElementalSkillStateMod[ nElementalType ], nOriginalCastingDelay );
|
|
}
|
|
}
|
|
|
|
CalculateStat();
|
|
}
|
|
|
|
void StructCreature::removeExhaustiveSkillStateMod( ElementalSkillStateMod *pSkillStateMod, AR_TIME nOriginalCastingDelay )
|
|
{
|
|
std::vector< StructState::StateCode > vEraseList = pSkillStateMod->vExhaustiveStateCodeForDelete;
|
|
|
|
std::vector< StructState::StateCode >::iterator it;
|
|
|
|
for( it = vEraseList.begin() ; it != vEraseList.end() ; ++it )
|
|
{
|
|
StructState *pState = GetState( *it );
|
|
if( !pState )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( pState->GetEffectType() == StructState::EF_ADD_PARAMETER_ON_SKILL && pState->GetValue( 11 ) && pState->GetValue( 11 ) * 100 < nOriginalCastingDelay )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RemoveState( *it, pState->GetLevel() );
|
|
}
|
|
}
|
|
|
|
void StructCreature::RemoveGoodState( int state_level )
|
|
{
|
|
std::vector< StructState::StateCode > vEraseStateList;
|
|
|
|
STATE_ITERATOR it;
|
|
for( it = m_vStateList.begin(); it != m_vStateList.end(); ++it )
|
|
{
|
|
if( (*it).IsHarmful() ) continue;
|
|
if( !( (*it).GetTimeType() & StateInfo::ERASE_ON_DEAD ) ) continue;
|
|
|
|
vEraseStateList.push_back( (*it).GetCode() );
|
|
}
|
|
|
|
for( std::vector< StructState::StateCode >::iterator itState = vEraseStateList.begin(); itState != vEraseStateList.end(); ++itState )
|
|
{
|
|
RemoveState( (*itState), state_level );
|
|
}
|
|
}
|
|
|
|
int StructCreature::damage( StructCreature * pFrom, int nDamage, bool decreaseEXPOnDead )
|
|
{
|
|
if( IsDead() ) return 0;
|
|
|
|
// 은신 해제
|
|
if( IsHiding() )
|
|
{
|
|
RemoveState( StructState::HIDE, GameRule::MAX_STATE_LEVEL );
|
|
RemoveState( StructState::TRACE_OF_FUGITIVE, GameRule::MAX_STATE_LEVEL );
|
|
}
|
|
|
|
m_nHP = ( m_nHP > nDamage ? m_nHP - nDamage : 0 );
|
|
if( IsDead() )
|
|
{
|
|
// 죽었다면 죽은 시간 세팅
|
|
SetDeadTime( GetArTime() );
|
|
onDead( pFrom, decreaseEXPOnDead );
|
|
}
|
|
return nDamage;
|
|
}
|
|
|
|
void StructCreature::ProcessAddHPMPOnCritical()
|
|
{
|
|
if( m_vAddHPMPOnCritical.empty() )
|
|
return;
|
|
|
|
for( std::vector< AddHPMPOnCriticalInfo >::iterator it = m_vAddHPMPOnCritical.begin() ; it != m_vAddHPMPOnCritical.end() ; ++it )
|
|
{
|
|
if( XRandom( 0, 99 ) < (*it).nActivationRate )
|
|
{
|
|
AddHP( (*it).nAddHP );
|
|
AddMP( (*it).nAddMP );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool StructCreature::IsVisible( StructCreature *pTarget )
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
ArPosition pos = GetCurrentPosition( t );
|
|
|
|
if( !pTarget->IsInvisible() && ( !pTarget->IsHiding() || pTarget->GetCurrentPosition( t ).GetDistance( pos ) < m_fDetectHideRange ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void StructCreature::onProcess( int nThreadIdx )
|
|
{
|
|
AR_TIME t = GetArTime();
|
|
|
|
{
|
|
ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( this ) );
|
|
|
|
for( std::vector< StructState >::iterator it = m_vPendStateList.begin(); it != m_vPendStateList.end(); ++it )
|
|
{
|
|
AddState( (*it).GetCode(), (*it).GetCaster(), (*it).GetLevel(), t, t + (*it).GetEndTime() - (*it).GetStartTime(), (*it).IsAura(), (*it).GetStateValue(), (*it).GetStateStringValue(), (*it).IsByEvent() );
|
|
}
|
|
|
|
m_vPendStateList.clear();
|
|
|
|
// 지속효과 적용 (여기서 사망하실수도 있는지라 가장 늦게 적용해야함 -.-)
|
|
if( m_vStateList.size() && m_nLastStateProcTime + 100 < t )
|
|
{
|
|
procStateDamage( t );
|
|
procState( t );
|
|
m_nLastStateProcTime = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::onHPChange( int nPrevHP )
|
|
{
|
|
if( nPrevHP == 0 && GetHP() > 0 )
|
|
{
|
|
removeStateWithFlag( StateInfo::ERASE_ON_RESURRECT );
|
|
}
|
|
}
|
|
|
|
// 범용적인 부활 처리, 추후에 기존의 부활들도 이 함수를 통하도록 수정
|
|
bool StructCreature::Resurrect( const _CHARACTER_RESURRECTION_TYPE eResurrectType, const int nIncHP, const int nIncMP, const __int64 nRecoveryEXP, const bool bIsRestoreRemovedStateByDead )
|
|
{
|
|
if( !IsDead() || ( !IsSummon() && !IsPlayer() ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 최소 1 회복
|
|
AddHP( std::max( nIncHP, 1 ) );
|
|
AddMP( nIncMP );
|
|
SetEXP( GetEXP() + nRecoveryEXP );
|
|
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
if (bIsRestoreRemovedStateByDead) RestoreRemovedStateByDead();
|
|
else ClearRemovedStateByDead();
|
|
|
|
|
|
//RestoreRemovedStateByDead();
|
|
|
|
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >( this );
|
|
pPlayer->Save( true );
|
|
|
|
if( pPlayer->IsCompeteDead() )
|
|
pPlayer->SetCompeteDead( false );
|
|
|
|
LOG::Log11N4S( LM_CHARACTER_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(), eResurrectType, 0, 0, 0, pPlayer->GetX(), pPlayer->GetY(), pPlayer->GetLayer(), nRecoveryEXP, pPlayer->GetEXP(),
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", LOG::STR_NTS, "" , LOG::STR_NTS );
|
|
}
|
|
else if( IsSummon() )
|
|
{
|
|
StructSummon * pSummon = static_cast< StructSummon * >( this );
|
|
StructItem *pCard = pSummon->GetParentCard();
|
|
if( pCard && pCard->GetInstanceFlag().IsOn( ItemInstance::ITEM_FLAG_SUMMON_DURABILITY ) )
|
|
{
|
|
pCard->SetCurrentEtherealDurability( pCard->GetCurrentEtherealDurability() + 1 );
|
|
if( pSummon->GetMaster() )
|
|
SendItemMessage( pSummon->GetMaster(), pCard );
|
|
|
|
pCard->SetInstanceFlagOff( ItemInstance::ITEM_FLAG_SUMMON_DURABILITY );
|
|
}
|
|
|
|
pSummon->DBQuery( new DB_UpdateSummon( pSummon ) );
|
|
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >(pSummon->GetMaster());
|
|
LOG::Log11N4S( LM_SUMMON_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(), pSummon->GetSID(), 0, 0, 0, 0, 0, (nRecoveryEXP > 0), nRecoveryEXP, pSummon->GetEXP(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", LOG::STR_NTS, "", LOG::STR_NTS );
|
|
}
|
|
|
|
BroadcastHPMPMsg( this, nIncHP, nIncMP );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool StructCreature::ResurrectByState()
|
|
{
|
|
if (!IsDead() || (!IsSummon() && !IsPlayer()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
StructState* pResurrectState = NULL;
|
|
|
|
for (std::vector< StructState >::iterator it = m_vStateList.begin(); it != m_vStateList.end(); ++it)
|
|
{
|
|
if ((*it).GetEffectType() == StructState::EF_RESURRECTION)
|
|
{
|
|
if (!pResurrectState || pResurrectState->GetLevel() < (*it).GetLevel())
|
|
{
|
|
pResurrectState = &(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!pResurrectState)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// resurrect~
|
|
|
|
int nIncHP = (pResurrectState->GetValue(0) + pResurrectState->GetValue(1) * pResurrectState->GetLevel()) * GetMaxHP();
|
|
int nIncMP = (pResurrectState->GetValue(2) + pResurrectState->GetValue(3) * pResurrectState->GetLevel()) * GetMaxMP();
|
|
__int64 nRecoveryEXP = GetLastDecreasedEXP() * (pResurrectState->GetValue(4) + pResurrectState->GetValue(5) * pResurrectState->GetLevel());
|
|
|
|
SetEXP(GetEXP() + nRecoveryEXP);
|
|
|
|
AddHP(nIncHP);
|
|
AddMP(nIncMP);
|
|
|
|
if (IsPlayer())
|
|
{
|
|
StructPlayer* pPlayer = static_cast<StructPlayer*>(this);
|
|
pPlayer->Save(true);
|
|
|
|
if (pPlayer->IsCompeteDead())
|
|
pPlayer->SetCompeteDead(false);
|
|
|
|
LOG::Log11N4S(LM_CHARACTER_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(), CRT_STATE, 0, 0, 0, pPlayer->GetX(), pPlayer->GetY(), pPlayer->GetLayer(), nRecoveryEXP, pPlayer->GetEXP(),
|
|
pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", LOG::STR_NTS, "", LOG::STR_NTS);
|
|
|
|
}
|
|
else if (IsSummon())
|
|
{
|
|
StructSummon* pSummon = static_cast<StructSummon*>(this);
|
|
StructItem* pCard = pSummon->GetParentCard();
|
|
if (pCard && pCard->GetInstanceFlag().IsOn(ItemInstance::ITEM_FLAG_SUMMON_DURABILITY))
|
|
{
|
|
pCard->SetCurrentEtherealDurability(pCard->GetCurrentEtherealDurability() + 1);
|
|
if (pSummon->GetMaster())
|
|
SendItemMessage(pSummon->GetMaster(), pCard);
|
|
|
|
pCard->SetInstanceFlagOff(ItemInstance::ITEM_FLAG_SUMMON_DURABILITY);
|
|
}
|
|
|
|
pSummon->DBQuery(new DB_UpdateSummon(pSummon));
|
|
|
|
StructPlayer* pPlayer = static_cast<StructPlayer*>(pSummon->GetMaster());
|
|
LOG::Log11N4S(LM_SUMMON_RESURRECTION, pPlayer->GetAccountID(), pPlayer->GetSID(), pSummon->GetSID(), 0, 0, 0, 0, 0, (nRecoveryEXP > 0), nRecoveryEXP, pSummon->GetEXP(), pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", LOG::STR_NTS, "", LOG::STR_NTS);
|
|
}
|
|
|
|
BroadcastHPMPMsg(this, nIncHP, nIncMP);
|
|
|
|
//AziaMafia KeepBuff & fix
|
|
ClearRemovedStateByDead();
|
|
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* StructCreature가 데미지를 받아 이를 반영하는 과정은 크게 4단계로 나뉜다.
|
|
*
|
|
*
|
|
* 1. 데미지 계산에 필요한 각종 정보들을 수집하는 단계
|
|
*
|
|
* 인자로 주어진 DamageMessage를 해석, 데미지를 주고 받는 StructCreature로 부터 데미지 계산에 필요한 수치들을 수집한다.
|
|
* 이 과정에 수행 순서에 의존하는 로직이 들어가면 부적절하다. 만약 필요하다면 DamageCalculator를 수정, 3번 단계에서
|
|
* 해당 로직을 수행하도록 해야 한다.
|
|
*
|
|
*
|
|
* 2. 데미지 계산에 영향을 줄 수 있는 외적 요인들을 반영하는 단계
|
|
*
|
|
* 크리티컬, 회피 시뮬레이션과 같이 순수 계산 과정에서는 예상하기 힘든, 데미지 계산에 영향을 줄 수 있는 외적 요인들을
|
|
* 반영하는 단계이다.
|
|
*
|
|
*
|
|
* 3. 실제 적용되는 데미지를 계산하는 단계
|
|
*
|
|
* 위에서 수집된 정보들과 시뮬레이션 결과를 기반으로 실제로 적용되는 데미지과 효과 적용 단계에 필요한 결과를 계산한다.
|
|
*
|
|
*
|
|
* 4. 데미지로 인한 효과를 적용하는 단계
|
|
*
|
|
* 계산의 결과 값을 실제로 StructCreature에 반영한다.
|
|
*
|
|
*
|
|
* 계산 과정을 굳이 이렇게 분리한 까닭은 아래와 같다.
|
|
*
|
|
* - 대부분의 코드가 계산 순서에 심하게 의존하고 있으며, 이로 인해 계산에 영향을 줄 수 있는 다양한 요인들이 서로 엉켜 있다.
|
|
* - 이러한 환경 하에서는 계산 과정 전반에 영향을 줄 수 있는 요인을 추가하기가 까다롭다.
|
|
* - 또한 외부 요인에 의해 계산 결과가 바뀔 수 있으므로 자동화된 테스트의 도입이 불가능에 가깝다.
|
|
*
|
|
* 이러한 이유로 순수한 계산 로직과 외적 요인들을 분리, 실제 계산에는 최소한의 복잡도만이 노출되도록 구조를 변경하였다.
|
|
*
|
|
*
|
|
* TODO:
|
|
*
|
|
* 현재는 외부에 노출되는 인터페이스를 바꾸지 않는 한도 내에서만 수정하였기에 구조적인 측면에서 일부 부적절한 면이 있다.
|
|
* 최종적으로는 데미지를 입히기를 원하는 호출부에서 DamageMessage를 직접 생성하여 이용하는 것이 적절할 것이다. (이게 바로
|
|
* 데미지 구조체에 Message라는 단어를 사용한 이유이다.)
|
|
*
|
|
* 이러면 호출부는 DamageMessage 내부에 직접 각종 연산의 (크리, 회피, 데미지 리듀스, 관통 등의 다양한 요소들) 적용 여부나
|
|
* 해당 데미지에만 적용되는 보너스 등의 고유한 정보들을 세팅하여 StructCreature에 질의를 날리고, 이러면 StructCreature는
|
|
* 이 값과 대상, 공격자의 파라메터들을 토대로 DamageCalculator를 생성하여 계산된 결과를 자신과 상대에게 반영하도록 하는
|
|
* 그림이 나올 것이다.
|
|
*
|
|
*/
|
|
|
|
StructCreature::_DAMAGE StructCreature::DealDamage( const DamageMessage& message )
|
|
{
|
|
DamageCalculator calculator( message );
|
|
|
|
CalculationResult result;
|
|
calculator.Calculate( result );
|
|
|
|
StructCreature* target = message.target;
|
|
|
|
result.finalDamage = target->onDamage( message.from, message.elementalType, message.oldDamageType, result.damage, result.simulation.critical );
|
|
target->damage( message.from, result.finalDamage );
|
|
|
|
ProcessPostDamageEffect( message, result );
|
|
|
|
return CreateDamageStruct( result );
|
|
}
|
|
|
|
|
|
// 데미지 계산에 필요한 각종 수치를 모아서 calculator에 반영하는 함수
|
|
// 계산 순서에 의존하거나 결과를 예상할 수 없는 로직은 가급적 여기에 넣지 말 것.
|
|
void StructCreature::ProvideAttackerInfo( const DamageMessage& message, DamageCalculator& calculator )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
calculator.expertiseAdvantage.amp = std::max(0.00f, (1.00f + m_Expert[target->GetCreatureGroup()].fDamage)) ;
|
|
|
|
if( message.damageType == DamageMessage::STATE_DAMAGE && message.elementalType >= 0 && message.elementalType < Elemental::TYPE_COUNT )
|
|
{
|
|
calculator.beforeDefence.amp += m_ElementalStateDamageAmplifier[message.elementalType];
|
|
calculator.beforeDefence.inc += m_ElementalStateDamageAdder[message.elementalType];
|
|
}
|
|
|
|
if( message.attackType == DamageMessage::ADDITIONAL_DAMAGE && IsUsingDoubleWeapon() )
|
|
{
|
|
if( message.damageType == DamageMessage::PHYSICAL_LEFT_HAND_ATTACK )
|
|
{
|
|
calculator.rule.amp *= ( 0.44f + m_nDoubleWeaponMasteryLevel * 0.02f );
|
|
}
|
|
else if ( message.damageType == DamageMessage::PHYSICAL_ATTACK )
|
|
{
|
|
calculator.rule.amp *= ( 0.90f + m_nDoubleWeaponMasteryLevel * 0.01f );
|
|
}
|
|
}
|
|
|
|
// 방어력/공격력/관통력 관련 정보
|
|
calculator.attackerLevel = GetLevel();
|
|
calculator.critical = GetCritical();
|
|
calculator.critPower = GetCriticalPower();
|
|
|
|
if( message.attackType == DamageMessage::MAGICAL_ATTACK )
|
|
{
|
|
calculator.attackPoint = GetMagicPoint();
|
|
calculator.penetration = m_Attribute.fMagicalPenetration;
|
|
calculator.penetrationRatio = m_Attribute.fMagicalPenetrationRatio * 0.01f;
|
|
calculator.defenceIgnore = m_Attribute.fMagicalDefIgnore;
|
|
calculator.defenceIgnoreRatio = m_Attribute.fPhysicalDefIgnoreRatio * 0.01f;
|
|
calculator.accuracy = GetMagicAccuracy();
|
|
}
|
|
else
|
|
{
|
|
calculator.attackPoint = GetAttackPointRight();
|
|
calculator.penetration = m_Attribute.fPhysicalPenetration;
|
|
calculator.penetrationRatio = m_Attribute.fPhysicalPenetrationRatio * 0.01f;
|
|
calculator.defenceIgnore = m_Attribute.fPhysicalDefIgnore;
|
|
calculator.defenceIgnoreRatio = m_Attribute.fPhysicalDefIgnoreRatio * 0.01f;
|
|
|
|
if( message.attackType == DamageMessage::PHYSICAL_LEFT_HAND_ATTACK )
|
|
{
|
|
calculator.accuracy = GetAccuracyLeft();
|
|
}
|
|
else
|
|
{
|
|
calculator.accuracy = GetAccuracyRight();
|
|
}
|
|
}
|
|
|
|
if ( IsSkillProp() )
|
|
{
|
|
calculator.flag &= ~DamageMessage::BLOCK;
|
|
calculator.damageType = DamageMessage::NAKED_DAMAGE;
|
|
}
|
|
else
|
|
{
|
|
calculator.damageType = message.damageType;
|
|
}
|
|
|
|
for ( std::vector< StructSkill* >::iterator it = message.from->m_vSkillRelatedToDamaging.begin();
|
|
it != message.from->m_vSkillRelatedToDamaging.end(); ++it )
|
|
{
|
|
ApplySkillToCalculation( message, calculator, *it );
|
|
}
|
|
}
|
|
|
|
void StructCreature::ProvideTargetInfo( const DamageMessage& message, DamageCalculator& calculator )
|
|
{
|
|
StructCreature* from = message.from;
|
|
|
|
calculator.expertisePenalty.amp = std::max(0.00f, (1.00f - m_Expert[from->GetCreatureGroup()].fAvoid) );
|
|
|
|
// TODO: 아래 수식을 실행하면 calculator.resist.amp는 무조건 1.0f로 나옴.
|
|
// 당장은 동작을 그대로 옮기나, 버그일 가능성이 크니 차후 수정
|
|
calculator.resist.amp -= GetElementalResist( message.elementalType ) / 300;
|
|
|
|
calculator.targetLevel = GetLevel();
|
|
calculator.manaShieldLimit = GetMP();
|
|
|
|
if( message.attackType == DamageMessage::MAGICAL_ATTACK )
|
|
{
|
|
calculator.defence = GetMagicDefence();
|
|
calculator.avoid = GetMagicAvoid();
|
|
calculator.isImmune = IsMagicalImmune();
|
|
calculator.manaShieldRatio = m_fMagicalDamageManaShieldAbsorbRatio;
|
|
}
|
|
else
|
|
{
|
|
calculator.defence = GetDefence();
|
|
calculator.blockDefence = calculator.defence + GetBlockDefence();
|
|
calculator.avoid = GetAvoid();
|
|
calculator.blockRate = GetBlockChance();
|
|
calculator.perfectBlockRate = m_Attribute.fPerfectBlock;
|
|
calculator.isImmune = IsPhysicalImmune();
|
|
calculator.manaShieldRatio = m_fPhysicalDamageManaShieldAbsorbRatio;
|
|
}
|
|
|
|
if ( !IsWearShield() && !IsSummon() )
|
|
{
|
|
calculator.flag &= ~DamageMessage::BLOCK;
|
|
}
|
|
|
|
if( ( IsPlayer() || IsSummon() ) && this != from )
|
|
{
|
|
if( from->IsPlayer() )
|
|
{
|
|
calculator.rule.amp *= GameRule::fPVPDamageRateForPlayer;
|
|
}
|
|
else if( from->IsSummon() )
|
|
{
|
|
calculator.rule.amp *= GameRule::fPVPDamageRateForSummon;
|
|
}
|
|
else if( from->IsMonster() )
|
|
{
|
|
StructMonster * pMonster = static_cast< StructMonster * >( from );
|
|
|
|
if( pMonster->GetMonsterType() >= MonsterBase::MONSTER_TYPE_HIGHEST_1_STAR )
|
|
{
|
|
if( this->IsPlayer() ) calculator.rule.amp *= GameRule::fEVPDamageRate;
|
|
if( this->IsSummon() ) calculator.rule.amp *= GameRule::fEVSDamageRate;
|
|
}
|
|
else
|
|
{
|
|
if( this->IsPlayer() ) calculator.rule.amp *= GameRule::fEVPBossDamageRate;
|
|
if( this->IsSummon() ) calculator.rule.amp *= GameRule::fEVSBossDamageRate;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( message.flag & DamageMessage::DAMAGE_REDUCE )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
calculator.statePenalty.inc -= CalculateDamageReduceSum( message, m_vDamageReduceValueInfo );
|
|
calculator.statePenalty.amp -= CalculateDamageReduceSum( message, m_vDamageReducePercentInfo );
|
|
}
|
|
|
|
// 플레이어 전용
|
|
// 앉은 상태에서 피격 시 모든 공격이 크리티컬로 터진다.
|
|
if( IsPlayer() )
|
|
{
|
|
StructPlayer *pPlayer = static_cast< StructPlayer * >( this );
|
|
|
|
if( pPlayer->GetBattleArenaID() )
|
|
calculator.isIgnoreLevelPenalty = true;
|
|
if( pPlayer->IsSitDown() )
|
|
calculator.critRateInc = 100;
|
|
}
|
|
}
|
|
|
|
const float StructCreature::CalculateDamageReduceSum( const DamageMessage& message, const std::vector< DamageReduceInfo >& reduceInfo )
|
|
{
|
|
std::vector< DamageReduceInfo >::const_iterator dit;
|
|
const int targetGroup = message.from->GetCreatureGroup();
|
|
float sum = 0.0f;
|
|
|
|
for( dit = reduceInfo.begin() ; dit != reduceInfo.end() ; ++dit )
|
|
{
|
|
if( dit->IsAppliableCreatureGroup( targetGroup ) && dit->ratio > XRandom() % 100 )
|
|
{
|
|
switch ( message.attackType )
|
|
{
|
|
case DamageMessage::MAGICAL_ATTACK:
|
|
sum += dit->magical_skill_reduce;
|
|
break;
|
|
case DamageMessage::PHYSICAL_ATTACK:
|
|
case DamageMessage::PHYSICAL_LEFT_HAND_ATTACK:
|
|
sum += dit->physical_reduce;
|
|
break;
|
|
case DamageMessage::PHYSICAL_SKILL_ATTACK:
|
|
sum += dit->physical_skill_reduce;
|
|
break;
|
|
default:
|
|
assert( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
return sum;
|
|
}
|
|
|
|
|
|
|
|
void StructCreature::ApplySkillToCalculation( const DamageMessage& message, DamageCalculator& calculator, StructSkill* skill )
|
|
{
|
|
StructCreature* target = message.target;
|
|
StructCreature* from = message.from;
|
|
|
|
int effectType = skill->GetSkillBase()->GetEffectType();
|
|
switch ( effectType )
|
|
{
|
|
case SkillBase::EF_INC_DAMAGE_BY_TARGET_STATE:
|
|
case SkillBase::EF_AMP_DAMAGE_BY_TARGET_STATE:
|
|
{
|
|
bool isAndOp = ( skill->GetVar( 12 ) == 1 );
|
|
bool apply = isAndOp;
|
|
|
|
for ( int i = 0; i < 12; i++ )
|
|
{
|
|
StructState::StateCode id = (StructState::StateCode)(int)skill->GetVar( i );
|
|
|
|
if( id == 0 )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( target->GetState( id ) != NULL )
|
|
{
|
|
if( isAndOp == false )
|
|
{
|
|
apply = true;
|
|
break;
|
|
}
|
|
}
|
|
else if( isAndOp == true )
|
|
{
|
|
apply = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( apply == true )
|
|
{
|
|
c_fixed10 damage;
|
|
|
|
if( message.damageType == DamageMessage::DIRECT_DAMAGE )
|
|
{
|
|
switch( message.attackType )
|
|
{
|
|
case DamageMessage::PHYSICAL_ATTACK:
|
|
case DamageMessage::PHYSICAL_LEFT_HAND_ATTACK:
|
|
damage = skill->GetVar( 14 ) + skill->GetVar( 15 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
case DamageMessage::PHYSICAL_SKILL_ATTACK:
|
|
damage = skill->GetVar( 16 ) + skill->GetVar( 17 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
case DamageMessage::MAGICAL_ATTACK:
|
|
damage = skill->GetVar( 18 ) + skill->GetVar( 19 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( effectType == SkillBase::EF_INC_DAMAGE_BY_TARGET_STATE )
|
|
{
|
|
calculator.afterDefence.inc += damage;
|
|
}
|
|
else
|
|
{
|
|
calculator.afterDefence.amp += damage;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case SkillBase::EF_INC_DAMAGE_INC_CRIT_RATE_BY_TARGET_HP_RATIO:
|
|
case SkillBase::EF_AMP_DAMAGE_INC_CRIT_RATE_BY_TARGET_HP_RATIO:
|
|
{
|
|
c_fixed10 condition = skill->GetVar( 0 ) + skill->GetVar( 1 ) * skill->GetCurrentSkillLevel();
|
|
c_fixed10 HPPercentage = ( static_cast< c_fixed10 > ( target->GetHP() ) * 100 ) / target->GetMaxHP();
|
|
|
|
if( HPPercentage <= condition )
|
|
{
|
|
bool targetIsInProperGroup = false;
|
|
|
|
for ( int i = 11; i < 16; i++ )
|
|
{
|
|
int requiredGroup = skill->GetVar( i );
|
|
|
|
if( requiredGroup == CREATURE_ALL || requiredGroup == target->GetCreatureGroup() )
|
|
{
|
|
targetIsInProperGroup = true;
|
|
break;
|
|
}
|
|
else if( requiredGroup == CREATURE_NONE )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( targetIsInProperGroup == true && XRandom( 0, 99 ) < skill->GetVar( 10 ) )
|
|
{
|
|
c_fixed10 damage;
|
|
|
|
if( message.damageType == DamageMessage::DIRECT_DAMAGE )
|
|
{
|
|
switch( message.attackType )
|
|
{
|
|
case DamageMessage::PHYSICAL_ATTACK:
|
|
case DamageMessage::PHYSICAL_LEFT_HAND_ATTACK:
|
|
damage = skill->GetVar( 2 ) + skill->GetVar( 3 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
case DamageMessage::PHYSICAL_SKILL_ATTACK:
|
|
damage = skill->GetVar( 4 ) + skill->GetVar( 5 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
case DamageMessage::MAGICAL_ATTACK:
|
|
damage = skill->GetVar( 6 ) + skill->GetVar( 7 ) * skill->GetCurrentSkillLevel();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( effectType == SkillBase::EF_INC_DAMAGE_INC_CRIT_RATE_BY_TARGET_HP_RATIO )
|
|
{
|
|
calculator.afterDefence.inc += damage;
|
|
}
|
|
else
|
|
{
|
|
calculator.afterDefence.amp += damage;
|
|
}
|
|
|
|
calculator.critRateInc += skill->GetVar( 8 ) + skill->GetVar( 9 ) * skill->GetCurrentSkillLevel();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
// 엉뚱한/미구현 스킬이 m_vSkillRelatedToDamaging에 등록된 상황이다!
|
|
assert( false );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void StructCreature::ProcessPostDamageEffect( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
ApplyManaShieldEffect( message, result );
|
|
//InterruptSpellCast( message, result );
|
|
|
|
|
|
/* AziaMafia Delete Pierre ame durabilité
|
|
if( !result.simulation.missed )
|
|
{
|
|
RemoveStateOnDamage( message, result );
|
|
//ConsumeSoulStoneDurabilityOnDamage( message, result ); // AziaMafia No Endurence
|
|
|
|
if( XRandom( 1, 100 ) <= GameRule::nEtherealDurabilityConsumptionRate * 100 )
|
|
ConsumeEtherealDurabilityOnDamage( message, result );
|
|
}
|
|
*/
|
|
RemoveStateOnDamage(message, result);
|
|
|
|
|
|
ReflectDamage( message, result );
|
|
}
|
|
|
|
void StructCreature::ApplyManaShieldEffect( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
if ( result.manaShieldAbsorption > 0 )
|
|
{
|
|
target->AddMP( -result.manaShieldAbsorption );
|
|
|
|
BroadcastHPMPMsg( message.target, 0, result.manaShieldAbsorption );
|
|
}
|
|
}
|
|
|
|
void StructCreature::InterruptSpellCast( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
// 캐스팅 캔슬 처리
|
|
if( target->IsUsingSkill() )
|
|
{
|
|
target->m_pCastSkill->onDamage( result.damage );
|
|
}
|
|
}
|
|
|
|
void StructCreature::RemoveStateOnDamage( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
target->RemoveStatesOnDamaged();
|
|
|
|
target->RemoveState( StructState::SLEEP, GameRule::MAX_STATE_LEVEL );
|
|
target->RemoveState( StructState::NIGHTMARE, GameRule::MAX_STATE_LEVEL );
|
|
target->RemoveState( StructState::ANOMALY_SLEEP, GameRule::MAX_STATE_LEVEL );
|
|
target->RemoveState( StructState::MONSTER_SLEEP, GameRule::MAX_STATE_LEVEL );
|
|
|
|
//AziaMafia FOZEN STATE
|
|
target->RemoveState( StructState::FROZEN, GameRule::MAX_STATE_LEVEL);
|
|
target->RemoveState( StructState::TOTAL_FROZEN, GameRule::MAX_STATE_LEVEL);
|
|
|
|
// 맞으면 샤인월 해제된다
|
|
if( message.attackType != DamageMessage::MAGICAL_ATTACK )
|
|
target->RemoveState( StructState::SHINE_WALL, GameRule::MAX_STATE_LEVEL );
|
|
|
|
// 맞으면 일정 확률로 빙결 해제
|
|
const StructState::StateCode nFrozen[] = { StructState::FROZEN, StructState::TOTAL_FROZEN };
|
|
for( int i = 0; i < 2; ++i )
|
|
{
|
|
StructState * pFrozen = target->GetState( nFrozen[i] );
|
|
if( pFrozen )
|
|
{
|
|
int nRatio = ( pFrozen->GetValue(4) + pFrozen->GetLevel() * pFrozen->GetValue(5) ) * 100.0f;
|
|
|
|
if( XRandom() % 100 < nRatio )
|
|
target->RemoveState( nFrozen[i], GameRule::MAX_STATE_LEVEL );
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::ConsumeSoulStoneDurabilityOnDamage( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* target = message.target;
|
|
|
|
// 소울스톤 내구도 감소
|
|
for( int pos = 0 ; pos < 5 ; ++pos )
|
|
{
|
|
static const ItemBase::ItemWearType WeaponIndices[ 5 ] = { ItemBase::WEAR_ARMOR, ItemBase::WEAR_HELM, ItemBase::WEAR_GLOVE, ItemBase::WEAR_BOOTS, ItemBase::WEAR_MANTLE };
|
|
|
|
ItemBase::ItemWearType idx = WeaponIndices[ pos ];
|
|
|
|
StructItem *pItem = target->m_anWear[ idx ];
|
|
if( pItem && pItem->GetCurrentEndurance() > 0 && pItem->GetUsingSocketCount() > 0 )
|
|
{
|
|
int nPrevEndurance = pItem->GetCurrentEndurance();
|
|
pItem->SetCurrentEndurance( pItem->GetCurrentEndurance() - GameRule::ENDURANCE_REDUCE_ON_DAMAGE );
|
|
if( target->IsPlayer() && GameRule::GetDecreasedEndurancePoint( nPrevEndurance, pItem->GetCurrentEndurance() ) > 0 )
|
|
SendItemMessage( static_cast< StructPlayer * >( target ), pItem );
|
|
|
|
if( pItem->GetCurrentEndurance() == 0 )
|
|
target->SetNeedCalculateStat();
|
|
}
|
|
}
|
|
}
|
|
|
|
void StructCreature::ConsumeEtherealDurabilityOnDamage( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* from = message.from;
|
|
StructCreature* target = message.target;
|
|
|
|
// 에테리얼 내구도 감소(평타, 평타-왼손, 물리스킬, 마법스킬, 물리지속, 마법지속 데미지일 때만 적용)
|
|
if( message.damageType != DamageMessage::ADDITIONAL_DAMAGE )
|
|
{
|
|
// 공격자가 자신이 아니고 반사막에 의한 공격이 아닐 경우 에테리얼 내구도 소모 적용
|
|
if( from != target && !from->IsProcessingReflectDamage() )
|
|
{
|
|
// 공격자의 에테리얼 내구도 소모는 공격자가 준 데미지 기준으로 적용
|
|
from->ProcEtherealDurabilityConsumption( true, message.oldDamageType, message.damage );
|
|
}
|
|
|
|
// 피격자의 에테리얼 내구도 소모는 피격자가 받은 데미지 기준으로 적용
|
|
target->ProcEtherealDurabilityConsumption( false, message.oldDamageType, result.damage );
|
|
}
|
|
}
|
|
|
|
void StructCreature::ReflectDamage( const DamageMessage& message, const CalculationResult& result )
|
|
{
|
|
StructCreature* from = message.from;
|
|
StructCreature* target = message.target;
|
|
|
|
const std::vector< StructCreature::DamageReflectInfo > reflectInfo = target->m_vDamageReflectInfo;
|
|
|
|
// 두 케릭이 서로 반사막 켜고 피케하면 연속 반사 되는 걸 방지하기 위해 IsProcessingReflectDamage() 사용
|
|
// 이 부분은 상대방을 죽일 수도 있으므로 상대방에게 적용시키는 모든 동작의 맨 마지막이 되어야 함
|
|
// Ex. 지속효과 부여 -> 반사 데미지 처리시 사망 : 부여된 지속효과 자동 제거 (O)
|
|
// 반사 데미지 처리시 사망 -> 지속효과 부여 : 사망 후 지속효과가 부여됨 (X)
|
|
if( !target->IsProcessingReflectDamage() && !from->IsProcessingReflectDamage() && !reflectInfo.empty() )
|
|
{
|
|
target->m_StatusFlag.On( STATUS_PROCESSING_REFELCT );
|
|
|
|
for( std::vector< DamageReflectInfo >::const_iterator it = reflectInfo.begin(); it != reflectInfo.end(); ++it )
|
|
{
|
|
if( XRandom( 0, 100 ) < it->fire_ratio &&
|
|
from->GetCurrentPosition( GetArTime() ).GetDistance( target->GetCurrentPosition( GetArTime() ) ) <=
|
|
it->range * GameRule::DEFAULT_UNIT_SIZE )
|
|
{
|
|
int nPrevHP = from->GetHP();
|
|
int nPrevMP = from->GetMP();
|
|
int nDamageFlag = IGNORE_AVOID | IGNORE_BLOCK | IGNORE_CRITICAL;
|
|
|
|
if( it->bIgnoreDefence )
|
|
nDamageFlag |= IGNORE_DEFENCE;
|
|
|
|
// 직접적으로 받은 데미지 유형일 경우만 반사막 일반 데미지 작동(일반 물리 공격, 왼손 물리 공격, 마법 공격)
|
|
if( message.damageType == DamageMessage::DIRECT_DAMAGE )
|
|
{
|
|
if ( it->nReflectDamage )
|
|
{
|
|
from->DealAdditionalMagicalDamage( target, it->nReflectDamage, it->type, 0, 0, nDamageFlag );
|
|
}
|
|
|
|
int nReflectDamage = 0;
|
|
|
|
switch( message.attackType )
|
|
{
|
|
case DamageMessage::PHYSICAL_ATTACK:
|
|
case DamageMessage::PHYSICAL_LEFT_HAND_ATTACK:
|
|
// 물리 데미지 비율 반사는 물리 데미지일 경우만 작동(반사도 물리 데미지임)
|
|
nReflectDamage = it->fPhysicalReflectRatio * result.finalDamage;
|
|
if ( nReflectDamage )
|
|
{
|
|
from->DealPhysicalDamage( target, nReflectDamage, it->type, 0, 0, nDamageFlag );
|
|
}
|
|
break;
|
|
case DamageMessage::PHYSICAL_SKILL_ATTACK:
|
|
// 물리 스킬 데미지 비율 반사는 물리 스킬 데미지일 경우만 작동(반사도 물리 스킬 데미지)
|
|
nReflectDamage = it->fPhysicalSkillReflectRatio * result.finalDamage;
|
|
if ( nReflectDamage )
|
|
{
|
|
from->DealPhysicalSkillDamage( target, nReflectDamage, it->type, 0, 0, nDamageFlag );
|
|
}
|
|
break;
|
|
case DamageMessage::MAGICAL_ATTACK:
|
|
// 마법 스킬 데미지 비율 반사는 마법 스킬 데미지일 경우만 작동(반사도 마법 스킬 데미지)
|
|
nReflectDamage = it->fMagicalReflectRatio * result.finalDamage;
|
|
if ( nReflectDamage )
|
|
{
|
|
from->DealMagicalSkillDamage( target, nReflectDamage, it->type, 0, 0, nDamageFlag );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 반사막에 의한 데미지 표시를 위해 방송 후 한 번 더 보냄
|
|
BroadcastHPMPMsg( from, from->GetHP() - nPrevHP, from->GetMP() - nPrevMP );
|
|
|
|
if( target->IsPlayer() )
|
|
{
|
|
SendHPMPMsg( static_cast< StructPlayer * >( target ), from, from->GetHP() - nPrevHP, from->GetMP() - nPrevMP, true );
|
|
}
|
|
else if( target->IsSummon() && static_cast< StructSummon * >( target )->GetMaster() )
|
|
{
|
|
SendHPMPMsg( static_cast< StructSummon * >( target )->GetMaster(), from, from->GetHP() - nPrevHP, from->GetMP() - nPrevMP, true );
|
|
}
|
|
|
|
if( from->IsPlayer() )
|
|
{
|
|
SendHPMPMsg( static_cast< StructPlayer * >( from ), from, from->GetHP() - nPrevHP, from->GetMP() - nPrevMP, true );
|
|
}
|
|
else if( from->IsSummon() && static_cast< StructSummon * >( from )->GetMaster() )
|
|
{
|
|
SendHPMPMsg( static_cast< StructSummon * >( from )->GetMaster(), from, from->GetHP() - nPrevHP, from->GetMP() - nPrevMP, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
target->m_StatusFlag.Off( STATUS_PROCESSING_REFELCT );
|
|
}
|
|
}
|
|
|
|
|
|
StructCreature::_DAMAGE StructCreature::CreateDamageStruct( const CalculationResult& result )
|
|
{
|
|
_DAMAGE damage;
|
|
|
|
damage.nDamage = result.finalDamage;
|
|
damage.nResistedDamage = result.resistedDamage;
|
|
damage.bBlock = result.simulation.blocked;
|
|
damage.bCritical = result.simulation.critical;
|
|
damage.bMiss = result.simulation.missed;
|
|
damage.bPerfectBlock = result.simulation.perfectBlocked;
|
|
|
|
return damage;
|
|
}
|
|
|
|
|
|
|
|
|
|
StructCreature::_DAMAGE_INFO StructCreature::DealMagicalSkillDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag )
|
|
{
|
|
_DAMAGE_INFO damage_info;
|
|
DamageMessage message( pFrom, this, DT_NORMAL_MAGICAL_DAMAGE, nFlag, elemental_type, nDamage );
|
|
|
|
message.penalty = &m_MagicalSkillStatePenalty;
|
|
message.flag |= DamageMessage::DAMAGE_REDUCE;
|
|
message.criticalBonus = critical_bonus + pFrom->m_BadMagicalElementalSkillStateMod[elemental_type].nCritical;
|
|
|
|
//AziaMafia WTF damage ????
|
|
//message.accuracyBonus = accuracy_bonus + pFrom->m_BadMagicalElementalSkillStateMod[elemental_type].nPhysicalAccuracy;
|
|
message.accuracyBonus = accuracy_bonus + pFrom->m_BadMagicalElementalSkillStateMod[elemental_type].nMagicalAccuracy;
|
|
|
|
damage_info.SetDamage( DealDamage( message ) );
|
|
|
|
ProcessAdditionalDamage( message, DT_ADDITIONAL_MAGICAL_DAMAGE, pFrom->m_vMagicalSkillAdditionalDamage, damage_info );
|
|
|
|
damage_info.target_hp = GetHP();
|
|
|
|
return damage_info;
|
|
}
|
|
|
|
StructCreature::_DAMAGE_INFO StructCreature::DealPhysicalNormalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag )
|
|
{
|
|
_DAMAGE_INFO damage_info;
|
|
DamageMessage message( pFrom, this, DT_NORMAL_PHYSICAL_DAMAGE, nFlag, elemental_type, nDamage );
|
|
|
|
bool bRange = ( pFrom->IsUsingBow() || pFrom->IsUsingCrossBow() ) && pFrom->IsPlayer();
|
|
|
|
message.advantage = bRange ? &pFrom->m_RangeStateAdvantage : &pFrom->m_NormalStateAdvantage;
|
|
message.penalty = bRange ? &m_RangeStatePenalty : &m_NormalStatePenalty;
|
|
message.flag |= DamageMessage::DAMAGE_REDUCE;
|
|
message.criticalBonus = critical_bonus;
|
|
message.accuracyBonus = accuracy_bonus;
|
|
|
|
damage_info.SetDamage( DealDamage( message ) );
|
|
|
|
ProcessAdditionalDamage( message, DT_ADDITIONAL_DAMAGE,
|
|
bRange ? pFrom->m_vRangeAdditionalDamage : pFrom->m_vNormalAdditionalDamage, damage_info );
|
|
|
|
damage_info.target_hp = GetHP();
|
|
|
|
return damage_info;
|
|
}
|
|
|
|
StructCreature::_DAMAGE_INFO StructCreature::DealPhysicalNormalLeftHandDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag )
|
|
{
|
|
_DAMAGE_INFO damage_info;
|
|
DamageMessage message( pFrom, this, DT_NORMAL_PHYSICAL_LEFT_HAND_DAMAGE, nFlag, elemental_type, nDamage );
|
|
|
|
message.advantage = &pFrom->m_NormalStateAdvantage;
|
|
message.penalty = &m_NormalStatePenalty;
|
|
message.flag |= DamageMessage::DAMAGE_REDUCE;
|
|
message.criticalBonus = critical_bonus;
|
|
message.accuracyBonus = accuracy_bonus;
|
|
|
|
damage_info.SetDamage( DealDamage( message ) );
|
|
|
|
ProcessAdditionalDamage( message, DT_ADDITIONAL_LEFT_HAND_DAMAGE, pFrom->m_vNormalAdditionalDamage, damage_info );
|
|
|
|
damage_info.target_hp = GetHP();
|
|
|
|
return damage_info;
|
|
}
|
|
|
|
StructCreature::_DAMAGE_INFO StructCreature::DealPhysicalSkillDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag )
|
|
{
|
|
_DAMAGE_INFO damage_info;
|
|
DamageMessage message( pFrom, this, DT_NORMAL_PHYSICAL_SKILL_DAMAGE, nFlag, elemental_type, nDamage );
|
|
|
|
message.penalty = &m_PhysicalSkillStatePenalty;
|
|
message.flag |= DamageMessage::DAMAGE_REDUCE;
|
|
message.criticalBonus = critical_bonus + pFrom->m_BadPhysicalElementalSkillStateMod[elemental_type].nCritical;
|
|
message.accuracyBonus = accuracy_bonus + pFrom->m_BadPhysicalElementalSkillStateMod[elemental_type].nPhysicalAccuracy;
|
|
|
|
damage_info.SetDamage( DealDamage( message ) );
|
|
|
|
ProcessAdditionalDamage( message, DT_ADDITIONAL_DAMAGE, pFrom->m_vPhysicalSkillAdditionalDamage, damage_info );
|
|
|
|
damage_info.target_hp = GetHP();
|
|
|
|
return damage_info;
|
|
}
|
|
|
|
|
|
void StructCreature::ProcessAdditionalDamage( const DamageMessage& sourceMessage, const DamageType additionalDamageType, const std::vector< AdditionalDamageInfo >& additionalDamage, _DAMAGE_INFO& damageInfo )
|
|
{
|
|
if( !damageInfo.bMiss && !damageInfo.bPerfectBlock )
|
|
{
|
|
StructCreature* target = sourceMessage.target;
|
|
|
|
// 추가 데미지 처리
|
|
std::vector< AdditionalDamageInfo >::const_iterator it;
|
|
for( it = additionalDamage.begin(); it != additionalDamage.end(); ++it )
|
|
{
|
|
if( ( it->require_type == 99 || it->require_type == sourceMessage.elementalType ) && it->ratio > XRandom() % 100 )
|
|
{
|
|
int damage = 0;
|
|
|
|
if( it->nDamage )
|
|
{
|
|
damage = it->nDamage;
|
|
}
|
|
else
|
|
{
|
|
damage = it->fDamage * damageInfo.nDamage;
|
|
}
|
|
|
|
DamageMessage message( sourceMessage.from, sourceMessage.target, additionalDamageType, 0, it->type, damage );
|
|
|
|
damage = target->DealDamage( message ).nDamage;
|
|
if ( it->type >= 0 && it->type < Elemental::TYPE_COUNT )
|
|
{
|
|
damageInfo.elemental_damage[ it->type ] += damage;
|
|
}
|
|
damageInfo.nDamage += damage;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
StructCreature::_DAMAGE StructCreature::DealDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, DamageType damageType, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
_DAMAGE_INFO damage_info;
|
|
DamageMessage message( pFrom, this, damageType, nFlag, elemental_type, nDamage );
|
|
|
|
message.advantage = damage_advantage;
|
|
message.penalty = damage_penalty;
|
|
message.criticalBonus = critical_bonus;
|
|
message.accuracyBonus = accuracy_bonus;
|
|
|
|
return DealDamage( message );
|
|
}
|
|
|
|
|
|
// 이하 함수들은 인터페이스 차원의 호환을 위해 남겨두었으나, 이런 류의 복붙 래퍼 함수가 굳이 필요한지는 의문이다.
|
|
// TODO : 추후 리팩토링을 통해 인터페이스를 적절하게 정리하도록 하자.
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealMagicalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_NORMAL_MAGICAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealPhysicalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_NORMAL_PHYSICAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealStateMagicalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_STATE_MAGICAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealPhysicalStateDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_STATE_PHYSICAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealPhysicalLeftHandDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_NORMAL_PHYSICAL_LEFT_HAND_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealAdditionalMagicalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_ADDITIONAL_MAGICAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealAdditionalDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_ADDITIONAL_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|
|
// 데미지를 리턴함
|
|
StructCreature::_DAMAGE StructCreature::DealAdditionalLeftHandDamage( StructCreature *pFrom, int nDamage, Elemental::Type elemental_type, int accuracy_bonus, int critical_bonus, int nFlag, const StateMod * damage_penalty, const StateMod * damage_advantage )
|
|
{
|
|
return DealDamage( pFrom, nDamage, elemental_type, DT_ADDITIONAL_LEFT_HAND_DAMAGE, accuracy_bonus, critical_bonus, nFlag, damage_penalty, damage_advantage );
|
|
}
|
|
|