3365 lines
No EOL
125 KiB
C++
3365 lines
No EOL
125 KiB
C++
#include "StdAfx.h"
|
||
#include "DnPlayerState.h"
|
||
#include "DnTableDB.h"
|
||
#include "MAPartsBody.h"
|
||
#include "DnActor.h"
|
||
#include "DnPlayerActor.h"
|
||
#include "DnGameTask.h"
|
||
#include "DnPvPGameTask.h"
|
||
#include "TaskManager.h"
|
||
#include "DnDLGameTask.h"
|
||
#include "DnItem.h"
|
||
#if defined(_GAMESERVER)
|
||
#include "DNGameDataManager.h"
|
||
#include "DNGameRoom.h"
|
||
#include "DNPvPGameRoom.h"
|
||
#include "DNUserSession.h"
|
||
#include "DNBestFriend.h"
|
||
#else //_GAMESERVER
|
||
#include "DnPetTask.h"
|
||
#include "DnItemTask.h"
|
||
#endif // _GAMESERVER
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
CDnPlayerState::CDnPlayerState()
|
||
{
|
||
m_pSetItemState = NULL;
|
||
m_pAppellationState = NULL;
|
||
m_pPetAbilityState = NULL;
|
||
#if defined(PRE_ADD_SKILLBUF_RENEW)
|
||
m_BuffState.ResetState();
|
||
#endif
|
||
|
||
m_nExperience = 0;
|
||
m_nNextLevelExperience = 0;
|
||
m_nCurrentLevelExperience = 0;
|
||
|
||
m_fDeadDurabilityRatio = 0.f;
|
||
m_nAppellationIndex = -1;
|
||
m_nCoverAppellationIndex = -1;
|
||
|
||
m_cAccountLevel = 0;
|
||
m_cPvPLevel = 0;
|
||
|
||
#ifdef PRE_ADD_STAGE_LIMIT_INTERFACE
|
||
memset(&m_sDamageLimitInfo,0,sizeof(m_sDamageLimitInfo));
|
||
#endif
|
||
|
||
}
|
||
|
||
CDnPlayerState::~CDnPlayerState()
|
||
{
|
||
SAFE_DELETE( m_pSetItemState );
|
||
SAFE_DELETE( m_pAppellationState );
|
||
SAFE_DELETE( m_pPetAbilityState );
|
||
for( int i=0; i<(int)m_vecpPetAccessaryState.size(); i++ )
|
||
{
|
||
if( m_vecpPetAccessaryState[i] )
|
||
SAFE_DELETE( m_vecpPetAccessaryState[i] );
|
||
}
|
||
m_vecpPetAccessaryState.clear();
|
||
}
|
||
|
||
void CDnPlayerState::CalcBaseState( StateTypeEnum Type )
|
||
{
|
||
if( m_nLevel == 0 ) return;
|
||
|
||
m_BaseState.SetSuperAmmor( CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::SuperAmmor ) );
|
||
m_fDeadDurabilityRatio = CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::DeadDurabilityRatio ) / 100.f;
|
||
|
||
m_BaseState.CalcValueType();
|
||
}
|
||
|
||
void CDnPlayerState::CalcState( RefreshStateExtentEnum Extent, StateTypeEnum Type )
|
||
{
|
||
if( m_nLevel == 0 ) return;
|
||
|
||
std::vector<CDnState *> pVecAbsoluteList[2];
|
||
std::vector<CDnState *> pVecRatioList[2];
|
||
|
||
#if defined(PRE_ADD_TALISMAN_SYSTEM)
|
||
GetStateList( BaseList | WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeAbsolute, pVecAbsoluteList[0] );
|
||
GetStateList( BaseList | WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeRatio, pVecRatioList[0] );
|
||
#else
|
||
GetStateList( BaseList | WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeAbsolute, pVecAbsoluteList[0] );
|
||
GetStateList( BaseList | WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeRatio, pVecRatioList[0] );
|
||
#endif // PRE_ADD_TALISMAN_SYSTEM
|
||
GetStateList( PostStateEffectList, ValueTypeRatio, pVecRatioList[1] );
|
||
GetStateList( PostStateEffectList, ValueTypeAbsolute, pVecAbsoluteList[1] );
|
||
|
||
if( Type & ST_Strength ) CalcStrength( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Agility ) CalcAgility( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Intelligence ) CalcIntelligence( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Stamina ) CalcStamina( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_AttackP ) CalcAttackP( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_AttackM ) CalcAttackM( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_DefenseP ) CalcDefenseP( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_DefenseM ) CalcDefenseM( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_HP ) CalcHP( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_SP ) CalcSP( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_MoveSpeed ) CalcMoveSpeed( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_DownDelay ) CalcDownDelay( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Stiff ) CalcStiff( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_StiffResistance ) CalcStiffResistance( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Critical ) CalcCritical( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_CriticalResistance ) CalcCriticalResistance( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Stun ) CalcStun( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_StunResistance ) CalcStunResistance( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_RecoverySP ) CalcRecoverySP( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_SuperAmmor ) CalcSuperAmmor( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_FinalDamage ) CalcFinalDamage( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_Spirit ) CalcSpirit( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_SafeZoneMoveSpeed ) CalcSafeZoneMoveSpeed( Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_AddExp ) CalcAddExp( Extent, pVecAbsoluteList, pVecRatioList );
|
||
|
||
for( int i=0; i<ElementEnum_Amount; i++ ) {
|
||
if( Type & ST_ElementAttack ) CalcElementAttack( (ElementEnum)i, Extent, pVecAbsoluteList, pVecRatioList );
|
||
if( Type & ST_ElementDefense ) CalcElementDefense( (ElementEnum)i, Extent, pVecAbsoluteList, pVecRatioList );
|
||
}
|
||
|
||
if( Extent & RefreshBase ) m_BaseState.CalcValueType();
|
||
if( Extent & RefreshEquip ) m_StateStep[0].CalcValueType();
|
||
if( Extent & RefreshSkill ) m_StateStep[1].CalcValueType();
|
||
|
||
CalcValueType();
|
||
#if defined(PRE_ADD_MISSION_COUPON)
|
||
if( m_nHP > m_nMaxHP ) SetHP(m_nMaxHP);
|
||
if( m_nSP > m_nMaxSP ) SetSP(m_nMaxSP);
|
||
#else
|
||
if( m_nHP > m_nMaxHP ) m_nHP = m_nMaxHP;
|
||
if( m_nSP > m_nMaxSP ) m_nSP = m_nMaxSP;
|
||
#endif
|
||
|
||
OnCalcPlayerState();
|
||
}
|
||
|
||
#if defined (PRE_ADD_BESTFRIEND)
|
||
bool CDnPlayerState::IsApplyPartsState(CDnActor *pActor, CDnParts* pParts, bool Durability)
|
||
{
|
||
if( Durability && !pParts->IsInfinityDurability() && pParts->GetDurability() <= 0 )
|
||
return false;
|
||
|
||
int nParam1=0, nParam2 = 0;
|
||
#if defined (_GAMESERVER)
|
||
int* nTypePram = pParts->GetTypeParam();
|
||
nParam1 = nTypePram[0];
|
||
nParam2 = nTypePram[1];
|
||
#elif defined (_CLIENT)
|
||
nParam1 = pParts->GetTypeParam(0);
|
||
nParam2 = pParts->GetTypeParam(1);
|
||
#endif
|
||
|
||
if( !IsBestFriendItem(pActor, pParts->GetItemType(), nParam1, nParam2, pParts->GetSerialID()))
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CDnPlayerState::IsApplyWeaponState(CDnActor *pActor, CDnWeapon* pWeapon, bool Durability)
|
||
{
|
||
if( Durability && !pWeapon->IsInfinityDurability() && pWeapon->GetDurability() <= 0 )
|
||
return false;
|
||
|
||
int nParam1=0, nParam2 = 0;
|
||
#if defined (_GAMESERVER)
|
||
int* nTypePram = pWeapon->GetTypeParam();
|
||
nParam1 = nTypePram[0];
|
||
nParam2 = nTypePram[1];
|
||
#elif defined (_CLIENT)
|
||
nParam1 = pWeapon->GetTypeParam(0);
|
||
nParam2 = pWeapon->GetTypeParam(1);
|
||
#endif
|
||
|
||
if( !IsBestFriendItem(pActor, pWeapon->GetItemType(), nParam1, nParam2, pWeapon->GetSerialID()))
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CDnPlayerState::IsBestFriendItem(CDnActor* pActor, eItemTypeEnum cType, int nParam1, int nParam2, INT64 nSerial)
|
||
{
|
||
#if defined (_GAMESERVER)
|
||
if (pActor && pActor->IsPlayerActor())
|
||
{
|
||
CDNUserSession* pUserSession = ((CDnPlayerActor*)pActor)->GetUserSession();
|
||
if (pUserSession)
|
||
{
|
||
TBestFriendInfo& Info = pUserSession->GetBestFriend()->GetInfo();
|
||
|
||
if (cType == ITEMTYPE_PARTS && nParam1 == 10 && nParam2 == 10)
|
||
{
|
||
if (Info.biItemSerial != nSerial)
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
#elif defined (_CLIENT)
|
||
|
||
if( pActor &&
|
||
cType == ITEMTYPE_PARTS && nParam1 == 10 && nParam2 == 10 &&
|
||
pActor->GetBFserial() != nSerial )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
#endif
|
||
|
||
void CDnPlayerState::GetStateList( int ListType, CDnState::ValueType Type, std::vector<CDnState *> &VecList )
|
||
{
|
||
VecList.clear();
|
||
|
||
CDnActorState::GetStateList( ListType, Type, VecList );
|
||
|
||
// <20><><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>´<EFBFBD>.
|
||
if( ListType & DefenseList ) {
|
||
CDnPlayerActor *pParts = static_cast<CDnPlayerActor *>(m_pActor);
|
||
if( pParts ) {
|
||
// <20>븻<EFBFBD><EBB8BB>
|
||
for( DWORD i=0; i<CDnParts::PartsTypeEnum_Amount; i++ ) {
|
||
DnPartsHandle hParts = pParts->GetParts( (CDnParts::PartsTypeEnum)i );
|
||
if( !hParts ) continue;
|
||
if( !hParts->IsInfinityDurability() && hParts->GetDurability() <= 0 ) continue;
|
||
|
||
std::vector<int> nVecJobHistory;
|
||
if( ((CDnPlayerActor*)m_pActor)->GetJobHistory( nVecJobHistory ) > 0 )
|
||
if( hParts->IsPermitPlayer( nVecJobHistory ) == false ) continue;
|
||
|
||
if( hParts->IsExistValueType( Type ) ) {
|
||
VecList.push_back( hParts );
|
||
}
|
||
|
||
if( hParts->IsActiveEnchant() ) {
|
||
if( hParts->GetEnchantState() && hParts->GetEnchantState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hParts->GetEnchantState() );
|
||
}
|
||
if( hParts->IsActivePotential() ) {
|
||
if( hParts->GetPotentialState() && hParts->GetPotentialState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hParts->GetPotentialState() );
|
||
}
|
||
}
|
||
// ij<><C4B3><EFBFBD><EFBFBD>
|
||
for( DWORD i=0; i<CDnParts::CashPartsTypeEnum_Amount; i++ ) {
|
||
DnPartsHandle hParts = pParts->GetCashParts( (CDnParts::PartsTypeEnum)i );
|
||
if( !hParts ) continue;
|
||
#if defined (PRE_ADD_BESTFRIEND)
|
||
if (!IsApplyPartsState(pParts, hParts)) continue;
|
||
#endif
|
||
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> üũ<C3BC><C5A9><EFBFBD><EFBFBD><EFBFBD>ʴ´<CAB4>.
|
||
if( hParts->IsExistValueType( Type ) ) {
|
||
VecList.push_back( hParts );
|
||
}
|
||
|
||
if( hParts->IsActiveEnchant() ) {
|
||
if( hParts->GetEnchantState() && hParts->GetEnchantState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hParts->GetEnchantState() );
|
||
|
||
}
|
||
if( hParts->IsActivePotential() ) {
|
||
if( hParts->GetPotentialState() && hParts->GetPotentialState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hParts->GetPotentialState() );
|
||
}
|
||
}
|
||
// ij<><C4B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
for( int i=0; i<2; i++ ) {
|
||
DnWeaponHandle hWeapon = pParts->GetCashWeapon(i);
|
||
if( !hWeapon ) continue;
|
||
#if defined (PRE_ADD_BESTFRIEND)
|
||
if (!IsApplyWeaponState(pParts, hWeapon)) continue;
|
||
#endif
|
||
if( hWeapon->IsExistValueType( Type ) ) {
|
||
VecList.push_back( hWeapon );
|
||
}
|
||
if( hWeapon->IsActiveEnchant() ) {
|
||
if( hWeapon->GetEnchantState() && hWeapon->GetEnchantState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hWeapon->GetEnchantState() );
|
||
|
||
}
|
||
if( hWeapon->IsActivePotential() ) {
|
||
if( hWeapon->GetPotentialState() && hWeapon->GetPotentialState()->IsExistValueType( Type ) )
|
||
VecList.push_back( hWeapon->GetPotentialState() );
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
// SetItem State
|
||
if( ( ListType & SetItemList ) && m_pSetItemState ) {
|
||
VecList.push_back( m_pSetItemState );
|
||
}
|
||
// Appellation State
|
||
if( ( ListType & AppellationList ) && m_pAppellationState ) {
|
||
VecList.push_back( m_pAppellationState );
|
||
}
|
||
// Glyph State
|
||
if( ListType & GlyphList ) {
|
||
CDnPlayerActor *pGlyph = static_cast<CDnPlayerActor *>(m_pActor);
|
||
if( pGlyph ) {
|
||
for( DWORD i=0; i<CDnGlyph::GlyphSlotEnum_Amount; i++ ) {
|
||
DnGlyphHandle hGlyph = pGlyph->GetGlyph( (CDnGlyph::GlyphSlotEnum)i );
|
||
if( !hGlyph ) continue;
|
||
|
||
#if !defined(_GAMESERVER)
|
||
#if defined(PRE_ADD_DRAGON_FELLOWSHIP_GLYPH)
|
||
if( (i >= CDnGlyph::Cash1 && i <= CDnGlyph::Cash3) && false == GetItemTask().IsCashGlyphOpen( i - CDnGlyph::Cash1 ) )
|
||
#else
|
||
if( i >= CDnGlyph::Cash1 && false == GetItemTask().IsCashGlyphOpen( i - CDnGlyph::Cash1 ) )
|
||
#endif // #if defined(PRE_ADD_DRAGON_FELLOWSHIP_GLYPH)
|
||
continue;
|
||
#endif // #if !defined(_GAMESERVER)
|
||
|
||
if( hGlyph->IsExistValueType( Type ) )
|
||
{
|
||
VecList.push_back( hGlyph );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Talisman State
|
||
#ifdef PRE_ADD_TALISMAN_SYSTEM
|
||
if( ListType & TalismanList) {
|
||
CDnPlayerActor* pTalisman = static_cast<CDnPlayerActor*>(m_pActor);
|
||
if(pTalisman) {
|
||
for( DWORD i = 0 ; i < TALISMAN_MAX ; ++i ) {
|
||
DnTalismanHandle hTalisman = pTalisman->GetTalisman(i);
|
||
if( !hTalisman ) continue;
|
||
if( hTalisman->IsExistValueType(Type) )
|
||
{
|
||
VecList.push_back( hTalisman );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif // PRE_ADD_TALISMAN_SYSTEM
|
||
|
||
if( ( ListType & PetAbility ) && m_pPetAbilityState )
|
||
{
|
||
VecList.push_back( m_pPetAbilityState );
|
||
}
|
||
if( ( ListType & PetAbility ) && m_vecpPetAccessaryState.size() > 0 )
|
||
{
|
||
for( int i=0; i<(int)m_vecpPetAccessaryState.size(); i++ )
|
||
VecList.push_back( m_vecpPetAccessaryState[i] );
|
||
}
|
||
}
|
||
|
||
void CDnPlayerState::CalcSetItemState()
|
||
{
|
||
if( m_nLevel == 0 ) return;
|
||
|
||
std::map<int, int> nMapSetList;
|
||
std::map<int, int>::iterator it;
|
||
CDnPlayerActor *pPlayerActor = static_cast<CDnPlayerActor *>(m_pActor);
|
||
if( !pPlayerActor ) return;
|
||
|
||
int nSetItemID = 0;
|
||
|
||
// <20>븻<EFBFBD><EBB8BB>
|
||
for( int i=CDnParts::Helmet; i<=CDnParts::Ring2; i++ ) {
|
||
DnPartsHandle hParts = pPlayerActor->GetParts( (CDnParts::PartsTypeEnum)i );
|
||
if( !hParts ) continue;
|
||
|
||
nSetItemID = hParts->GetSetItemID();
|
||
if( nSetItemID < 1 ) continue;
|
||
|
||
#if defined( PRE_ADD_OVERLAP_SETEFFECT )
|
||
if( hParts->GetOverLapSet() )
|
||
{
|
||
CalcOverLapSetItemState(nSetItemID, nMapSetList);
|
||
continue;
|
||
}
|
||
#endif
|
||
|
||
it = nMapSetList.find( nSetItemID );
|
||
if( it != nMapSetList.end() ) {
|
||
it->second++;
|
||
}
|
||
else {
|
||
nMapSetList.insert( make_pair( nSetItemID, 1 ) );
|
||
}
|
||
}
|
||
//<2F>ɽ<EFBFBD><C9BD><EFBFBD>
|
||
for( int i=CDnParts::CashHelmet; i<=CDnParts::CashFairy; i++ ) {
|
||
DnPartsHandle hParts = pPlayerActor->GetCashParts( (CDnParts::PartsTypeEnum)i );
|
||
if( !hParts ) continue;
|
||
nSetItemID = hParts->GetSetItemID();
|
||
if( nSetItemID < 1 ) continue;
|
||
#if defined (PRE_ADD_BESTFRIEND)
|
||
if (!IsApplyPartsState(pPlayerActor, hParts, false)) continue;
|
||
#endif
|
||
#if defined( PRE_ADD_OVERLAP_SETEFFECT )
|
||
if( hParts->GetOverLapSet() )
|
||
{
|
||
CalcOverLapSetItemState(nSetItemID, nMapSetList);
|
||
continue;
|
||
}
|
||
#endif
|
||
it = nMapSetList.find( nSetItemID );
|
||
if( it != nMapSetList.end() ) {
|
||
it->second++;
|
||
}
|
||
else {
|
||
nMapSetList.insert( make_pair( nSetItemID, 1 ) );
|
||
}
|
||
}
|
||
|
||
// <20>븻<EFBFBD><EBB8BB>
|
||
for( int i=0; i<2; i++ ) {
|
||
DnWeaponHandle hWeapon = m_pActor->GetWeapon(i);
|
||
if( !hWeapon ) continue;
|
||
nSetItemID = hWeapon->GetSetItemID();
|
||
if( nSetItemID < 1 ) continue;
|
||
|
||
#if defined( PRE_ADD_OVERLAP_SETEFFECT )
|
||
if( hWeapon->GetOverLapSet() )
|
||
{
|
||
CalcOverLapSetItemState(nSetItemID, nMapSetList);
|
||
continue;
|
||
}
|
||
#endif
|
||
it = nMapSetList.find( nSetItemID );
|
||
if( it != nMapSetList.end() ) {
|
||
it->second++;
|
||
}
|
||
else {
|
||
nMapSetList.insert( make_pair( nSetItemID, 1 ) );
|
||
}
|
||
}
|
||
// <20>ɽ<EFBFBD><C9BD><EFBFBD>
|
||
for( int i=0; i<2; i++ ) {
|
||
DnWeaponHandle hWeapon = pPlayerActor->GetCashWeapon(i);
|
||
if( !hWeapon ) continue;
|
||
nSetItemID = hWeapon->GetSetItemID();
|
||
if( nSetItemID < 1 ) continue;
|
||
#if defined (PRE_ADD_BESTFRIEND)
|
||
if (!IsApplyWeaponState(pPlayerActor, hWeapon, false)) continue;
|
||
#endif
|
||
#if defined( PRE_ADD_OVERLAP_SETEFFECT )
|
||
if( hWeapon->GetOverLapSet() )
|
||
{
|
||
CalcOverLapSetItemState(nSetItemID, nMapSetList);
|
||
continue;
|
||
}
|
||
#endif
|
||
it = nMapSetList.find( nSetItemID );
|
||
if( it != nMapSetList.end() ) {
|
||
it->second++;
|
||
}
|
||
else {
|
||
nMapSetList.insert( make_pair( nSetItemID, 1 ) );
|
||
}
|
||
}
|
||
|
||
SAFE_DELETE( m_pSetItemState );
|
||
|
||
if( nMapSetList.empty() )
|
||
{
|
||
#ifdef PRE_ADD_COSTUME_SKILL
|
||
pPlayerActor->RefreshCostumeSkill( 0, 0 );
|
||
#endif
|
||
return;
|
||
}
|
||
|
||
m_pSetItemState = new CDnState;
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TSETITEM );
|
||
char szLabel[32];
|
||
int nTemp;
|
||
for( it = nMapSetList.begin(); it != nMapSetList.end(); it++ ) {
|
||
if( it->second < 2 ) continue;
|
||
|
||
nSetItemID = it->first;
|
||
std::vector<int> nVecStateList;
|
||
for( int i=0; i<12; i++ ) {
|
||
sprintf_s( szLabel, "_NeedSetNum%d", i + 1 );
|
||
nTemp = pSox->GetFieldFromLablePtr( nSetItemID, szLabel )->GetInteger();
|
||
if( nTemp < 2 ) continue;
|
||
if( nTemp <= it->second ) nVecStateList.push_back(i);
|
||
}
|
||
for( DWORD i=0; i<nVecStateList.size(); i++ ) {
|
||
sprintf_s( szLabel, "_State%d", nVecStateList[i] + 1 );
|
||
int nStateType = pSox->GetFieldFromLablePtr( nSetItemID, szLabel )->GetInteger();
|
||
sprintf_s( szLabel, "_State%dValue", nVecStateList[i] + 1 );
|
||
char *szValue = pSox->GetFieldFromLablePtr( nSetItemID, szLabel )->GetString();
|
||
#ifdef _GAMESERVER
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), m_pSetItemState, nStateType, szValue, szValue, false, false );
|
||
#else
|
||
CDnItem::CalcStateValue( m_pSetItemState, nStateType, szValue, szValue, false, false );
|
||
#endif
|
||
}
|
||
}
|
||
|
||
#ifdef PRE_ADD_COSTUME_SKILL
|
||
for( it = nMapSetList.begin(); it != nMapSetList.end(); it++ )
|
||
{
|
||
nSetItemID = it->first;
|
||
|
||
int nCustumeSkillNeedCount = pSox->GetFieldFromLablePtr( nSetItemID, "_NeedCSSetNum" )->GetInteger();
|
||
if( nCustumeSkillNeedCount > 0 )
|
||
{
|
||
if( it->second >= nCustumeSkillNeedCount )
|
||
{
|
||
int nSkillIndex = pSox->GetFieldFromLablePtr( nSetItemID, "_SkillID" )->GetInteger();
|
||
int nSkillLevel = pSox->GetFieldFromLablePtr( nSetItemID, "_SkillLevel" )->GetInteger();
|
||
pPlayerActor->RefreshCostumeSkill( nSkillIndex, nSkillLevel );
|
||
}
|
||
else
|
||
{
|
||
pPlayerActor->RefreshCostumeSkill( 0, 0 );
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
#if defined( PRE_ADD_OVERLAP_SETEFFECT )
|
||
void CDnPlayerState::CalcOverLapSetItemState(int nOverLapSetItemID, std::map<int, int> &nMapSetList)
|
||
{
|
||
if( nOverLapSetItemID > 0 )
|
||
{
|
||
int nOverLapID = 0;
|
||
std::map<int, int>::iterator it;
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TOVERLAPSETEFFECT );
|
||
char szLabel[32];
|
||
for(int i=0;i<10;i++)
|
||
{
|
||
sprintf_s( szLabel, "_SetItemID%d", i + 1 );
|
||
nOverLapID = pSox->GetFieldFromLablePtr( nOverLapSetItemID, szLabel )->GetInteger();
|
||
if( nOverLapID > 0 )
|
||
{
|
||
it = nMapSetList.find( nOverLapID );
|
||
if( it != nMapSetList.end() ) {
|
||
it->second++;
|
||
}
|
||
else {
|
||
nMapSetList.insert( make_pair( nOverLapID, 1 ) );
|
||
}
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
void CDnPlayerState::CalcAppellationState()
|
||
{
|
||
SAFE_DELETE( m_pAppellationState );
|
||
if( m_nAppellationIndex == -1 ) return;
|
||
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TAPPELLATION );
|
||
int nItemID = pSox->GetItemID( m_nAppellationIndex );
|
||
if( nItemID == -1 ) return;
|
||
|
||
bool bExistState = false;
|
||
char szLabel[32];
|
||
int nState[10] = { -1, };
|
||
char *szStateValue[10];
|
||
|
||
for( int i=0; i<10; i++ ) {
|
||
sprintf_s( szLabel, "_State%d", i + 1 );
|
||
nState[i] = pSox->GetFieldFromLablePtr( nItemID, szLabel )->GetInteger();
|
||
if( nState[i] >= 0 ) bExistState = true;
|
||
sprintf_s( szLabel, "_StateValue%d", i + 1 );
|
||
szStateValue[i] = pSox->GetFieldFromLablePtr( nItemID, szLabel )->GetString();
|
||
}
|
||
|
||
if( bExistState ) {
|
||
m_pAppellationState = new CDnState;
|
||
|
||
for( int i=0; i<10; i++ ) {
|
||
#ifdef _GAMESERVER
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), m_pAppellationState, nState[i], szStateValue[i], szStateValue[i], false );
|
||
#else
|
||
CDnItem::CalcStateValue( m_pAppellationState, nState[i], szStateValue[i], szStateValue[i], false );
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
void CDnPlayerState::SetAppellationIndex( int nCoverIndex, int nIndex )
|
||
{
|
||
m_nCoverAppellationIndex = nCoverIndex;
|
||
m_nAppellationIndex = nIndex;
|
||
}
|
||
|
||
void CDnPlayerState::ChangeAppellationState( int nCoverArrayIndex, int nArrayIndex )
|
||
{
|
||
SetAppellationIndex( nCoverArrayIndex, nArrayIndex );
|
||
RefreshState( RefreshEquip );
|
||
}
|
||
|
||
bool CDnPlayerState::IsSetAppellationIndex()
|
||
{
|
||
if( m_nAppellationIndex == -1 && m_nCoverAppellationIndex == -1 )
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
void CDnPlayerState::CalcPetAbilityState()
|
||
{
|
||
if( m_nLevel == 0 ) return;
|
||
|
||
SAFE_DELETE( m_pPetAbilityState );
|
||
|
||
CDnPlayerActor *pPlayer = static_cast<CDnPlayerActor *>(m_pActor);
|
||
if( !pPlayer ) return;
|
||
|
||
#ifdef _GAMESERVER
|
||
if( !pPlayer->GetUserSession() || !pPlayer->GetUserSession()->GetItem() || !pPlayer->IsCanPetMode() ) return;
|
||
if( pPlayer->GetUserSession()->GetItem()->GetPetBodyItemID() == 0 && pPlayer->GetUserSession()->GetItem()->GetPetExp() == 0 ) return; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||
TPetLevelDetail *pPetData = g_pDataManager->GetPetLevelDetail( pPlayer->GetUserSession()->GetItem()->GetPetBodyItemID(), pPlayer->GetUserSession()->GetItem()->GetPetExp() );
|
||
if( !pPetData ) return;
|
||
|
||
bool bExistState = false;
|
||
for( int i=0; i<PetStateMax; i++ )
|
||
{
|
||
if (pPetData->nState[i] >= 0)
|
||
{
|
||
bExistState = true;
|
||
break;
|
||
}
|
||
}
|
||
#else // _GAMESERVER
|
||
if( !pPlayer->GetSummonPet() || !pPlayer->IsSummonPet() ) return;
|
||
int nPetLevelTableIndex = GetPetTask().GetPetLevelTableIndex( pPlayer->GetUniqueID() );
|
||
if( nPetLevelTableIndex == -1 ) return;
|
||
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TPETLEVEL );
|
||
if( pSox == NULL ) return;
|
||
|
||
bool bExistState = false;
|
||
char szLabel[32];
|
||
int nState[10] = { -1, };
|
||
char* szStateMinValue[10];
|
||
char* szStateMaxValue[10];
|
||
|
||
for( int i=0; i<10; i++ )
|
||
{
|
||
sprintf_s( szLabel, "_State%d", i + 1 );
|
||
nState[i] = pSox->GetFieldFromLablePtr( nPetLevelTableIndex, szLabel )->GetInteger();
|
||
if( nState[i] >= 0 ) bExistState = true;
|
||
sprintf_s( szLabel, "_State%d_Min", i + 1 );
|
||
szStateMinValue[i] = pSox->GetFieldFromLablePtr( nPetLevelTableIndex, szLabel )->GetString();
|
||
sprintf_s( szLabel, "_State%d_Max", i + 1 );
|
||
szStateMaxValue[i] = pSox->GetFieldFromLablePtr( nPetLevelTableIndex, szLabel )->GetString();
|
||
}
|
||
#endif // _GAMESERVER
|
||
if( bExistState )
|
||
{
|
||
m_pPetAbilityState = new CDnState;
|
||
|
||
for( int i=0; i<10; i++ )
|
||
{
|
||
#ifdef _GAMESERVER
|
||
if( pPlayer->GetUserSession()->GetItem()->GetPetEquip()->nType & Pet::Type::ePETTYPE_SATIETY ) // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>뿡 <20><><EFBFBD><EFBFBD>
|
||
{
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), m_pPetAbilityState, pPetData->nState[i], pPetData->szStateMin[i], pPetData->szStateMax[i], false ,
|
||
true, pPlayer->GetUserSession()->GetItem()->GetSatietyApplyStateRatio() );
|
||
}
|
||
else
|
||
{
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), m_pPetAbilityState, pPetData->nState[i], pPetData->szStateMin[i], pPetData->szStateMax[i], false );
|
||
}
|
||
#else // _GAMESERVER
|
||
if( pPlayer->GetPetInfo().nType & Pet::Type::ePETTYPE_SATIETY ) // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>뿡 <20><><EFBFBD><EFBFBD>
|
||
{
|
||
CDnItem::CalcStateValue( m_pPetAbilityState, nState[i], szStateMinValue[i], szStateMaxValue[i], false, true, GetPetTask().GetSatietyApplyStateRatio() );
|
||
}
|
||
else
|
||
{
|
||
CDnItem::CalcStateValue( m_pPetAbilityState, nState[i], szStateMinValue[i], szStateMaxValue[i], false );
|
||
}
|
||
#endif // _GAMESERVER
|
||
}
|
||
}
|
||
}
|
||
|
||
void CDnPlayerState::CalcPetAccessaryAbilityState()
|
||
{
|
||
if( m_nLevel == 0 ) return;
|
||
|
||
for( int i=0; i<(int)m_vecpPetAccessaryState.size(); i++ )
|
||
{
|
||
if( m_vecpPetAccessaryState[i] )
|
||
SAFE_DELETE( m_vecpPetAccessaryState[i] );
|
||
}
|
||
m_vecpPetAccessaryState.clear();
|
||
|
||
CDnPlayerActor *pPlayer = static_cast<CDnPlayerActor *>(m_pActor);
|
||
if( !pPlayer ) return;
|
||
|
||
vector<int> vecPartsItemID;
|
||
#ifdef _GAMESERVER
|
||
if( !pPlayer->GetUserSession() || !pPlayer->GetUserSession()->GetItem() || !pPlayer->IsCanPetMode() ) return;
|
||
|
||
const TVehicle* pPetEquip = pPlayer->GetUserSession()->GetItem()->GetPetEquip();
|
||
if( !pPetEquip ) return;
|
||
|
||
bool bExistState = false;
|
||
for( int i=Pet::Slot::Accessory1; i<Pet::Slot::Max; ++i )
|
||
{
|
||
if( !pPetEquip->Vehicle[i].nItemID ) continue;
|
||
vecPartsItemID.push_back( pPetEquip->Vehicle[i].nItemID );
|
||
}
|
||
#else // _GAMESERVER
|
||
if( !pPlayer->GetSummonPet() || !pPlayer->IsSummonPet() ) return;
|
||
|
||
for( int i=Pet::Slot::Accessory1; i<Pet::Slot::Max; ++i )
|
||
{
|
||
if( !pPlayer->GetPetInfo().Vehicle[i].nItemID ) continue;
|
||
vecPartsItemID.push_back( pPlayer->GetPetInfo().Vehicle[i].nItemID );
|
||
}
|
||
#endif // _GAMESERVER
|
||
|
||
if( vecPartsItemID.size() == 0 ) return;
|
||
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TITEM );
|
||
if( pSox == NULL ) return;
|
||
|
||
char szLabel[32];
|
||
|
||
for( int i=0; i<static_cast<int>( vecPartsItemID.size() ); i++ )
|
||
{
|
||
bool bExistState = false;
|
||
int nState[10] = { -1, };
|
||
char* szStateMinValue[10];
|
||
char* szStateMaxValue[10];
|
||
|
||
for( int j=0; j<10; j++ )
|
||
{
|
||
sprintf_s( szLabel, "_State%d", j + 1 );
|
||
nState[j] = pSox->GetFieldFromLablePtr( vecPartsItemID[i], szLabel )->GetInteger();
|
||
if( nState[j] >= 0 ) bExistState = true;
|
||
sprintf_s( szLabel, "_State%d_Min", j + 1 );
|
||
szStateMinValue[j] = pSox->GetFieldFromLablePtr( vecPartsItemID[i], szLabel )->GetString();
|
||
sprintf_s( szLabel, "_State%d_Max", j + 1 );
|
||
szStateMaxValue[j] = pSox->GetFieldFromLablePtr( vecPartsItemID[i], szLabel )->GetString();
|
||
}
|
||
|
||
if( bExistState )
|
||
{
|
||
CDnState* pPetEquipState = new CDnState;
|
||
for( int k=0; k<10; k++ )
|
||
{
|
||
#ifdef _GAMESERVER
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), pPetEquipState, nState[k], szStateMinValue[k], szStateMaxValue[k], false );
|
||
#else // _GAMESERVER
|
||
CDnItem::CalcStateValue( pPetEquipState, nState[k], szStateMinValue[k], szStateMaxValue[k], false );
|
||
#endif // _GAMESERVER
|
||
}
|
||
m_vecpPetAccessaryState.push_back( pPetEquipState );
|
||
}
|
||
}
|
||
vecPartsItemID.clear();
|
||
|
||
// <20><> <20><>Ʈȿ<C6AE><C8BF>
|
||
pSox = GetDNTable( CDnTableDB::TVEHICLEPARTS );
|
||
if( !pSox ) return;
|
||
#ifdef _GAMESERVER
|
||
int nSetItemID1 = pSox->GetFieldFromLablePtr( pPetEquip->Vehicle[Pet::Slot::Accessory1].nItemID, "_SetItemID" )->GetInteger();
|
||
int nSetItemID2 = pSox->GetFieldFromLablePtr( pPetEquip->Vehicle[Pet::Slot::Accessory2].nItemID, "_SetItemID" )->GetInteger();
|
||
#else // _GAMESERVER
|
||
int nSetItemID1 = pSox->GetFieldFromLablePtr( pPlayer->GetPetInfo().Vehicle[Pet::Slot::Accessory1].nItemID, "_SetItemID" )->GetInteger();
|
||
int nSetItemID2 = pSox->GetFieldFromLablePtr( pPlayer->GetPetInfo().Vehicle[Pet::Slot::Accessory2].nItemID, "_SetItemID" )->GetInteger();
|
||
#endif // _GAMESERVER
|
||
if( nSetItemID1 > 0 && nSetItemID2 > 0 && nSetItemID1 == nSetItemID2 )
|
||
{
|
||
DNTableFileFormat* pSox = GetDNTable( CDnTableDB::TSETITEM );
|
||
char szLabel[32];
|
||
int nTemp;
|
||
std::vector<int> nVecStateList;
|
||
for( int i=0; i<12; i++ )
|
||
{
|
||
sprintf_s( szLabel, "_NeedSetNum%d", i+1 );
|
||
nTemp = pSox->GetFieldFromLablePtr( nSetItemID1, szLabel )->GetInteger();
|
||
if( nTemp < 2 ) continue;
|
||
nVecStateList.push_back(i);
|
||
}
|
||
|
||
CDnState* pPetEquipState = new CDnState;
|
||
for( DWORD i=0; i<nVecStateList.size(); i++ )
|
||
{
|
||
sprintf_s( szLabel, "_State%d", nVecStateList[i] + 1 );
|
||
int nStateType = pSox->GetFieldFromLablePtr( nSetItemID1, szLabel )->GetInteger();
|
||
sprintf_s( szLabel, "_State%dValue", nVecStateList[i] + 1 );
|
||
char *szValue = pSox->GetFieldFromLablePtr( nSetItemID1, szLabel )->GetString();
|
||
#ifdef _GAMESERVER
|
||
CDnItem::CalcStateValue( m_pActor->GetRoom(), pPetEquipState, nStateType, szValue, szValue, false, false );
|
||
#else // _GAMESERVER
|
||
CDnItem::CalcStateValue( pPetEquipState, nStateType, szValue, szValue, false, false );
|
||
#endif // _GAMESERVER
|
||
}
|
||
m_vecpPetAccessaryState.push_back( pPetEquipState );
|
||
}
|
||
}
|
||
|
||
void CDnPlayerState::RefreshAdditionalState( RefreshStateExtentEnum &Extent, StateTypeEnum &Type )
|
||
{
|
||
if( Extent != RefreshAll ) {
|
||
// RefreshSkill <20>ε<EFBFBD> <20>⺻<EFBFBD>ɷ<EFBFBD>ġ<EFBFBD><C4A1> <20><>ȭ<EFBFBD><C8AD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Equip <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20>ϹǷ<CFB9> <20><><EFBFBD>⼭ üũ<C3BC><C5A9><EFBFBD>ش<EFBFBD>.
|
||
if( ( Extent & RefreshSkill ) || ( Extent & RefreshEquip ) ) {
|
||
if( (Type&ST_Strength) || (Type&ST_Agility) || (Type&ST_Intelligence) || (Type&ST_Stamina) ) {
|
||
Extent = RefreshAll;
|
||
}
|
||
}
|
||
}
|
||
// <20><><EFBFBD><EFBFBD> State <20><> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20>ɾ<EFBFBD><C9BE>ش<EFBFBD>.
|
||
if( Type & ST_Strength ) Type = (StateTypeEnum)( Type | ST_AttackP | ST_Stiff | ST_StiffResistance | ST_Stun );
|
||
if( Type & ST_Agility ) Type = (StateTypeEnum)( Type | ST_AttackP | ST_Critical | ST_CriticalResistance );
|
||
if( Type & ST_Intelligence ) Type = (StateTypeEnum)( Type | ST_AttackM | ST_DefenseM | ST_SP | ST_RecoverySP );
|
||
if( Type & ST_Stamina ) Type = (StateTypeEnum)( Type | ST_DefenseP | ST_HP | ST_StunResistance );
|
||
|
||
|
||
// <20><>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
if( Type & RefreshEquip ) {
|
||
CalcSetItemState();
|
||
CalcAppellationState();
|
||
CalcPetAbilityState();
|
||
CalcPetAccessaryAbilityState();
|
||
}
|
||
}
|
||
|
||
#ifdef PRE_ADD_STAGE_DAMAGE_LIMIT
|
||
|
||
float CDnPlayerState::GetUseStageStateLimit()
|
||
{
|
||
#if defined(_GAMESERVER)
|
||
CDNGameRoom *pRoom = ((CDnPlayerActor*)m_pActor)->GetGameRoom();
|
||
if( pRoom )
|
||
{
|
||
CDnGameTask *pTask = pRoom->GetGameTask();
|
||
if( pTask && pTask->GetStageDamageLimit() )
|
||
{
|
||
return pTask->GetStageDamageLimit()->fStateLimit;
|
||
}
|
||
}
|
||
#else
|
||
CDnGameTask *pGameTask = (CDnGameTask*)CTaskManager::GetInstance().GetTask( "GameTask" );
|
||
if( pGameTask && pGameTask->GetStageDamageLimit() )
|
||
{
|
||
return pGameTask->GetStageDamageLimit()->fStateLimit;
|
||
}
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
#endif
|
||
|
||
char CDnPlayerState::GetUseRegulation()
|
||
{
|
||
|
||
#if defined(_GAMESERVER)
|
||
|
||
CDNGameRoom *pRoom = ((CDnPlayerActor*)m_pActor)->GetGameRoom();
|
||
if( pRoom )
|
||
{
|
||
CDnGameTask *pTask = pRoom->GetGameTask();
|
||
if( pTask )
|
||
{
|
||
if (pRoom->bIsPvPRoom())
|
||
{
|
||
if( pRoom->bIsZombieMode() )
|
||
return 4; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ƽ<DEBE><C6BC><EFBFBD> <20>ȵ˴ϴ<CBB4>.
|
||
|
||
char cPvPRegulation = 1;
|
||
|
||
if( pRoom->bIsLadderRoom() )
|
||
cPvPRegulation = 3;
|
||
if( pRoom->bIsGuildWarSystem() )
|
||
cPvPRegulation = 5;
|
||
|
||
#ifdef PRE_ADD_DWC
|
||
if( GetAccountLevel() == AccountLevel_DWC )
|
||
cPvPRegulation = 9;
|
||
#endif
|
||
if( pRoom->bIsLevelRegulation() == false )
|
||
return 0;
|
||
|
||
return cPvPRegulation;
|
||
}
|
||
else if( pRoom->bIsDLRoom() )
|
||
{
|
||
#ifdef PRE_ADD_CHALLENGE_DARKLAIR
|
||
CDnDLGameTask *pDLTask = (CDnDLGameTask *)pTask;
|
||
if( pDLTask && pDLTask->IsChallengeDarkLair() )
|
||
{
|
||
return 7;
|
||
}
|
||
#endif
|
||
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
#if defined( PRE_NORMALSTAGE_REGULATION )
|
||
const TMapInfo* pMapInfo = g_pDataManager->GetMapInfo( pRoom->GetGameTask()->GetMapTableID() );
|
||
if(pMapInfo)
|
||
{
|
||
return pMapInfo->cRevisionNum;
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
|
||
#else // _CLIENT
|
||
|
||
CDnGameTask *pGameTask = (CDnGameTask*)CTaskManager::GetInstance().GetTask( "GameTask" );
|
||
if( pGameTask )
|
||
{
|
||
switch( pGameTask->GetGameTaskType() )
|
||
{
|
||
case GameTaskType::PvP:
|
||
{
|
||
if( ((CDnPvPGameTask*)pGameTask)->GetGameMode() == PvPCommon::GameMode::PvP_Zombie_Survival )
|
||
return 4; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ƽ<DEBE><C6BC><EFBFBD> <20>ȵ˴ϴ<CBB4>.
|
||
|
||
char cPvPRegulation = 1;
|
||
|
||
if( ((CDnPvPGameTask*)pGameTask)->IsLadderMode() == true )
|
||
cPvPRegulation = 3;
|
||
if( ((CDnPvPGameTask*)pGameTask)->GetGameMode() == PvPCommon::GameMode::PvP_GuildWar )
|
||
cPvPRegulation = 5;
|
||
#ifdef PRE_ADD_DWC
|
||
if( GetAccountLevel() == AccountLevel_DWC )
|
||
cPvPRegulation = 9;
|
||
#endif
|
||
if( ((CDnPvPGameTask*)pGameTask)->IsUseRegulation() == false )
|
||
return 0;
|
||
|
||
return cPvPRegulation;
|
||
}
|
||
break;
|
||
case GameTaskType::DarkLair:
|
||
{
|
||
#ifdef PRE_ADD_CHALLENGE_DARKLAIR
|
||
CDnDLGameTask* pDarkLairGameTask = static_cast<CDnDLGameTask*>(pGameTask);
|
||
if( pDarkLairGameTask && pDarkLairGameTask->IsChallengeDarkLair() )
|
||
return 7;
|
||
#endif
|
||
|
||
return 2;
|
||
}
|
||
break;
|
||
case GameTaskType::Normal:
|
||
{
|
||
#if defined( PRE_NORMALSTAGE_REGULATION )
|
||
DNTableFileFormat *pSox = GetDNTable( CDnTableDB::TMAP );
|
||
if ( pSox )
|
||
{
|
||
return pSox->GetFieldFromLablePtr( pGameTask->GetGameMapIndex(), "_RevisionNum" )->GetInteger();
|
||
}
|
||
#endif
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
|
||
#endif
|
||
|
||
}
|
||
|
||
void CDnPlayerState::CalcStrength( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStrength( CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::Strength ) );
|
||
}
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStrength() );
|
||
nTemp = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStrengthRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStrength( nTemp );
|
||
|
||
#ifdef PRE_ADD_BASE_STAT_REGULATION
|
||
OnCalcEquipStep( ST_Strength, &m_StateStep[0] );
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStrength() );
|
||
nBuffValue = m_StateStep[0].GetStrength() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStrengthRatio() );
|
||
#ifdef PRE_ADD_BASIC_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue, fBuffRatioValue, GetStrengthRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Strength_Ratio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Strength_Ratio_Max ) );
|
||
#endif
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStrength( nBuffValue - m_StateStep[0].GetStrength() );
|
||
|
||
m_StateStep[0].SetStrength( nBuffValue );
|
||
#endif
|
||
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStrength(), fRatioValue, GetStrengthRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStrength() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStrength( nTemp );
|
||
}
|
||
m_nStrength = m_StateStep[0].GetStrength() + m_StateStep[1].GetStrength();
|
||
}
|
||
|
||
void CDnPlayerState::CalcAgility( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetAgility( CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::Agility ) );
|
||
}
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetAgility() );
|
||
nTemp = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetAgilityRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetAgility( nTemp );
|
||
|
||
#ifdef PRE_ADD_BASE_STAT_REGULATION
|
||
OnCalcEquipStep( ST_Agility, &m_StateStep[0] );
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetAgility() );
|
||
nBuffValue = m_StateStep[0].GetAgility() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetAgilityRatio() );
|
||
#ifdef PRE_ADD_BASIC_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue, fBuffRatioValue, GetAgilityRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Agility_Ratio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Agility_Ratio_Max ) );
|
||
#endif
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetAgility( nBuffValue - m_StateStep[0].GetAgility() );
|
||
|
||
m_StateStep[0].SetAgility( nBuffValue );
|
||
#endif
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetAgility(), fRatioValue, GetAgilityRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetAgility() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetAgility( nTemp );
|
||
}
|
||
m_nAgility = m_StateStep[0].GetAgility() + m_StateStep[1].GetAgility();
|
||
}
|
||
|
||
void CDnPlayerState::CalcIntelligence( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetIntelligence( CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::Intelligence ) );
|
||
}
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetIntelligence() );
|
||
nTemp = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetIntelligenceRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetIntelligence( nTemp );
|
||
|
||
#ifdef PRE_ADD_BASE_STAT_REGULATION
|
||
OnCalcEquipStep( ST_Intelligence, &m_StateStep[0] );
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetIntelligence() );
|
||
nBuffValue = m_StateStep[0].GetIntelligence() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetIntelligenceRatio() );
|
||
#ifdef PRE_ADD_BASIC_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue, fBuffRatioValue, GetIntelligenceRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Intelligence_Ratio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Intelligence_Ratio_Max ) );
|
||
#endif
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetIntelligence( nBuffValue - m_StateStep[0].GetIntelligence() );
|
||
|
||
m_StateStep[0].SetIntelligence( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetIntelligence(), fRatioValue, GetIntelligenceRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetIntelligence() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetIntelligence( nTemp );
|
||
}
|
||
|
||
m_nIntelligence = m_StateStep[0].GetIntelligence() + m_StateStep[1].GetIntelligence();
|
||
}
|
||
|
||
void CDnPlayerState::CalcStamina( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStamina( CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CPlayerLevelTable::Stamina ) );
|
||
}
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStamina() );
|
||
nTemp = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStaminaRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStamina( nTemp );
|
||
|
||
#ifdef PRE_ADD_BASE_STAT_REGULATION
|
||
OnCalcEquipStep( ST_Stamina, &m_StateStep[0] );
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStamina() );
|
||
nBuffValue = m_StateStep[0].GetStamina() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStaminaRatio() );
|
||
#ifdef PRE_ADD_BASIC_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue, fBuffRatioValue, GetStaminaRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Stamina_Ratio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Stamina_Ratio_Max ) );
|
||
#endif
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStamina( nBuffValue - m_StateStep[0].GetStamina() );
|
||
|
||
m_StateStep[0].SetStamina( nBuffValue );
|
||
#endif
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStamina(), fRatioValue, GetStaminaRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStamina() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStamina( nTemp );
|
||
}
|
||
|
||
m_nStamina = m_StateStep[0].GetStamina() + m_StateStep[1].GetStamina();
|
||
}
|
||
|
||
void CDnPlayerState::CalcAttackP( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp[2] = {0,0};
|
||
|
||
if( Extent & RefreshBase )
|
||
{
|
||
int nBaseStrength = m_nStrength;
|
||
int nBaseAgility = m_nAgility;
|
||
#ifdef PRE_ADD_CHANGE_ATK_FORMULA_BY_STATE
|
||
nBaseStrength = m_StateStep[0].GetStrength() - m_BuffState.GetStrength();
|
||
nBaseAgility = m_StateStep[0].GetAgility() - m_BuffState.GetAgility();
|
||
#endif
|
||
int nAttackPoint = (int)( nBaseStrength * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::StrengthAttack ) );
|
||
nAttackPoint += (int)( nBaseAgility * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::AgilityAttack ) );
|
||
m_BaseState.SetAttackPMin( nAttackPoint );
|
||
m_BaseState.SetAttackPMax( nAttackPoint );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetAttackPMin() );
|
||
nTemp[0] = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp[0], fRatioValue, GetAttackPMinRatio() );
|
||
nTemp[0] += (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetAttackPMax() );
|
||
nTemp[1] = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp[1], fRatioValue, GetAttackPMaxRatio() );
|
||
nTemp[1] += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetAttackPMin( nTemp[0] );
|
||
m_StateStep[0].SetAttackPMax( nTemp[1] );
|
||
|
||
OnCalcEquipStep( ST_AttackP, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue[2];
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetAttackPMin() );
|
||
nBuffValue[0] = m_StateStep[0].GetAttackPMin() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue[0], fBuffRatioValue, GetAttackPMinRatio() );
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue[0], fBuffRatioValue, GetAttackPMinRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Max ) );
|
||
#endif
|
||
nBuffValue[0] += (int)fBuffRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetAttackPMax() );
|
||
nBuffValue[1] = m_StateStep[0].GetAttackPMax() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue[1], fBuffRatioValue, GetAttackPMaxRatio() );
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue[1], fBuffRatioValue, GetAttackPMaxRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Max ) );
|
||
#endif
|
||
nBuffValue[1] += (int)fBuffRatioValue;
|
||
|
||
#ifdef PRE_ADD_CHANGE_ATK_FORMULA_BY_STATE
|
||
int nBuffSkillStrengh = m_BuffState.GetStrength() + m_StateStep[1].GetStrength();
|
||
int nBuffSkillAgility = m_BuffState.GetAgility() + m_StateStep[1].GetAgility();
|
||
int nAttackPoint = (int)( nBuffSkillStrengh * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::StrengthAttack ) );
|
||
nAttackPoint += (int)( nBuffSkillAgility * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::AgilityAttack ) );
|
||
|
||
nBuffValue[0] += nAttackPoint;
|
||
nBuffValue[1] += nAttackPoint;
|
||
#endif
|
||
|
||
m_BuffState.SetAttackPMin( nBuffValue[0] - m_StateStep[0].GetAttackPMin() );
|
||
m_BuffState.SetAttackPMax( nBuffValue[1] - m_StateStep[0].GetAttackPMax() );
|
||
|
||
m_StateStep[0].SetAttackPMin( nBuffValue[0] );
|
||
m_StateStep[0].SetAttackPMax( nBuffValue[1] );
|
||
#endif
|
||
|
||
// #32220 <20><>ų <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>. /////////////////////////
|
||
std::vector<CDnState *> pVecAbsoluteListBeforePost;
|
||
std::vector<CDnState *> pVecRatioListBeforePost;
|
||
|
||
GetStateList( BeforePostStateEffectList, ValueTypeAbsolute, pVecAbsoluteListBeforePost );
|
||
GetStateList( BeforePostStateEffectList, ValueTypeRatio, pVecRatioListBeforePost );
|
||
|
||
if( false == pVecAbsoluteListBeforePost.empty() || false == pVecRatioListBeforePost.empty() )
|
||
{
|
||
CALC_STATE_VALUE_RATIO( pVecRatioListBeforePost, m_StateStep[0].GetAttackPMin(), fRatioValue, GetAttackPMinRatio() );
|
||
nTemp[0] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteListBeforePost, nAddValue, GetAttackPMin() );
|
||
nTemp[0] += nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioListBeforePost, m_StateStep[0].GetAttackPMax(), fRatioValue, GetAttackPMaxRatio() );
|
||
nTemp[1] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteListBeforePost, nAddValue, GetAttackPMax() );
|
||
nTemp[1] += nAddValue;
|
||
|
||
m_StateStep[0].SetAttackPMin( m_StateStep[0].GetAttackPMin() + nTemp[ 0 ] );
|
||
m_StateStep[0].SetAttackPMax( m_StateStep[0].GetAttackPMax() + nTemp[ 1 ] );
|
||
}
|
||
|
||
#ifdef PRE_ADD_STAGE_DAMAGE_LIMIT
|
||
if( GetUseStageStateLimit() > 0.f )
|
||
{
|
||
nTemp[0] = m_StateStep[0].GetAttackPMin();
|
||
nTemp[1] = m_StateStep[0].GetAttackPMax();
|
||
int nEquipLevelAttackPowerMin = (int)( ( 1.f * GetUseStageStateLimit() ) * ( m_StateStep[0].GetAttackPMin() - m_BuffState.GetAttackPMin() ) );
|
||
int nEquipLevelAttackPowerMax = (int)( ( 1.f * GetUseStageStateLimit() ) * ( m_StateStep[0].GetAttackPMax() - m_BuffState.GetAttackPMax() ) );
|
||
CALC_STATE_LIMIT( nTemp[0], 0, nEquipLevelAttackPowerMin );
|
||
CALC_STATE_LIMIT( nTemp[1], 0, nEquipLevelAttackPowerMax );
|
||
#ifdef PRE_ADD_STAGE_LIMIT_INTERFACE
|
||
m_sDamageLimitInfo.bPhysicalAttack = ( nTemp[0] == nEquipLevelAttackPowerMin || nTemp[1] == nEquipLevelAttackPowerMax );
|
||
#endif
|
||
m_StateStep[0].SetAttackPMin( nTemp[0] );
|
||
m_StateStep[0].SetAttackPMax( nTemp[1] );
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetAttackPMin(), fRatioValue, GetAttackPMinRatio() );
|
||
nTemp[0] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetAttackPMin() );
|
||
nTemp[0] += nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetAttackPMax(), fRatioValue, GetAttackPMaxRatio() );
|
||
nTemp[1] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetAttackPMax() );
|
||
nTemp[1] += nAddValue;
|
||
|
||
|
||
m_StateStep[1].SetAttackPMin( nTemp[0] );
|
||
m_StateStep[1].SetAttackPMax( nTemp[1] );
|
||
}
|
||
|
||
m_nAttackP[0] = m_StateStep[0].GetAttackPMin() + m_StateStep[1].GetAttackPMin();
|
||
m_nAttackP[1] = m_StateStep[0].GetAttackPMax() + m_StateStep[1].GetAttackPMax();
|
||
|
||
#ifndef PRE_ADD_BUFF_STATE_LIMIT
|
||
// #31367 <20>̽<EFBFBD> <20><><EFBFBD><EFBFBD>. <20><><EFBFBD>ݷ<EFBFBD> <20>ּҰ<D6BC><D2B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3>.
|
||
float fAttackPowerClampLowestRatio = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::AttackPowerClampLowestRatio );
|
||
int nAttackPowerLowest = int((float)m_StateStep[0].GetAttackPMin() * fAttackPowerClampLowestRatio);
|
||
if( m_nAttackP[ 0 ] < nAttackPowerLowest )
|
||
{
|
||
m_nAttackP[ 0 ] = nAttackPowerLowest;
|
||
m_nAttackP[ 1 ] = int((float)m_StateStep[0].GetAttackPMax() * fAttackPowerClampLowestRatio);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void CDnPlayerState::CalcAttackM( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp[2] = {0,0};
|
||
|
||
if( Extent & RefreshBase )
|
||
{
|
||
int nBaseIntelligence = m_nIntelligence;
|
||
#ifdef PRE_ADD_CHANGE_ATK_FORMULA_BY_STATE
|
||
nBaseIntelligence = m_StateStep[0].GetIntelligence() - m_BuffState.GetIntelligence();
|
||
#endif
|
||
|
||
int nAttackPoint = (int)( nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::IntelligenceAttack ) );
|
||
m_BaseState.SetAttackMMin( nAttackPoint );
|
||
m_BaseState.SetAttackMMax( nAttackPoint );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetAttackMMin() );
|
||
nTemp[0] = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp[0], fRatioValue, GetAttackMMinRatio() );
|
||
nTemp[0] += (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetAttackMMax() );
|
||
nTemp[1] = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp[1], fRatioValue, GetAttackMMaxRatio() );
|
||
nTemp[1] += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetAttackMMin( nTemp[0] );
|
||
m_StateStep[0].SetAttackMMax( nTemp[1] );
|
||
OnCalcEquipStep( ST_AttackM, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue[2];
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetAttackMMin() );
|
||
nBuffValue[0] = m_StateStep[0].GetAttackMMin() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue[0], fBuffRatioValue, GetAttackMMinRatio() );
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue[0], fBuffRatioValue, GetAttackMMinRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Max ) );
|
||
#endif
|
||
nBuffValue[0] += (int)fBuffRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetAttackMMax() );
|
||
nBuffValue[1] = m_StateStep[0].GetAttackMMax() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue[1], fBuffRatioValue, GetAttackMMaxRatio() );
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList , nBuffValue[1], fBuffRatioValue, GetAttackMMaxRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Magical_AttackRatio_Max ) );
|
||
#endif
|
||
nBuffValue[1] += (int)fBuffRatioValue;
|
||
|
||
#ifdef PRE_ADD_CHANGE_ATK_FORMULA_BY_STATE
|
||
int nBuffSkillIntelligence = m_BuffState.GetIntelligence() + m_StateStep[1].GetIntelligence();
|
||
int nAttackPoint = (int)( nBuffSkillIntelligence * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::IntelligenceAttack ) );
|
||
nBuffValue[0] += nAttackPoint;
|
||
nBuffValue[1] += nAttackPoint;
|
||
#endif
|
||
|
||
m_BuffState.SetAttackMMin( nBuffValue[0] - m_StateStep[0].GetAttackMMin() );
|
||
m_BuffState.SetAttackMMax( nBuffValue[1] - m_StateStep[0].GetAttackMMax() );
|
||
|
||
m_StateStep[0].SetAttackMMin( nBuffValue[0] );
|
||
m_StateStep[0].SetAttackMMax( nBuffValue[1] );
|
||
#endif
|
||
|
||
// #32220 <20><>ų <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>. /////////////////////////
|
||
std::vector<CDnState *> pVecAbsoluteListBeforePost;
|
||
std::vector<CDnState *> pVecRatioListBeforePost;
|
||
|
||
GetStateList( BeforePostStateEffectList, ValueTypeAbsolute, pVecAbsoluteListBeforePost );
|
||
GetStateList( BeforePostStateEffectList, ValueTypeRatio, pVecRatioListBeforePost );
|
||
|
||
if( false == pVecAbsoluteListBeforePost.empty() || false == pVecRatioListBeforePost.empty() )
|
||
{
|
||
CALC_STATE_VALUE_RATIO( pVecRatioListBeforePost, m_StateStep[0].GetAttackMMin(), fRatioValue, GetAttackMMinRatio() );
|
||
nTemp[0] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteListBeforePost, nAddValue, GetAttackMMin() );
|
||
nTemp[0] += nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioListBeforePost, m_StateStep[0].GetAttackMMax(), fRatioValue, GetAttackMMaxRatio() );
|
||
nTemp[1] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteListBeforePost, nAddValue, GetAttackMMax() );
|
||
nTemp[1] += nAddValue;
|
||
|
||
m_StateStep[0].SetAttackMMin( m_StateStep[0].GetAttackMMin() + nTemp[ 0 ] );
|
||
m_StateStep[0].SetAttackMMax( m_StateStep[0].GetAttackMMax() + nTemp[ 1 ] );
|
||
}
|
||
|
||
#ifdef PRE_ADD_STAGE_DAMAGE_LIMIT
|
||
if( GetUseStageStateLimit() > 0.f )
|
||
{
|
||
nTemp[0] = m_StateStep[0].GetAttackMMin();
|
||
nTemp[1] = m_StateStep[0].GetAttackMMax();
|
||
int nEquipLevelAttackPowerMin = (int)( ( 1.f * GetUseStageStateLimit() ) * ( m_StateStep[0].GetAttackMMin() - m_BuffState.GetAttackMMin() ) );
|
||
int nEquipLevelAttackPowerMax = (int)( ( 1.f * GetUseStageStateLimit() ) * ( m_StateStep[0].GetAttackMMax() - m_BuffState.GetAttackMMax() ) );
|
||
CALC_STATE_LIMIT( nTemp[0], 0, nEquipLevelAttackPowerMin );
|
||
CALC_STATE_LIMIT( nTemp[1], 0, nEquipLevelAttackPowerMax );
|
||
#ifdef PRE_ADD_STAGE_LIMIT_INTERFACE
|
||
m_sDamageLimitInfo.bMagicalAttack = ( nTemp[0] == nEquipLevelAttackPowerMin || nTemp[1] == nEquipLevelAttackPowerMax );
|
||
#endif
|
||
m_StateStep[0].SetAttackMMin( nTemp[0] );
|
||
m_StateStep[0].SetAttackMMax( nTemp[1] );
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetAttackMMin(), fRatioValue, GetAttackMMinRatio() );
|
||
nTemp[0] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetAttackMMin() );
|
||
nTemp[0] += nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetAttackMMax(), fRatioValue, GetAttackMMaxRatio() );
|
||
nTemp[1] = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetAttackMMax() );
|
||
nTemp[1] += nAddValue;
|
||
|
||
m_StateStep[1].SetAttackMMin( nTemp[0] );
|
||
m_StateStep[1].SetAttackMMax( nTemp[1] );
|
||
}
|
||
|
||
m_nAttackM[0] = m_StateStep[0].GetAttackMMin() + m_StateStep[1].GetAttackMMin();
|
||
m_nAttackM[1] = m_StateStep[0].GetAttackMMax() + m_StateStep[1].GetAttackMMax();
|
||
|
||
#ifndef PRE_ADD_BUFF_STATE_LIMIT
|
||
// #31367 <20>̽<EFBFBD> <20><><EFBFBD><EFBFBD>. <20><><EFBFBD>ݷ<EFBFBD> <20>ּҰ<D6BC><D2B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3>.
|
||
float fAttackPowerClampLowestRatio = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::AttackPowerClampLowestRatio );
|
||
int nAttackPowerLowest = int((float)m_StateStep[0].GetAttackMMin() * fAttackPowerClampLowestRatio);
|
||
if( m_nAttackM[ 0 ] < nAttackPowerLowest )
|
||
{
|
||
m_nAttackM[ 0 ] = nAttackPowerLowest;
|
||
m_nAttackM[ 1 ] = int((float)m_StateStep[0].GetAttackMMax() * fAttackPowerClampLowestRatio);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void CDnPlayerState::CalcDefenseP( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetDefenseP( (int)( m_nStamina * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::PhysicalDefense ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetDefenseP() );
|
||
if( nAddValue <= 0 ) nAddValue = 1;
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetDefensePRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetDefenseP( nTemp );
|
||
OnCalcEquipStep( ST_DefenseP, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetDefenseP() );
|
||
nBuffValue = m_StateStep[0].GetDefenseP() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetDefensePRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetDefenseP( nBuffValue - m_StateStep[0].GetDefenseP() );
|
||
|
||
m_StateStep[0].SetDefenseP( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetDefenseP(), fRatioValue, GetDefensePRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetDefenseP() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetDefenseP( nTemp );
|
||
}
|
||
|
||
m_nDefenseP = m_StateStep[0].GetDefenseP() + m_StateStep[1].GetDefenseP();
|
||
}
|
||
|
||
void CDnPlayerState::CalcDefenseM( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetDefenseM( (int)( m_nIntelligence * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::MagicDefense ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetDefenseM() );
|
||
if( nAddValue <= 0 ) nAddValue = 1;
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetDefenseMRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetDefenseM( nTemp );
|
||
OnCalcEquipStep( ST_DefenseM, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetDefenseM() );
|
||
nBuffValue = m_StateStep[0].GetDefenseM() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetDefenseMRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetDefenseM( nBuffValue - m_StateStep[0].GetDefenseM() );
|
||
|
||
m_StateStep[0].SetDefenseM( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetDefenseM(), fRatioValue, GetDefenseMRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetDefenseM() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetDefenseM( nTemp );
|
||
}
|
||
|
||
m_nDefenseM = m_StateStep[0].GetDefenseM() + m_StateStep[1].GetDefenseM();
|
||
}
|
||
|
||
void CDnPlayerState::CalcHP( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList, bool bRevisionCurrentHP )
|
||
{
|
||
float fRatioValue;
|
||
INT64 nAddValue;
|
||
INT64 nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetMaxHP( (INT64)( m_nStamina * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::HP ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetMaxHP() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetMaxHPRatio() );
|
||
nTemp += (INT64)fRatioValue;
|
||
|
||
m_StateStep[0].SetMaxHP( nTemp );
|
||
OnCalcEquipStep( ST_HP, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
INT64 nBuffAddValue;
|
||
INT64 nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetMaxHP() );
|
||
nBuffValue = m_StateStep[0].GetMaxHP() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetMaxHPRatio() );
|
||
nBuffValue += (INT64)fBuffRatioValue;
|
||
|
||
m_BuffState.SetMaxHP( nBuffValue - m_StateStep[0].GetMaxHP() );
|
||
|
||
m_StateStep[0].SetMaxHP( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetMaxHP(), fRatioValue, GetMaxHPRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetMaxHP() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetMaxHP( nTemp );
|
||
}
|
||
|
||
m_nMaxHP = m_StateStep[0].GetMaxHP() + m_StateStep[1].GetMaxHP();
|
||
|
||
#if defined(PRE_ADD_MISSION_COUPON)
|
||
if( bRevisionCurrentHP && m_nHP > m_nMaxHP ) SetHP(m_nMaxHP);
|
||
#else
|
||
if( bRevisionCurrentHP && m_nHP > m_nMaxHP ) m_nHP = m_nMaxHP;
|
||
#endif
|
||
}
|
||
|
||
void CDnPlayerState::CalcSP(RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList, bool bRevisionCurrentSP)
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if (Extent & RefreshBase) {
|
||
m_BaseState.SetMaxSP((int)(m_nIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::SP)));
|
||
}
|
||
|
||
if (Extent & RefreshEquip) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE(pVecAbsoluteList[0], nAddValue, GetMaxSP());
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO(pVecRatioList[0], nTemp, fRatioValue, GetMaxSPRatio());
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetMaxSP(nTemp);
|
||
OnCalcEquipStep(ST_SP, &m_StateStep[0]);
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetMaxSP() );
|
||
nBuffValue = m_StateStep[0].GetMaxSP() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetMaxSPRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetMaxSP( nBuffValue - m_StateStep[0].GetMaxSP() );
|
||
|
||
m_StateStep[0].SetMaxSP( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetMaxSP(), fRatioValue, GetMaxSPRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetMaxSP() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetMaxSP( nTemp );
|
||
}
|
||
m_nMaxSP = m_StateStep[0].GetMaxSP() + m_StateStep[1].GetMaxSP();
|
||
|
||
#if defined(PRE_ADD_MISSION_COUPON)
|
||
if( bRevisionCurrentSP && m_nSP > m_nMaxSP ) SetSP(m_nMaxSP);
|
||
#else
|
||
if( bRevisionCurrentSP && m_nSP > m_nMaxSP ) m_nSP = m_nMaxSP;
|
||
#endif
|
||
}
|
||
|
||
void CDnPlayerState::CalcMoveSpeed( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
float fValue1 = CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::MoveSpeed );
|
||
m_BaseState.SetMoveSpeed( (int)fValue1 );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
float fValue1 = CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::MoveSpeed );
|
||
float fValue2 = CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::MoveSpeedRevision );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetMoveSpeed() );
|
||
nTemp = (int)( fValue1 * ( 2.f / ( 1.f + exp( -1 * ( ( nAddValue - fValue1 ) / fValue2 ) ) ) ) );
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetMoveSpeedRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetMoveSpeed( nTemp );
|
||
OnCalcEquipStep( ST_MoveSpeed, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetMoveSpeed() );
|
||
nBuffValue = m_StateStep[0].GetMoveSpeed() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetMoveSpeedRatio() );
|
||
|
||
#ifdef PRE_ADD_SLOW_DEBUFF_LIMIT
|
||
#ifdef _GAMESERVER
|
||
CDNGameRoom* pRoom = ((CDnPlayerActor*)m_pActor)->GetGameRoom();
|
||
if( pRoom && pRoom->bIsPvPRoom() )
|
||
#else // _GAMESERVER
|
||
CDnGameTask* pGameTask = (CDnGameTask*)CTaskManager::GetInstance().GetTask( "GameTask" );
|
||
if( pGameTask && pGameTask->GetGameTaskType() == GameTaskType::PvP )
|
||
#endif // _GAMESERVER
|
||
{
|
||
MODIFY_STATE_VALUE_LIMIT_RATIO_INTEGER( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetMoveSpeedRatio()
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::MoveSpeedRatio_Limit_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::MoveSpeedRatio_Limit_Max ) );
|
||
}
|
||
#endif // PRE_ADD_SLOW_DEBUFF_LIMIT
|
||
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
m_BuffState.SetMoveSpeed( nBuffValue - m_StateStep[0].GetMoveSpeed() );
|
||
m_StateStep[0].SetMoveSpeed( nBuffValue );
|
||
#endif
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetMoveSpeed(), fRatioValue, GetMoveSpeedRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetMoveSpeed() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetMoveSpeed( nTemp );
|
||
}
|
||
|
||
m_nMoveSpeed = m_StateStep[0].GetMoveSpeed() + m_StateStep[1].GetMoveSpeed();
|
||
}
|
||
|
||
void CDnPlayerState::CalcDownDelay( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fAddValue;
|
||
float fTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], fAddValue, GetDownDelayProb() );
|
||
fTemp = fAddValue;
|
||
CALC_STATE_LIMIT( fTemp, 0.f, 1.f );
|
||
m_StateStep[0].SetDownDelayProb( fTemp );
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], fAddValue, GetDownDelayProb() );
|
||
fTemp = fAddValue;
|
||
CALC_STATE_LIMIT( fTemp, 0.f, 1.f );
|
||
|
||
m_StateStep[1].SetDownDelayProb( fTemp );
|
||
}
|
||
|
||
m_fDownDelayProb = m_StateStep[0].GetDownDelayProb() + m_StateStep[1].GetDownDelayProb();
|
||
m_fDownDelayProb *= CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::DownDelay );
|
||
}
|
||
|
||
void CDnPlayerState::CalcStiff( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStiff( (int)( m_nStrength * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::Stiff ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStiff() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStiffRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStiff( nTemp );
|
||
OnCalcEquipStep( ST_Stiff, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStiff() );
|
||
nBuffValue = m_StateStep[0].GetStiff() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStiffRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStiff( nBuffValue - m_StateStep[0].GetStiff() );
|
||
|
||
m_StateStep[0].SetStiff( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStiff(), fRatioValue, GetStiffRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStiff() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStiff( nTemp );
|
||
|
||
}
|
||
m_nStiff = m_StateStep[0].GetStiff() + m_StateStep[1].GetStiff();
|
||
}
|
||
|
||
void CDnPlayerState::CalcStiffResistance( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStiffResistance( (int)( m_nStrength * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::StiffResistance ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStiffResistance() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStiffResistanceRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStiffResistance( nTemp );
|
||
OnCalcEquipStep( ST_StiffResistance, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStiffResistance() );
|
||
nBuffValue = m_StateStep[0].GetStiffResistance() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStiffResistanceRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStiffResistance( nBuffValue - m_StateStep[0].GetStiffResistance() );
|
||
|
||
m_StateStep[0].SetStiffResistance( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStiffResistance(), fRatioValue, GetStiffResistanceRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStiffResistance() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStiffResistance( nTemp );
|
||
|
||
}
|
||
m_nStiffResistance = m_StateStep[0].GetStiffResistance() + m_StateStep[1].GetStiffResistance();
|
||
}
|
||
|
||
void CDnPlayerState::CalcCritical( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetCritical( (int)( m_nAgility * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::Critical ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetCritical() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetCriticalRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetCritical( nTemp );
|
||
OnCalcEquipStep( ST_Critical, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetCritical() );
|
||
nBuffValue = m_StateStep[0].GetCritical() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetCriticalRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetCritical( nBuffValue - m_StateStep[0].GetCritical() );
|
||
|
||
m_StateStep[0].SetCritical( nBuffValue );
|
||
#endif
|
||
|
||
// #32220 <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>ȿ<EFBFBD><C8BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>. /////////////////////////
|
||
std::vector<CDnState *> pVecAbsoluteListBeforePost;
|
||
std::vector<CDnState *> pVecRatioListBeforePost;
|
||
|
||
GetStateList( BeforePostStateEffectList, ValueTypeAbsolute, pVecAbsoluteListBeforePost );
|
||
GetStateList( BeforePostStateEffectList, ValueTypeRatio, pVecRatioListBeforePost );
|
||
|
||
if( false == pVecAbsoluteListBeforePost.empty() || false == pVecRatioListBeforePost.empty() )
|
||
{
|
||
CALC_STATE_VALUE_RATIO( pVecRatioListBeforePost, m_StateStep[0].GetAttackPMin(), fRatioValue, GetCriticalRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteListBeforePost, nAddValue, GetCritical() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[0].SetCritical( m_StateStep[0].GetCritical() + nTemp );
|
||
}
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetCritical(), fRatioValue, GetCriticalRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetCritical() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetCritical( nTemp );
|
||
|
||
}
|
||
m_nCritical = m_StateStep[0].GetCritical() + m_StateStep[1].GetCritical();
|
||
}
|
||
|
||
void CDnPlayerState::CalcCriticalResistance( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetCriticalResistance( (int)( m_nAgility * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::CriticalResistance ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetCriticalResistance() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetCriticalResistanceRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetCriticalResistance( nTemp );
|
||
OnCalcEquipStep( ST_CriticalResistance, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetCriticalResistance() );
|
||
nBuffValue = m_StateStep[0].GetCriticalResistance() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetCriticalResistanceRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetCriticalResistance( nBuffValue - m_StateStep[0].GetCriticalResistance() );
|
||
|
||
m_StateStep[0].SetCriticalResistance( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetCriticalResistance(), fRatioValue, GetCriticalResistanceRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetCriticalResistance() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetCriticalResistance( nTemp );
|
||
|
||
}
|
||
m_nCriticalResistance = m_StateStep[0].GetCriticalResistance() + m_StateStep[1].GetCriticalResistance();
|
||
}
|
||
|
||
void CDnPlayerState::CalcStun( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStun( (int)( m_nStrength * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::Stun ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStun() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStunRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStun( nTemp );
|
||
OnCalcEquipStep( ST_Stun, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStun() );
|
||
nBuffValue = m_StateStep[0].GetStun() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStunRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStun( nBuffValue - m_StateStep[0].GetStun() );
|
||
|
||
m_StateStep[0].SetStun( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStun(), fRatioValue, GetStunRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStun() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStun( nTemp );
|
||
|
||
}
|
||
m_nStun = m_StateStep[0].GetStun() + m_StateStep[1].GetStun();
|
||
}
|
||
|
||
void CDnPlayerState::CalcStunResistance( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
int nAddValue;
|
||
float fRatioValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
m_BaseState.SetStunResistance( (int)( m_nStamina * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::StunResistance ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetStunResistance() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetStunResistanceRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetStunResistance( nTemp );
|
||
OnCalcEquipStep( ST_StunResistance, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetStunResistance() );
|
||
nBuffValue = m_StateStep[0].GetStunResistance() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetStunResistanceRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetStunResistance( nBuffValue - m_StateStep[0].GetStunResistance() );
|
||
|
||
m_StateStep[0].SetStunResistance( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetStunResistance(), fRatioValue, GetStunResistanceRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetStunResistance() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetStunResistance( nTemp );
|
||
|
||
}
|
||
m_nStunResistance = m_StateStep[0].GetStunResistance() + m_StateStep[1].GetStunResistance();
|
||
}
|
||
|
||
void CDnPlayerState::CalcElementAttack( ElementEnum Type, RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fAddValue;
|
||
float fTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], fAddValue, GetElementAttack( Type ) );
|
||
fTemp = fAddValue * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::ElementAttack );
|
||
|
||
m_StateStep[0].SetElementAttack( Type , fTemp );
|
||
#ifdef PRE_FIX_ELEMENT_REGULATION
|
||
OnCalcEquipStep_ElementAttack( Type, &m_StateStep[0] );
|
||
#else
|
||
OnCalcEquipStep( ST_ElementAttack, &m_StateStep[0] );
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffAddValue;
|
||
float fBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , fBuffAddValue , GetElementAttack(Type) );
|
||
fBuffValue = m_StateStep[0].GetElementAttack(Type) + fBuffAddValue;
|
||
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_ABSOLUTE( pVecAbsoluteBuffStateList , fBuffValue , GetElementAttack(Type)
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Attack_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Attack_Max ) );
|
||
#endif
|
||
|
||
m_BuffState.SetElementAttack( Type , fBuffValue - m_StateStep[0].GetElementAttack( Type ) );
|
||
|
||
m_StateStep[0].SetElementAttack( Type , fBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], fAddValue, GetElementAttack( Type ) );
|
||
fTemp = fAddValue;
|
||
m_StateStep[1].SetElementAttack( Type, fTemp );
|
||
|
||
}
|
||
|
||
m_fElementAttack[Type] = m_StateStep[0].GetElementAttack( Type ) + m_StateStep[1].GetElementAttack( Type );
|
||
}
|
||
|
||
void CDnPlayerState::CalcElementDefense( ElementEnum Type, RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fAddValue;
|
||
float fTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], fAddValue, GetElementDefense( Type ) );
|
||
fTemp = fAddValue * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::ElementDefense );
|
||
|
||
m_StateStep[0].SetElementDefense( Type , fTemp );
|
||
|
||
#ifdef PRE_FIX_ELEMENT_REGULATION
|
||
OnCalcEquipStep_ElementDefense( Type, &m_StateStep[0] );
|
||
#else
|
||
OnCalcEquipStep( ST_ElementDefense, &m_StateStep[0] );
|
||
#endif
|
||
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffAddValue;
|
||
float fBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , fBuffAddValue , GetElementDefense(Type) );
|
||
fBuffValue = m_StateStep[0].GetElementDefense(Type) + fBuffAddValue;
|
||
|
||
#ifdef PRE_ADD_BUFF_STATE_LIMIT
|
||
MODIFY_STATE_VALUE_LIMIT_ABSOLUTE( pVecAbsoluteBuffStateList , fBuffValue , GetElementDefense(Type)
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Min )
|
||
, CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Max ) );
|
||
#endif
|
||
|
||
m_BuffState.SetElementDefense( Type , fBuffValue - m_StateStep[0].GetElementDefense( Type ) );
|
||
|
||
#ifdef PRE_ADD_ELEMENT_DEFENSE_LIMIT
|
||
if( fBuffValue > CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Limit ) )
|
||
{
|
||
fBuffValue = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Limit );
|
||
}
|
||
#endif
|
||
|
||
m_StateStep[0].SetElementDefense( Type , fBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], fAddValue, GetElementDefense( Type ) );
|
||
fTemp = fAddValue;
|
||
m_StateStep[1].SetElementDefense( Type, fTemp );
|
||
}
|
||
|
||
m_fElementDefense[Type] = m_StateStep[0].GetElementDefense( Type ) + m_StateStep[1].GetElementDefense( Type );
|
||
|
||
#ifdef PRE_ADD_ELEMENT_DEFENSE_LIMIT
|
||
if( m_fElementDefense[Type] > CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Limit ) )
|
||
{
|
||
m_fElementDefense[Type] = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Defense_Limit );
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
void CDnPlayerState::CalcRecoverySP( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase )
|
||
{
|
||
m_BaseState.SetRecoverySP( (int)( GetLevelWeightValue() * CPlayerWeightTable::GetInstance().GetValue( m_nActorTableID, CPlayerWeightTable::RecoverySP ) ) );
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetRecoverySP() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetRecoverySPRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetRecoverySP( nTemp );
|
||
OnCalcEquipStep( ST_RecoverySP, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetRecoverySP() );
|
||
nBuffValue = m_StateStep[0].GetRecoverySP() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetRecoverySPRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetRecoverySP( nBuffValue - m_StateStep[0].GetRecoverySP() );
|
||
|
||
m_StateStep[0].SetRecoverySP( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetRecoverySP(), fRatioValue, GetRecoverySPRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetRecoverySP() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetRecoverySP( nTemp );
|
||
}
|
||
|
||
m_nRecoverySP = m_StateStep[0].GetRecoverySP() + m_StateStep[1].GetRecoverySP();
|
||
}
|
||
|
||
void CDnPlayerState::CalcSuperAmmor( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetSuperAmmor() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetSuperAmmorRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetSuperAmmor( nTemp );
|
||
OnCalcEquipStep( ST_SuperAmmor, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetSuperAmmor() );
|
||
nBuffValue = m_StateStep[0].GetSuperAmmor() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetSuperAmmorRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetSuperAmmor( nBuffValue - m_StateStep[0].GetSuperAmmor() );
|
||
|
||
m_StateStep[0].SetSuperAmmor( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetSuperAmmor(), fRatioValue, GetSuperAmmorRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetSuperAmmor() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetSuperAmmor( nTemp );
|
||
}
|
||
|
||
m_nSuperAmmor = m_StateStep[0].GetSuperAmmor() + m_StateStep[1].GetSuperAmmor();
|
||
}
|
||
|
||
void CDnPlayerState::CalcFinalDamage( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp = 0;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetFinalDamage() );
|
||
nTemp = nAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetFinalDamageRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetFinalDamage( nTemp );
|
||
OnCalcEquipStep( ST_FinalDamage, &m_StateStep[0] );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetFinalDamage() );
|
||
nBuffValue = m_StateStep[0].GetFinalDamage() + nBuffAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetFinalDamageRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetFinalDamage( nBuffValue - m_StateStep[0].GetFinalDamage() );
|
||
m_StateStep[0].SetFinalDamage( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill )
|
||
{
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetFinalDamageRatio(), fRatioValue, GetFinalDamageRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetFinalDamage() );
|
||
nTemp = nAddValue;
|
||
|
||
m_StateStep[1].SetFinalDamage( nTemp );
|
||
}
|
||
|
||
m_nFinalDamage = m_StateStep[0].GetFinalDamage() + m_StateStep[1].GetFinalDamage();
|
||
}
|
||
|
||
void CDnPlayerState::CalcSpirit( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetSpirit() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], nTemp, fRatioValue, GetSpiritRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetSpirit( nTemp );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetSpirit() );
|
||
nBuffValue = m_StateStep[0].GetSpirit() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetSpiritRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetSpirit( nBuffValue - m_StateStep[0].GetSpirit() );
|
||
|
||
m_StateStep[0].SetSpirit( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetSpirit(), fRatioValue, GetSpiritRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetSpirit() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetSpirit( nTemp );
|
||
}
|
||
|
||
m_nSpirit = m_StateStep[0].GetSpirit() + m_StateStep[1].GetSpirit();
|
||
}
|
||
|
||
void CDnPlayerState::CalcSafeZoneMoveSpeed( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fRatioValue;
|
||
int nAddValue;
|
||
int nTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], nAddValue, GetSafeZoneMoveSpeed() );
|
||
nTemp = nAddValue;
|
||
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[0], (nTemp + m_nMoveSpeed), fRatioValue, GetSafeZoneMoveSpeedRatio() );
|
||
nTemp += (int)fRatioValue;
|
||
|
||
m_StateStep[0].SetSafeZoneMoveSpeed( nTemp );
|
||
|
||
#ifdef PRE_ADD_SKILLBUF_RENEW
|
||
float fBuffRatioValue;
|
||
int nBuffAddValue;
|
||
int nBuffValue;
|
||
|
||
std::vector<CDnState*> pVecAbsoluteBuffStateList;
|
||
std::vector<CDnState*> pVecRatioBuffStateList;
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeAbsolute, pVecAbsoluteBuffStateList );
|
||
GetBuffStateList( CDnState::ValueType::ValueTypeRatio, pVecRatioBuffStateList );
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteBuffStateList , nBuffAddValue , GetSafeZoneMoveSpeed() );
|
||
nBuffValue = m_StateStep[0].GetSafeZoneMoveSpeed() + nBuffAddValue;
|
||
CALC_STATE_VALUE_RATIO( pVecRatioBuffStateList, nBuffValue, fBuffRatioValue, GetSafeZoneMoveSpeedRatio() );
|
||
nBuffValue += (int)fBuffRatioValue;
|
||
|
||
m_BuffState.SetSafeZoneMoveSpeed( nBuffValue - m_StateStep[0].GetSafeZoneMoveSpeed() );
|
||
|
||
m_StateStep[0].SetSafeZoneMoveSpeed( nBuffValue );
|
||
#endif
|
||
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_RATIO( pVecRatioList[1], m_StateStep[0].GetSafeZoneMoveSpeed(), fRatioValue, GetSafeZoneMoveSpeedRatio() );
|
||
nTemp = (int)fRatioValue;
|
||
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], nAddValue, GetSafeZoneMoveSpeed() );
|
||
nTemp += nAddValue;
|
||
|
||
m_StateStep[1].SetSafeZoneMoveSpeed( nTemp );
|
||
}
|
||
|
||
m_nSafeZoneMoveSpeed = m_StateStep[0].GetSafeZoneMoveSpeed() + m_StateStep[1].GetSafeZoneMoveSpeed();
|
||
}
|
||
|
||
void CDnPlayerState::CalcAddExp( RefreshStateExtentEnum Extent, std::vector<CDnState *> *pVecAbsoluteList, std::vector<CDnState *> *pVecRatioList )
|
||
{
|
||
float fAddValue;
|
||
float fTemp;
|
||
|
||
if( Extent & RefreshBase ) {
|
||
}
|
||
|
||
if( Extent & RefreshEquip ) {
|
||
//<2F><><EFBFBD><EFBFBD>
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[0], fAddValue, GetAddExp() );
|
||
fTemp = fAddValue;
|
||
|
||
m_StateStep[0].SetAddExp( fTemp );
|
||
}
|
||
|
||
if( Extent & RefreshSkill ) {
|
||
// PostStateEffect
|
||
CALC_STATE_VALUE_ABSOLUTE( pVecAbsoluteList[1], fAddValue, GetAddExp() );
|
||
fTemp = fAddValue;
|
||
|
||
m_StateStep[1].SetAddExp( fTemp );
|
||
}
|
||
|
||
m_fAddExp = m_StateStep[0].GetAddExp() + m_StateStep[1].GetAddExp();
|
||
}
|
||
|
||
void CDnPlayerState::OnCalcEquipStep_ElementAttack( ElementEnum eElementType , CDnState *pState )
|
||
{
|
||
char cRegulation = GetUseRegulation();
|
||
if( cRegulation == 0 ) return;
|
||
float fDeclarationRatio = 0.f;
|
||
float fRevision = 0.f;
|
||
|
||
#if defined(PRE_FIX_ELEMENT_REGULATION_RENEW)
|
||
float fCurrentElement = pState->GetElementAttack( eElementType );
|
||
float fBasisValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::ElementAttackRevision );
|
||
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::ElementAttackRevision );
|
||
fDeclarationRatio = pow( fCurrentElement / fBasisValue , fRevision );
|
||
pState->SetElementAttack( eElementType , CEqualLevelTable::GetInstance().GetValueFloat( cRegulation, GetJobClassID(), CEqualLevelTable::ElementAttackRevision ) * fDeclarationRatio );
|
||
#else
|
||
float fCurrentElement = pState->GetElementAttack( eElementType );
|
||
float fExpotentLimit = CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_Expotent_Limit );
|
||
float fBasisValue = (float)CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_EqualBasis );
|
||
|
||
if( fCurrentElement <= fExpotentLimit)
|
||
{
|
||
pState->SetElementAttack( eElementType , fCurrentElement );
|
||
}
|
||
else
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::ElementAttackRevision );
|
||
fDeclarationRatio = pow( fCurrentElement / fBasisValue , fRevision );
|
||
pState->SetElementAttack( eElementType , (float)CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::Element_EqualLevel ) * fDeclarationRatio );
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
void CDnPlayerState::OnCalcEquipStep_ElementDefense( ElementEnum eElementType , CDnState *pState )
|
||
{
|
||
char cRegulation = GetUseRegulation();
|
||
if( cRegulation == 0 ) return;
|
||
float fDeclarationRatio = 0.f;
|
||
float fRevision = 0.f;
|
||
|
||
#ifdef PRE_FIX_ELEMENT_REGULATION_RENEW // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20>۵<EFBFBD><DBB5>ϵ<EFBFBD><CFB5><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
float fCurrentElement = pState->GetElementDefense( eElementType );
|
||
float fBasisValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::ElementDefenseRevision );
|
||
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::ElementDefenseRevision );
|
||
fDeclarationRatio = pow( fCurrentElement / fBasisValue , fRevision );
|
||
pState->SetElementDefense( eElementType , CEqualLevelTable::GetInstance().GetValueFloat( cRegulation, GetJobClassID(), CEqualLevelTable::ElementDefenseRevision ) * fDeclarationRatio );
|
||
#endif
|
||
|
||
}
|
||
|
||
void CDnPlayerState::OnCalcEquipStep( StateTypeEnum Type, CDnState *pState )
|
||
{
|
||
char cRegulation = GetUseRegulation();
|
||
if( cRegulation == 0 ) return;
|
||
float fDeclarationRatio = 0.f;
|
||
float fRevision = 0.f;
|
||
|
||
switch( Type ) {
|
||
#if defined(PRE_ADD_REVEAL_REGULATION_VALUE) || defined(_GAMESERVER)
|
||
case ST_AttackP:
|
||
{
|
||
|
||
#ifdef PRE_FIX_MODIFY_AVERAGE_DAMAGE_REGULATION
|
||
float fMinRevisionSquare = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::PhysicalAttackMinRevision );
|
||
float fMaxRevisionSquare = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::PhysicalAttackMaxRevision );
|
||
fRevision = (fMinRevisionSquare + fMaxRevisionSquare) / 2; // <20><EFBFBD><F1B1B3B4><EFBFBD><EFBFBD>̵<EFBFBD> Square <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
float fMinRevisionValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::PhysicalAttackMinRevision );
|
||
float fMaxRevisionValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::PhysicalAttackMaxRevision );
|
||
float fTotalRevisionValue = fMinRevisionValue + fMaxRevisionValue; // <20><EFBFBD><F1B1B3B4><EFBFBD><EFBFBD>̵<EFBFBD> Value <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
float fTotalAttackValue = (float)pState->GetAttackPMin() + (float)pState->GetAttackPMax();
|
||
fDeclarationRatio = pow( ( fTotalAttackValue / fTotalRevisionValue ) , fRevision );
|
||
|
||
float fBasisValueMin = (float)CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::PhysicalAttackMinRevision );
|
||
float fBaseisValueMax = (float)CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::PhysicalAttackMaxRevision );
|
||
|
||
float fResultTotalValue = (fBasisValueMin + fBaseisValueMax) * fDeclarationRatio;
|
||
float fResultMinValue = fResultTotalValue * ( (float)pState->GetAttackPMin() / (float)(pState->GetAttackPMin() + pState->GetAttackPMax()) );
|
||
float fResultMaxValue = fResultTotalValue * ( (float)pState->GetAttackPMax() / (float)(pState->GetAttackPMin() + pState->GetAttackPMax()) );
|
||
|
||
pState->SetAttackPMin( (int)fResultMinValue );
|
||
pState->SetAttackPMax( (int)fResultMaxValue );
|
||
#else
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::PhysicalAttackMinRevision );
|
||
fDeclarationRatio = pow( pState->GetAttackPMin() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::PhysicalAttackMinRevision ), fRevision );
|
||
pState->SetAttackPMin( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::PhysicalAttackMinRevision ) * fDeclarationRatio ) );
|
||
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::PhysicalAttackMaxRevision );
|
||
fDeclarationRatio = pow( pState->GetAttackPMax() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::PhysicalAttackMaxRevision ), fRevision );
|
||
pState->SetAttackPMax( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::PhysicalAttackMaxRevision ) * fDeclarationRatio ) );
|
||
#endif
|
||
|
||
}
|
||
break;
|
||
case ST_AttackM:
|
||
{
|
||
#ifdef PRE_FIX_MODIFY_AVERAGE_DAMAGE_REGULATION
|
||
float fMinRevisionSquare = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MagicAttackMinRevision );
|
||
float fMaxRevisionSquare = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MagicAttackMaxRevision );
|
||
fRevision = (fMinRevisionSquare + fMaxRevisionSquare) / 2; // <20><EFBFBD><F1B1B3B4><EFBFBD><EFBFBD>̵<EFBFBD> Square <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
float fMinRevisionValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MagicAttackMinRevision );
|
||
float fMaxRevisionValue = (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MagicAttackMaxRevision );
|
||
fDeclarationRatio = fMinRevisionValue + fMaxRevisionValue; // <20><EFBFBD><F1B1B3B4><EFBFBD><EFBFBD>̵<EFBFBD> Value <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
float fTotalAttackValue = (float)pState->GetAttackMMin() + (float)pState->GetAttackMMax();
|
||
float fResultTotalRatio = pow( (fTotalAttackValue / fDeclarationRatio ) , fRevision );
|
||
|
||
float fBasisValueMin = (float)CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MagicAttackMinRevision );
|
||
float fBaseisValueMax = (float)CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MagicAttackMaxRevision );
|
||
|
||
float fResultTotalValue = (fBasisValueMin + fBaseisValueMax) * fResultTotalRatio;
|
||
float fResultMinValue = fResultTotalValue * ( (float)pState->GetAttackMMin() / (float)(pState->GetAttackMMin() + pState->GetAttackMMax()) );
|
||
float fResultMaxValue = fResultTotalValue * ( (float)pState->GetAttackMMax() / (float)(pState->GetAttackMMin() + pState->GetAttackMMax()) );
|
||
|
||
pState->SetAttackMMin( (int)fResultMinValue );
|
||
pState->SetAttackMMax( (int)fResultMaxValue );
|
||
#else
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MagicAttackMinRevision );
|
||
fDeclarationRatio = pow( pState->GetAttackMMin() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MagicAttackMinRevision ), fRevision );
|
||
pState->SetAttackMMin( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MagicAttackMinRevision ) * fDeclarationRatio ) );
|
||
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MagicAttackMaxRevision );
|
||
fDeclarationRatio = pow( pState->GetAttackMMax() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MagicAttackMaxRevision ), fRevision );
|
||
pState->SetAttackMMax( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MagicAttackMaxRevision ) * fDeclarationRatio ) );
|
||
#endif
|
||
|
||
}
|
||
break;
|
||
case ST_DefenseP:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::PhysicalDefenseRevision );
|
||
fDeclarationRatio = pow( pState->GetDefenseP() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::PhysicalDefenseRevision ), fRevision );
|
||
pState->SetDefenseP( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::PhysicalDefenseRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_DefenseM:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MagicDefenseRevision );
|
||
fDeclarationRatio = pow( pState->GetDefenseM() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MagicDefenseRevision ), fRevision );
|
||
pState->SetDefenseM( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MagicDefenseRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Stiff:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StiffRevision );
|
||
fDeclarationRatio = pow( pState->GetStiff() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StiffRevision ), fRevision );
|
||
pState->SetStiff( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StiffRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_StiffResistance:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StiffResistanceRevision );
|
||
fDeclarationRatio = pow( pState->GetStiffResistance() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StiffResistanceRevision ), fRevision );
|
||
pState->SetStiffResistance( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StiffResistanceRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Critical:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::CriticalRevision );
|
||
fDeclarationRatio = pow( pState->GetCritical() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::CriticalRevision ), fRevision );
|
||
pState->SetCritical( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::CriticalRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_CriticalResistance:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::CriticalResistanceRevision );
|
||
fDeclarationRatio = pow( pState->GetCriticalResistance() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::CriticalResistanceRevision ), fRevision );
|
||
pState->SetCriticalResistance( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::CriticalResistanceRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Stun:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StunRevision );
|
||
fDeclarationRatio = pow( pState->GetStun() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StunRevision ), fRevision );
|
||
pState->SetStun( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StunRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_StunResistance:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StunResistanceRevision );
|
||
fDeclarationRatio = pow( pState->GetStunResistance() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StunResistanceRevision ), fRevision );
|
||
pState->SetStunResistance( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StunResistanceRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_SuperAmmor:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::SuperAmmorRevision );
|
||
fDeclarationRatio = pow( pState->GetSuperAmmor() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::SuperAmmorRevision ), fRevision );
|
||
pState->SetSuperAmmor( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::SuperAmmorRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_RecoverySP:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::RecoverySPRevision );
|
||
fDeclarationRatio = pow( pState->GetRecoverySP() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::RecoverySPRevision ), fRevision );
|
||
pState->SetRecoverySP( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::RecoverySPRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_ElementAttack:
|
||
{
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߳<EFBFBD><DFB3><EFBFBD><E2B6A7><EFBFBD><EFBFBD> Ex> <20><> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> Refresh <20><><EFBFBD>ֱ<D6B1><E2B6A7>
|
||
// OnCalcEqupStep_Element<6E><74> <20><> <20>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD> <20>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ؾ<EFBFBD><D8BE>Ѵ<EFBFBD>.
|
||
#ifndef PRE_FIX_ELEMENT_REGULATION
|
||
float fDeclaration = CEqualLevelTable::GetInstance().GetValueFloat( cRegulation, GetJobClassID(), CEqualLevelTable::ElementAttackRevision );
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::ElementAttackRevision );
|
||
|
||
for( int i=0; i<ElementEnum_Amount; i++ )
|
||
{
|
||
pState->SetElementAttack( (ElementEnum)i, fDeclaration * pow( pState->GetElementAttack( (ElementEnum)i ), fRevision ) );
|
||
}
|
||
#endif
|
||
}
|
||
break;
|
||
case ST_ElementDefense:
|
||
{
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<CFB1><E2B6A7><EFBFBD><EFBFBD> Ex> <20><> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> Refresh <20><><EFBFBD>ֱ<D6B1><E2B6A7>
|
||
// OnCalcEqupStep_Element<6E><74> <20><> <20>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD> <20>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ؾ<EFBFBD><D8BE>Ѵ<EFBFBD>.
|
||
// <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȹ<EFBFBD>ʿ<EFBFBD><CABF><EFBFBD> <20>ϴ<EFBFBD><CFB4><EFBFBD> <20>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´ٰ<C2B4> <20>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӵϴ<D3B4>. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ü<EFBFBD><C3BC> <20>߸<EFBFBD><DFB8>Ǿ<EFBFBD><C7BE>־ <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD>ü<EFBFBD><C3BC> <20><><EFBFBD>߳<EFBFBD><DFB3><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD> <20>ȵ˴ϴ<CBB4>.
|
||
#ifndef PRE_FIX_ELEMENT_REGULATION
|
||
float fDeclaration = CEqualLevelTable::GetInstance().GetValueFloat( cRegulation, GetJobClassID(), CEqualLevelTable::ElementDefenseRevision );
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::ElementDefenseRevision );
|
||
|
||
for( int i=0; i<ElementEnum_Amount; i++ ) {
|
||
pState->SetElementDefense( (ElementEnum)i, fDeclaration * pow( pState->GetElementDefense( (ElementEnum)i ), fRevision ) );
|
||
}
|
||
#endif
|
||
}
|
||
break;
|
||
case ST_FinalDamage:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::FinalDamageRevision );
|
||
fDeclarationRatio = pow( pState->GetFinalDamage() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::FinalDamageRevision ), fRevision );
|
||
pState->SetFinalDamage( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::FinalDamageRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
#endif // #if defined(PRE_ADD_REVEAL_REGULATION_VALUE) || defined(_GAMESERVER)
|
||
|
||
case ST_HP:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MaxHPRevision );
|
||
fDeclarationRatio = pow( pState->GetMaxHP() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MaxHPRevision ), fRevision );
|
||
pState->SetMaxHP( (INT64)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MaxHPRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_SP:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MaxSPRevision );
|
||
fDeclarationRatio = pow( pState->GetMaxSP() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MaxSPRevision ), fRevision );
|
||
pState->SetMaxSP( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MaxSPRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_MoveSpeed:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::MoveSpeedRevision );
|
||
fDeclarationRatio = pow( pState->GetMoveSpeed() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::MoveSpeedRevision ), fRevision );
|
||
pState->SetMoveSpeed( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::MoveSpeedRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
#ifdef PRE_ADD_BASE_STAT_REGULATION
|
||
case ST_Strength:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StrengthRevision );
|
||
fDeclarationRatio = pow( pState->GetStrength() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StrengthRevision ), fRevision );
|
||
pState->SetStrength( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StrengthRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Agility:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::AgilityRevision );
|
||
fDeclarationRatio = pow( pState->GetAgility() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::AgilityRevision ), fRevision );
|
||
pState->SetAgility( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::AgilityRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Intelligence:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::IntelligenceRevision );
|
||
fDeclarationRatio = pow( pState->GetIntelligence() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::IntelligenceRevision ), fRevision );
|
||
pState->SetIntelligence( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::IntelligenceRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
case ST_Stamina:
|
||
{
|
||
fRevision = CEqualExponentTable::GetInstance().GetValue( cRegulation, CEqualExponentTable::StaminaRevision );
|
||
fDeclarationRatio = pow( pState->GetStamina() / (float)CEqualBasisTable::GetInstance().GetValue( GetJobClassID(), m_nLevel, CEqualBasisTable::StaminaRevision ), fRevision );
|
||
pState->SetStamina( (int)( CEqualLevelTable::GetInstance().GetValue( cRegulation, GetJobClassID(), CEqualLevelTable::StaminaRevision ) * fDeclarationRatio ) );
|
||
}
|
||
break;
|
||
#endif
|
||
}
|
||
}
|
||
|
||
int CDnPlayerState::GetJobClassID()
|
||
{
|
||
if( m_nVecJobHistoryList.empty() ) return 0;
|
||
return m_nVecJobHistoryList[ m_nVecJobHistoryList.size() - 1 ];
|
||
}
|
||
|
||
int CDnPlayerState::GetJobHistory( std::vector<int> &nVecResult )
|
||
{
|
||
nVecResult = m_nVecJobHistoryList;
|
||
return (int)m_nVecJobHistoryList.size();
|
||
}
|
||
|
||
void CDnPlayerState::SetJobHistory( const std::vector<int> &nVecList )
|
||
{
|
||
m_nVecJobHistoryList = nVecList;
|
||
}
|
||
|
||
void CDnPlayerState::SetJobHistory( int nValue )
|
||
{
|
||
//m_nVecJobHistoryList.clear();
|
||
vector<int>::iterator iter = find( m_nVecJobHistoryList.begin(), m_nVecJobHistoryList.end(), nValue );
|
||
_ASSERT( iter == m_nVecJobHistoryList.end() && "<EFBFBD>̹<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD>ٰ<EFBFBD> <20><><EFBFBD>ƿ<EFBFBD>. ġƮŰ <20>߸<EFBFBD><DFB8><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>." );
|
||
if( iter == m_nVecJobHistoryList.end() )
|
||
m_nVecJobHistoryList.push_back( nValue );
|
||
}
|
||
|
||
// #26902 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ѹ<EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̷<EFBFBD> <20><> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>. <20>ӽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> Ŭ<><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||
void CDnPlayerState::PopJobHistory( int nValue )
|
||
{
|
||
if( nValue == m_nVecJobHistoryList.back() )
|
||
m_nVecJobHistoryList.pop_back();
|
||
}
|
||
|
||
bool CDnPlayerState::IsPassJob( int nJobClassID )
|
||
{
|
||
for( DWORD i=0; i<m_nVecJobHistoryList.size(); i++ ) {
|
||
if( m_nVecJobHistoryList[i] == nJobClassID ) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void CDnPlayerState::OnChangeJob( int nJobID )
|
||
{
|
||
RefreshState();
|
||
}
|
||
|
||
void CDnPlayerState::SetExperience( int nValue )
|
||
{
|
||
m_nExperience = nValue;
|
||
CalcExperience();
|
||
}
|
||
|
||
void CDnPlayerState::AddExperience( int nValue, int nLogCode, INT64 biFKey )
|
||
{
|
||
#if defined(_GAMESERVER)
|
||
#ifndef _WORK
|
||
if( GetAccountLevel() < AccountLevel_Master ) {
|
||
int nLevelLimit = (int)CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::PlayerLevelLimit );
|
||
if( m_nLevel >= nLevelLimit ) return;
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
m_nExperience += nValue;
|
||
OnAddExperience( nValue, nLogCode, biFKey );
|
||
CalcExperience();
|
||
}
|
||
|
||
void CDnPlayerState::CalcExperience()
|
||
{
|
||
if( m_ActorType > ActorTypeEnum::Reserved6 ) return;
|
||
|
||
int nExperience;
|
||
int nTempLevel = 1;
|
||
int nOffset = m_nLevel - 1;
|
||
|
||
if( nOffset < 0 ) nOffset = 0;
|
||
|
||
for( int i=nOffset; i<PLAYER_MAX_LEVEL; i++ ) {
|
||
nExperience = CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), i + 1, CPlayerLevelTable::Experience );
|
||
if( m_nExperience >= nExperience ) {
|
||
m_nCurrentLevelExperience = nExperience;
|
||
nTempLevel = i + 1;
|
||
}
|
||
else {
|
||
m_nNextLevelExperience = nExperience;
|
||
break;
|
||
}
|
||
}
|
||
#if defined(_GAMESERVER)
|
||
#ifndef _WORK
|
||
if( GetAccountLevel() < AccountLevel_Master ) {
|
||
int nLevelLimit = (int)CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::PlayerLevelLimit );
|
||
if( nTempLevel >= nLevelLimit ) {
|
||
nTempLevel = nLevelLimit;
|
||
m_nExperience = CPlayerLevelTable::GetInstance().GetValue( GetJobClassID(), nLevelLimit, CPlayerLevelTable::Experience );
|
||
m_nCurrentLevelExperience = m_nExperience;
|
||
m_nNextLevelExperience = m_nExperience;
|
||
}
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
if( m_nLevel < nTempLevel ) {
|
||
int nLevelUpAmount = nTempLevel - m_nLevel;
|
||
SetLevel( nTempLevel );
|
||
OnLevelUp( nTempLevel, nLevelUpAmount );
|
||
}
|
||
|
||
}
|
||
|
||
int CDnPlayerState::GetJobToBaseClassID( int nJobID )
|
||
{
|
||
DNTableFileFormat* pSox = GetDNTable(CDnTableDB::TJOB);
|
||
if( !pSox )
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"JobTable.ext failed\r\n");
|
||
return nJobID;
|
||
}
|
||
|
||
if( !pSox->IsExistItem( nJobID ) ) return nJobID;
|
||
|
||
return pSox->GetFieldFromLablePtr( nJobID, "_BaseClass" )->GetInteger() + 1;
|
||
}
|
||
|
||
CDnState CDnPlayerState::MakeEquipState()
|
||
{
|
||
CDnState SumAbsolute;
|
||
CDnState SumRatio;
|
||
CDnState PureBaseState;
|
||
|
||
|
||
std::vector<CDnState *> pVecAbsoluteList;
|
||
std::vector<CDnState *> pVecRatioList;
|
||
|
||
// <20><><EFBFBD>⼭ <20><><EFBFBD>̽<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>ϴ<EFBFBD>.
|
||
#if defined(PRE_ADD_TALISMAN_SYSTEM)
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeAbsolute, pVecAbsoluteList );
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeRatio, pVecRatioList );
|
||
#else
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeAbsolute, pVecAbsoluteList );
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeRatio, pVecRatioList );
|
||
#endif
|
||
|
||
// <20><><EFBFBD>̽<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ʒ<EFBFBD><C6B7><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD> <20><><EFBFBD>ݿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ޱ<DEB1><E2B6A7><EFBFBD><EFBFBD>
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><>ġ<EFBFBD><C4A1><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϱ<EFBFBD><CFB1><EFBFBD><EFBFBD>ؼ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>մϴ<D5B4>.
|
||
|
||
PureBaseState = m_BaseState; // <20>⺻<EFBFBD><E2BABB><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѱ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ݿ<EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>⺻<EFBFBD><E2BABB>ġ<EFBFBD><C4A1> <20><>.
|
||
int nBaseStrength = m_StateStep[0].GetStrength() - m_BuffState.GetStrength();
|
||
int nBaseAgility = m_StateStep[0].GetAgility() - m_BuffState.GetAgility();
|
||
int nBaseIntelligence = m_StateStep[0].GetIntelligence() - m_BuffState.GetIntelligence();
|
||
int nBaseStamina = m_StateStep[0].GetStamina() - m_BuffState.GetStamina();
|
||
|
||
int nAttackPoint = (int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StrengthAttack));
|
||
nAttackPoint += (int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::AgilityAttack));
|
||
PureBaseState.SetAttackPMin(nAttackPoint);
|
||
PureBaseState.SetAttackPMax(nAttackPoint);
|
||
|
||
nAttackPoint = (int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::IntelligenceAttack));
|
||
PureBaseState.SetAttackMMin(nAttackPoint);
|
||
PureBaseState.SetAttackMMax(nAttackPoint);
|
||
|
||
PureBaseState.SetMaxHP((INT64)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::HP)));
|
||
PureBaseState.SetDefenseP((int)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::PhysicalDefense)));
|
||
PureBaseState.SetStunResistance((int)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StunResistance)));
|
||
|
||
PureBaseState.SetDefenseM((int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::MagicDefense)));
|
||
PureBaseState.SetMaxSP((int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::SP)));
|
||
|
||
PureBaseState.SetStun((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Stun)));
|
||
PureBaseState.SetStiff((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Stiff)));
|
||
PureBaseState.SetStiffResistance((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StiffResistance)));
|
||
|
||
PureBaseState.SetCritical((int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Critical)));
|
||
PureBaseState.SetCriticalResistance((int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::CriticalResistance)));
|
||
|
||
for( DWORD i=0; i<pVecAbsoluteList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecAbsoluteList[i];
|
||
if( pState )
|
||
SumAbsolute.MergeState( *pState, ValueTypeAbsolute );
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̽<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>־<EFBFBD><D6BE><EFBFBD>
|
||
SumAbsolute.MergeState( PureBaseState , ValueTypeAbsolute );
|
||
|
||
for( DWORD i=0; i<pVecRatioList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecRatioList[i];
|
||
if( pState )
|
||
SumRatio.MergeState( *pState, ValueTypeRatio );
|
||
}
|
||
|
||
// PureBaseState <20><><EFBFBD>̽<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>꿡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<CAB1><E2B6A7><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD><EFBFBD><EFBFBD> <20>ʿ䰡<CABF><E4B0A1><EFBFBD><EFBFBD>.
|
||
|
||
SumAbsolute.CalculateRatioValue( SumRatio );
|
||
|
||
return SumAbsolute;
|
||
}
|
||
|
||
CDnState CDnPlayerState::MakeComparePotentialState(CDnItem* pCurrItemState, CDnItem* pNewItemState)
|
||
{
|
||
ValueType eType = ValueType::ValueTypeNone;
|
||
CDnState SumAbsolute;
|
||
CDnState SumRatio;
|
||
CDnState* pTempPotentialState = NULL;
|
||
CDnState* pTempEnchantState = NULL;
|
||
std::vector<CDnState*> pVecAbsoluteList;
|
||
std::vector<CDnState*> pVecRatioList;
|
||
|
||
#if defined(PRE_ADD_TALISMAN_SYSTEM)
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeAbsolute, pVecAbsoluteList );
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility | TalismanList, ValueTypeRatio, pVecRatioList );
|
||
#else
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeAbsolute, pVecAbsoluteList );
|
||
GetStateList( WeaponList | DefenseList | AccessoryList | StateEffectList | SetItemList | AppellationList | GlyphList | PetAbility, ValueTypeRatio, pVecRatioList );
|
||
#endif
|
||
|
||
#pragma region -------------------------- 1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD> --------------------------
|
||
for( DWORD i=0; i<pVecAbsoluteList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecAbsoluteList[i];
|
||
if( pState )
|
||
SumAbsolute.MergeState( *pState, ValueTypeAbsolute );
|
||
}
|
||
SumAbsolute.MergeState( m_BaseState , ValueTypeAbsolute );
|
||
|
||
for( DWORD i=0; i<pVecRatioList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecRatioList[i];
|
||
if( pState )
|
||
SumRatio.MergeState( *pState, ValueTypeRatio );
|
||
}
|
||
|
||
if(pCurrItemState)
|
||
{
|
||
SumAbsolute -= (CDnState)*pCurrItemState;
|
||
pTempPotentialState = (CDnState*)pCurrItemState->GetPotentialState();
|
||
pTempEnchantState = (CDnState*)pCurrItemState->GetEnchantState();
|
||
|
||
if(pTempPotentialState)
|
||
{
|
||
eType = pTempPotentialState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
SumAbsolute -= *pTempPotentialState;
|
||
else if(eType == ValueTypeRatio)
|
||
SumRatio -= *pTempPotentialState;
|
||
}
|
||
|
||
if(pTempEnchantState)
|
||
{
|
||
eType = pTempEnchantState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
SumAbsolute -= *pTempEnchantState;
|
||
else if(eType == ValueTypeRatio)
|
||
SumRatio -= *pTempEnchantState;
|
||
}
|
||
}
|
||
|
||
if(pNewItemState)
|
||
{
|
||
SumAbsolute += (CDnState)*pNewItemState;
|
||
pTempPotentialState = (CDnState*)pNewItemState->GetPotentialState();
|
||
pTempEnchantState = (CDnState*)pNewItemState->GetEnchantState();
|
||
|
||
if(pTempPotentialState)
|
||
{
|
||
eType = pTempPotentialState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
SumAbsolute += *pTempPotentialState;
|
||
else if(eType == ValueTypeRatio)
|
||
SumRatio += *pTempPotentialState;
|
||
}
|
||
|
||
if(pTempEnchantState)
|
||
{
|
||
eType = pTempEnchantState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
SumAbsolute += *pTempEnchantState;
|
||
else if(eType == ValueTypeRatio)
|
||
SumRatio += *pTempEnchantState;
|
||
}
|
||
}
|
||
|
||
SumAbsolute.CalculateRatioValue( SumRatio );
|
||
#pragma endregion
|
||
|
||
|
||
#pragma region -------------------------- 2<><32> <20><><EFBFBD>̽<EFBFBD> <20>簻<EFBFBD><E7B0BB> --------------------------
|
||
CDnState ResultBaseState = m_BaseState;
|
||
|
||
int nBaseStrength = SumAbsolute.GetStrength();
|
||
int nBaseAgility = SumAbsolute.GetAgility();
|
||
int nBaseIntelligence = SumAbsolute.GetIntelligence();
|
||
int nBaseStamina = SumAbsolute.GetStamina();
|
||
|
||
int nAttackPoint = (int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StrengthAttack));
|
||
nAttackPoint += (int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::AgilityAttack));
|
||
ResultBaseState.SetAttackPMin(nAttackPoint);
|
||
ResultBaseState.SetAttackPMax(nAttackPoint);
|
||
|
||
nAttackPoint = (int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::IntelligenceAttack));
|
||
ResultBaseState.SetAttackMMin(nAttackPoint);
|
||
ResultBaseState.SetAttackMMax(nAttackPoint);
|
||
|
||
ResultBaseState.SetMaxHP((INT64)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::HP)));
|
||
ResultBaseState.SetDefenseP((int)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::PhysicalDefense)));
|
||
ResultBaseState.SetStunResistance((int)(nBaseStamina * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StunResistance)));
|
||
|
||
ResultBaseState.SetDefenseM((int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::MagicDefense)));
|
||
ResultBaseState.SetMaxSP((int)(nBaseIntelligence * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::SP)));
|
||
|
||
ResultBaseState.SetStun((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Stun)));
|
||
ResultBaseState.SetStiff((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Stiff)));
|
||
ResultBaseState.SetStiffResistance((int)(nBaseStrength * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::StiffResistance)));
|
||
|
||
ResultBaseState.SetCritical((int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::Critical)));
|
||
ResultBaseState.SetCriticalResistance((int)(nBaseAgility * CPlayerWeightTable::GetInstance().GetValue(m_nActorTableID, CPlayerWeightTable::CriticalResistance)));
|
||
#pragma endregion
|
||
|
||
CDnState NewSumAbsolute;
|
||
CDnState NewSumRatio;
|
||
for( DWORD i=0; i<pVecAbsoluteList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecAbsoluteList[i];
|
||
if( pState )
|
||
NewSumAbsolute.MergeState( *pState, ValueTypeAbsolute );
|
||
}
|
||
NewSumAbsolute.MergeState( ResultBaseState , ValueTypeAbsolute );
|
||
|
||
for( DWORD i=0; i<pVecRatioList.size(); i++ )
|
||
{
|
||
CDnState *pState = pVecRatioList[i];
|
||
if( pState )
|
||
NewSumRatio.MergeState( *pState, ValueTypeRatio );
|
||
}
|
||
|
||
if(pCurrItemState)
|
||
{
|
||
NewSumAbsolute -= (CDnState)*pCurrItemState;
|
||
pTempPotentialState = (CDnState*)pCurrItemState->GetPotentialState();
|
||
pTempEnchantState = (CDnState*)pCurrItemState->GetEnchantState();
|
||
|
||
if(pTempPotentialState)
|
||
{
|
||
eType = pTempPotentialState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
NewSumAbsolute -= *pTempPotentialState;
|
||
else if(eType == ValueTypeRatio)
|
||
NewSumRatio -= *pTempPotentialState;
|
||
}
|
||
|
||
if(pTempEnchantState)
|
||
{
|
||
eType = pTempEnchantState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
NewSumAbsolute -= *pTempEnchantState;
|
||
else if(eType == ValueTypeRatio)
|
||
NewSumRatio -= *pTempEnchantState;
|
||
}
|
||
}
|
||
|
||
if(pNewItemState)
|
||
{
|
||
NewSumAbsolute += (CDnState)*pNewItemState;
|
||
pTempPotentialState = (CDnState*)pNewItemState->GetPotentialState();
|
||
pTempEnchantState = (CDnState*)pNewItemState->GetEnchantState();
|
||
|
||
if(pTempPotentialState)
|
||
{
|
||
eType = pTempPotentialState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
NewSumAbsolute += *pTempPotentialState;
|
||
else if(eType == ValueTypeRatio)
|
||
NewSumRatio += *pTempPotentialState;
|
||
}
|
||
|
||
if(pTempEnchantState)
|
||
{
|
||
eType = pTempEnchantState->GetValueType();
|
||
if(eType == ValueTypeAbsolute)
|
||
NewSumAbsolute += *pTempEnchantState;
|
||
else if(eType == ValueTypeRatio)
|
||
NewSumRatio += *pTempEnchantState;
|
||
}
|
||
}
|
||
NewSumAbsolute.CalculateRatioValue( NewSumRatio ); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ<EFBFBD><C8AD> <20><><EFBFBD><EFBFBD>
|
||
|
||
return NewSumAbsolute;
|
||
}
|
||
|
||
bool CDnPlayerState::IsDeveloperAccountLevel()
|
||
{
|
||
bool bIsDeveloper = true;
|
||
|
||
if(m_cAccountLevel < eAccountLevel::AccountLevel_New)
|
||
bIsDeveloper = false;
|
||
|
||
#ifdef PRE_ADD_DWC
|
||
if(m_cAccountLevel == eAccountLevel::AccountLevel_DWC)
|
||
bIsDeveloper = false;
|
||
#endif
|
||
|
||
return bIsDeveloper;
|
||
}
|
||
|
||
bool CDnPlayerState::IsDeveloperAccountLevel(char cAccountLevel)
|
||
{
|
||
bool bIsDeveloper = true;
|
||
|
||
if(cAccountLevel < eAccountLevel::AccountLevel_New)
|
||
bIsDeveloper = false;
|
||
|
||
#ifdef PRE_ADD_DWC
|
||
if(cAccountLevel == eAccountLevel::AccountLevel_DWC)
|
||
bIsDeveloper = false;
|
||
#endif
|
||
|
||
return bIsDeveloper;
|
||
} |