739 lines
24 KiB
C++
739 lines
24 KiB
C++
#include "stdafx.h"
|
|
#include "SkillEx.h"
|
|
//#include "Util.h"
|
|
#include <toolkit/nsl.h>
|
|
#include <toolkit/nslreg.h>
|
|
#include "SStringDB.h"
|
|
#include "SSkillDB.h"
|
|
#include "STenacityDB.h"
|
|
#include "SItemDB.h"
|
|
#include <toolkit/XStringUtil.h>
|
|
#include "SkillBase.h"
|
|
|
|
#include "SUIDisplayInfo.h"
|
|
#include "SPlayerInfoMgr.h"
|
|
#include "SSummonSlotMgr.h"
|
|
|
|
#include <xtree>
|
|
|
|
namespace rp {
|
|
|
|
CSkillEx::CSkillEx() : mSkill( 0 ), mUseLv( 0 ), mEnhance( 0 ), maxMP(0), curMP(0)
|
|
{
|
|
}
|
|
CSkillEx::CSkillEx( SkillBaseEx* skill ) : mSkill( 0 ), mUseLv( 0 ), mEnhance( 0 ), maxMP(0), curMP(0)
|
|
{
|
|
bind( skill );
|
|
}
|
|
void CSkillEx::bind( SkillBaseEx* skill )
|
|
{
|
|
mSkill = skill;
|
|
}
|
|
bool CSkillEx::isRecoverable() const
|
|
{
|
|
int type = mSkill->GetEffectType();
|
|
if( type == SkillBase::EF_ADD_HP ||
|
|
type == SkillBase::EF_ADD_MP ||
|
|
type == SkillBase::EF_ADD_SP ||
|
|
type == SkillBase::EF_ADD_HP_MP ||
|
|
type == SkillBase::EF_ADD_HP_MP_BY_SUMMON_DAMAGE ||
|
|
type == SkillBase::EF_ADD_HP_MP_BY_SUMMON_DEAD ||
|
|
type == SkillBase::EF_CORPSE_ABSORB ||
|
|
type == SkillBase::EF_ADD_HP_MP_BY_STEAL_SUMMON_HP_MP )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CSkillExFxValue::update()
|
|
{
|
|
/// 2011.05.19 - prodongi
|
|
//mValue = Subject->getSkill()->var[ m_FxValueIndex ];
|
|
if (Subject->isEnchantSkill())
|
|
{
|
|
mValue = Subject->getSkill().level() * Subject->getSkill()->var[ m_FxValueIndex ] + Subject->getEnchantSkill()->var[m_FxValueIndex];
|
|
}
|
|
else
|
|
{
|
|
mValue = Subject->getSkill()->var[ m_FxValueIndex ];
|
|
}
|
|
}
|
|
|
|
void CSkillExValueSkillLv::update()
|
|
{
|
|
if (Subject->isEnchantSkill())
|
|
{
|
|
mValue = Subject->getEnchantSkill().level();
|
|
}
|
|
else
|
|
{
|
|
mValue = Subject->getSkill().level();
|
|
}
|
|
}
|
|
|
|
void CSkillExValueEnhancePoint::update()
|
|
{
|
|
mValue = Subject->getSkill().enhance();
|
|
}
|
|
|
|
void CSkillExValueUserAttack::update()
|
|
{
|
|
//const SPlayerInfo* playerInfo = Subject->getSkill().player();
|
|
//Value = playerInfo->GetAttribute().nAttackPointRight;
|
|
mValue = Subject->getSkill().userAttribute().nAttackPointRight + Subject->getSkill().itemAttribute().nAttackPointRight;
|
|
}
|
|
|
|
void CSkillExValueUserMagic::update()
|
|
{
|
|
//const SPlayerInfo* playerInfo = Subject->getSkill().player();
|
|
//Value = playerInfo->GetAttribute().nMagicPoint;
|
|
mValue = Subject->getSkill().userAttribute().nMagicPoint + Subject->getSkill().itemAttribute().nMagicPoint;
|
|
}
|
|
|
|
/// 2011.04.26 - prodongi
|
|
void CSkillExValueCoolTime::update()
|
|
{
|
|
mValue = (float)Subject->getSkill()->GetCoolTime() / 100.0f;
|
|
}
|
|
|
|
void CSkillExSvValueConsumeBaseHP::update()
|
|
{
|
|
mValue = Subject->getSkill()->cost_hp;
|
|
}
|
|
|
|
void CSkillExSvValueConsumeSlvHP::update()
|
|
{
|
|
mValue = Subject->getSkill()->cost_hp_per_skl;
|
|
}
|
|
|
|
/// 2011.05.19 - prodongi
|
|
void CSkillExValueMP::update()
|
|
{
|
|
mValue = Subject->getSkill()->cost_mp + Subject->getSkill().level() * Subject->getSkill()->cost_mp_per_skl;
|
|
}
|
|
|
|
/// 2011.05.19 - prodongi
|
|
void CSkillExValueCastingDelay::update()
|
|
{
|
|
mValue = (float)(Subject->getSkill()->delay_cast + Subject->getSkill().level() * Subject->getSkill()->delay_cast_per_skl)/100.0f;
|
|
}
|
|
|
|
/// 2011.05.27 - prodongi
|
|
void CSkillExValueMaxMP::update()
|
|
{
|
|
mValue = Subject->getSkill().getMaxMP();
|
|
}
|
|
|
|
/// 2011.05.27 - prodongi
|
|
void CSkillExValueCurMP::update()
|
|
{
|
|
mValue = Subject->getSkill().getCurMP();
|
|
}
|
|
|
|
CSkillTooltip::~CSkillTooltip()
|
|
{
|
|
composer_map_t::iterator it = mComposerMap.begin(), end = mComposerMap.end();
|
|
for( ; it != end; ++it )
|
|
SAFE_DELETE( it->second );
|
|
mComposerMap.clear();
|
|
}
|
|
CSkillTooltip* CSkillTooltip::append( const char* key, ISkillTooltipComposer* composer )
|
|
{
|
|
mComposerMap.insert( std::make_pair( key, composer ) );
|
|
return this;
|
|
}
|
|
|
|
ISkillTooltipComposer* CSkillTooltip::find( const char* key )
|
|
{
|
|
composer_map_t::iterator found = mComposerMap.find( key );
|
|
if( found != mComposerMap.end() )
|
|
{
|
|
return found->second;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CSkillTooltip::compose( const CSkillEx& skill, std::string& tooltip )
|
|
{
|
|
std::string pattern = "#@([_a-z]*)@#";
|
|
std::vector< std::string > matchList;
|
|
while( nsl::regex::match( pattern.c_str(), tooltip.c_str(), &matchList ) )
|
|
{
|
|
composer_map_t::iterator found = mComposerMap.find( matchList[ 0 ].c_str() );
|
|
if( found != mComposerMap.end() )
|
|
found->second->compose( skill, tooltip, found->first );
|
|
else
|
|
CSkillEmptyDeco().compose( skill, tooltip, matchList[ 0 ] );
|
|
matchList.clear();
|
|
}
|
|
}
|
|
|
|
void CSkillEmptyDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), "" );
|
|
}
|
|
|
|
void CSkillLvDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), CStringUtil::StringFormat( "%d", skill.level() ).c_str() );
|
|
}
|
|
|
|
void CSkillAttributeIconDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string attribute_icon;
|
|
int elemental = skill->GetElementalType();
|
|
if( elemental == 0 ) attribute_icon = "#@NOMAL@#";
|
|
else if( elemental == 1 ) attribute_icon = "#@FIRE@#";
|
|
else if( elemental == 2 ) attribute_icon = "#@WATER@#";
|
|
else if( elemental == 3 ) attribute_icon = "#@WIND@#";
|
|
else if( elemental == 4 ) attribute_icon = "#@EARTH@#";
|
|
else if( elemental == 5 ) attribute_icon = "#@LIGHT@#";
|
|
else if( elemental == 6 ) attribute_icon = "#@DARK@#";
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), attribute_icon.c_str() );
|
|
}
|
|
|
|
void CSkillHpDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), CStringUtil::StringFormat( "%d", skill->GetCostHP( skill.level() ) ).c_str() );
|
|
}
|
|
|
|
void CSkillMpDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), CStringUtil::StringFormat( "%d", skill->GetCostMP( skill.level() ) ).c_str() );
|
|
}
|
|
|
|
void CSkillAggroDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), CStringUtil::StringFormat( "%d", skill->GetHate( skill.level() ) ).c_str() );
|
|
}
|
|
|
|
void CSkillAggroTypeDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string aggroType;
|
|
if( !skill->GetHate( skill.level() ) )
|
|
{
|
|
if( skill.isRecoverable() )
|
|
aggroType = S( 7035 );
|
|
else
|
|
aggroType = S( 7036 );
|
|
}
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), aggroType.c_str() );
|
|
}
|
|
|
|
void CSkillCastingTimeDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
//시간을 시간, 분, 초로 나눠서 출력
|
|
std::string time;
|
|
float ar_CastTime = skill->GetCastDelay( skill.level() );
|
|
if( ar_CastTime > 0 )
|
|
{
|
|
time = " ";
|
|
time += Helper->GetTimeString( ar_CastTime / 100.0f ).c_str();
|
|
}
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), time.c_str() );
|
|
}
|
|
|
|
/// 2011.06.20 - prodongi
|
|
void CSkillCoolTimeDeco::compose(const CSkillEx& skill, std::string& tooltip, const std::string& pattern)
|
|
{
|
|
// 2012. 1. 18 - marine 쿨타임이 소수점이하는 처리되지 않아서 수정
|
|
float cooltime = (float)(skill->GetCoolTime()) / 100.0f;
|
|
float cooltimeSkl = (float)(skill->GetCoolTimePerSkill()) / 100.0f ;
|
|
float t = cooltime + (float)skill.level() * cooltimeSkl;
|
|
std::string str = S(77);
|
|
str += " ";
|
|
str += Helper->GetTimeString(t);
|
|
XStringUtil::Replace(tooltip, pattern.c_str(), str.c_str());
|
|
}
|
|
|
|
void CSkillCriticalBonusDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
int nCritical = skill->GetCriticalBonus( skill.level() );
|
|
if( nCritical )
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), CStringUtil::StringFormat( "%d", nCritical ).c_str() );
|
|
else
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), "" );
|
|
}
|
|
|
|
void CSkillEnhanceDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), skill.enhance() > 0 ? CStringUtil::StringFormat( "+%d ", skill.enhance() ).c_str() : "" );
|
|
}
|
|
|
|
void CSkillImproveMpCostDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
int improvedMpCost = skill->GetCostMPByEnhance( skill.enhance() );
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), improvedMpCost ? CStringUtil::StringFormat( "(%d)", improvedMpCost ).c_str() : "" );
|
|
}
|
|
|
|
void CSkillImproveCastingTimeDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string improvedCastingTimeString;
|
|
float castingTime = skill->GetCastDelay( skill.level() );
|
|
float improvedCastingTime = skill->GetCastDelayByEnhance( skill.enhance() );
|
|
if( improvedCastingTime )
|
|
improvedCastingTimeString = "(" + Helper->GetTimeString( castingTime / 100 * improvedCastingTime ) + ")";
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), improvedCastingTimeString.c_str() );
|
|
}
|
|
|
|
void CSkillImproveCoolTimeDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string improvedCooltimeString;
|
|
long coolTime( skill->GetCoolTime() ); /// 2011.04.27 AR_TIME -> long - prodongi
|
|
float improvedCooltime( skill->GetCoolTimeByEnhance( skill.enhance() ) );
|
|
if( improvedCooltime )
|
|
improvedCooltimeString = "(" + Helper->GetTimeString( coolTime / 100 * improvedCooltime ) + ")";
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), improvedCooltimeString.c_str() );
|
|
}
|
|
|
|
void CSkillImproveHitBonusDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
int hitbonus( skill->GetHitBonusByEnhance( skill.enhance() ) );
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), hitbonus ? CStringUtil::StringFormat( "(+%d)", hitbonus ).c_str() : "" );
|
|
}
|
|
|
|
void CSkillImproveAggroDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
int aggro( skill->GetHateByEnhance( skill.enhance() ) );
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), aggro ? CStringUtil::StringFormat( "(+%d)", aggro ).c_str() : "" );
|
|
}
|
|
|
|
void CSkillFxDeco::setDefaultTag( const char* tag )
|
|
{
|
|
m_DefaultTag = tag;
|
|
}
|
|
|
|
/// 2011.05.19 - prodongi
|
|
void CSkillFxDeco::compileSkill(const CSkillEx& skill, std::string& result)
|
|
{
|
|
_STRING_TABLE_INFO* stringTable = GetStringDB().GetStringData( GameRule::SKILL_EFFECT_TOOLTIP_STRING_OFFSET + skill->GetSkillEffectType() );
|
|
if( stringTable )
|
|
{
|
|
std::string fx = stringTable->pStrDesc;
|
|
|
|
if( !fx.empty() )
|
|
{
|
|
fx_expr::Compiler compiler( *m_Subject );
|
|
compiler.addTokens( "()+-*/&,$" );
|
|
compiler.addEscape( "'" );
|
|
compiler.compile( fx.begin(), fx.end() );
|
|
// 2010.08.31 에러 처리 - prodongi
|
|
//result = compiler.result()->toString();
|
|
if (compiler.result())
|
|
result = compiler.result()->toString();
|
|
}
|
|
}
|
|
|
|
if( !result.empty() )
|
|
result = "<br>" + result;
|
|
}
|
|
|
|
// #2.1.2.12
|
|
void CSkillFxDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
/// 2011.05.19 - prodongi
|
|
if (skill->skill_enchant_link_id)
|
|
{
|
|
std::string result, result1, result2;
|
|
// 강화 스킬
|
|
m_Subject->setSkill( skill );
|
|
compileSkill(skill, result1);
|
|
|
|
// 강화 대상 스킬
|
|
SkillBaseEx* enchantSkillData = GetSkillDB().GetSkillData(skill->skill_enchant_link_id);
|
|
if (enchantSkillData)
|
|
{
|
|
rp::CSkillEx enchantSkill(enchantSkillData);
|
|
enchantSkill.level(1);
|
|
m_Subject->setSkill(skill, enchantSkill);
|
|
compileSkill(enchantSkill, result2);
|
|
}
|
|
|
|
result = result1 + result2;
|
|
nsl::replace( tooltip, pattern, result );
|
|
}
|
|
else
|
|
{
|
|
m_Subject->setSkill( skill );
|
|
std::string result;
|
|
compileSkill(skill, result);
|
|
nsl::replace( tooltip, pattern, result );
|
|
}
|
|
|
|
/*
|
|
m_Subject->setSkill( skill );
|
|
|
|
std::string result;
|
|
|
|
_STRING_TABLE_INFO* stringTable = GetStringDB().GetStringData( GameRule::SKILL_EFFECT_TOOLTIP_STRING_OFFSET + skill->GetSkillEffectType() );
|
|
if( stringTable )
|
|
{
|
|
std::string fx = stringTable->pStrDesc;
|
|
|
|
if( !fx.empty() )
|
|
{
|
|
fx_expr::Compiler compiler( *m_Subject ); */
|
|
// compiler.addTokens( "()+-*/&,$" );
|
|
/* compiler.addEscape( "'" );
|
|
compiler.compile( fx.begin(), fx.end() );
|
|
// 2010.08.31 에러 처리 - prodongi
|
|
//result = compiler.result()->toString();
|
|
if (compiler.result())
|
|
result = compiler.result()->toString();
|
|
}
|
|
}
|
|
|
|
if( !result.empty() )
|
|
result = "<br>" + result;
|
|
|
|
nsl::replace( tooltip, pattern, result );
|
|
*/
|
|
}
|
|
|
|
const char* tagBR = "<br>";
|
|
const char* tagOBRACKET = "<#17f39c>(";
|
|
const char* tagCBRACKET = ")<#ffffff>";
|
|
const char* tagFxEnhance = "<#17f39c>(#@value@#)<#ffeab1>";
|
|
|
|
void CSkillStateFxDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string StateFxDeco;
|
|
m_Subject->setSkill( skill );
|
|
// 2010.06.03 - prodongi
|
|
std::vector<int> stateLevel;
|
|
std::vector< int > StateFxIDs;
|
|
gatherStateFxIDFrom( skill, StateFxIDs, stateLevel );
|
|
//std::vector< int > StateFxIDs = gatherStateFxIDFrom( skill );
|
|
|
|
if( !StateFxIDs.empty() )
|
|
{
|
|
std::string StateFxCommonDecl;
|
|
int Probability = skill->GetStateSuccess( skill.level() );
|
|
AR_TIME Duration = skill->GetStateTime( skill.level() );
|
|
|
|
// 지속 시간 출력
|
|
if( !skill->IsToggle() && Duration )
|
|
{
|
|
StateFxCommonDecl = S( 1606 ); // "#@success_per@#% 확률로 #@state_time@# 동안 #@state_name@# 효과 부여"
|
|
std::string DurationString = m_Helper->GetTimeString( Duration / 100.0f ).c_str();
|
|
if( skill.enhance() )
|
|
{
|
|
AR_TIME EnhancedDuration = skill->GetStateEnhanceTime( skill.enhance() );
|
|
if( EnhancedDuration )
|
|
{
|
|
std::string EnhancedDurationString = S( 7001 );
|
|
XStringUtil::Replace( EnhancedDurationString, "#@enhance@#", m_Helper->GetTimeString( EnhancedDuration / 100.0f ).c_str() );
|
|
DurationString += EnhancedDurationString;
|
|
}
|
|
}
|
|
XStringUtil::Replace( StateFxCommonDecl, "#@state_time@#", DurationString.c_str() );
|
|
}
|
|
else
|
|
StateFxCommonDecl = S( 2057 ); // "#@success_per@#% 확률로 #@state_name@# 효과 부여"
|
|
|
|
// 부여 확률 출력
|
|
XStringUtil::Replace( StateFxCommonDecl, "#@success_per@#", SStringDB::ToString( Probability ).c_str() );
|
|
|
|
std::vector< int >::iterator it = StateFxIDs.begin(), end = StateFxIDs.end();
|
|
// 2010.06.03 - prodongi
|
|
for(int count = 0 ; it != end; ++it, ++count )
|
|
//for( ; it != end; ++it )
|
|
{
|
|
int StateFxID = *it;
|
|
if( !isSystemStateFx( StateFxID ) ) // if the state fx is for system only, there's no need to show the state fx declaration.
|
|
{
|
|
int StateNameID = GetTenacityDB().GetNameID( StateFxID );
|
|
if( !StateNameID )
|
|
continue;
|
|
|
|
std::string StateFxDecl( StateFxCommonDecl );
|
|
|
|
// 지속 효과명
|
|
XStringUtil::Replace( StateFxDecl, "#@state_name@#", GetStringDB().GetString( StateNameID ) );
|
|
StateFxDeco += tagBR;
|
|
StateFxDeco += "<#FFC57F>";
|
|
StateFxDeco += StateFxDecl;
|
|
StateFxDeco += "<#FFFFFF>";
|
|
}
|
|
|
|
std::string StateFxDetail;
|
|
// 2010.06.03 - prodongi
|
|
int stateFxLevel = -1;
|
|
if (count < (int)stateLevel.size()) stateFxLevel = stateLevel[count];
|
|
/// 2010.11.18 - prodongi
|
|
getStateFxDetail( StateFxID, StateFxDetail, stateFxLevel, skill.enhance() );
|
|
//getStateFxDetail( StateFxID, StateFxDetail, stateFxLevel );
|
|
//getStateFxDetail( StateFxID, StateFxDetail );
|
|
if( !StateFxDetail.empty() )
|
|
{
|
|
StateFxDeco += tagBR;
|
|
StateFxDeco += StateFxDetail;
|
|
}
|
|
}
|
|
}
|
|
// 2010.06.03 - prodongi
|
|
stateLevel.clear();
|
|
StateFxIDs.clear();
|
|
|
|
XStringUtil::Replace( tooltip, pattern.c_str(), StateFxDeco.c_str() );
|
|
}
|
|
|
|
// 2010.05.17 - prodongi
|
|
void CSkillPassiveFxDeco::compose( const CSkillEx& skill, std::string& tooltip, const std::string& pattern )
|
|
{
|
|
std::string result;
|
|
switch (skill->GetEffectType())
|
|
{
|
|
case SkillBase::EF_PASSIVE_PARAMETER_INCREASE: result = parameterIncAmp(skill, false); break;
|
|
case SkillBase::EF_PASSIVE_PARAMETER_AMPLIFY: result = parameterIncAmp(skill, true); break;
|
|
}
|
|
|
|
nsl::replace( tooltip, pattern, result );
|
|
}
|
|
|
|
// 2010.05.17 - prodongi
|
|
std::string CSkillPassiveFxDeco::getParameterTypeABitSetText(const CSkillEx& skill, int strId, int varPos, bool amplify)
|
|
{
|
|
if (0 == skill->var[varPos])
|
|
return "";
|
|
float p = (amplify) ? 100.0f : 1.0f;
|
|
double dValue = (skill->var[varPos+1] + (float)skill.level() * skill->var[varPos+2]) * p;
|
|
return SUIDisplayInfo::Get_A_BitSetText(strId, skill->var[varPos], dValue, amplify);
|
|
}
|
|
|
|
// 2010.05.20 - prodongi
|
|
std::string CSkillPassiveFxDeco::getParameterTypeBBitSetText(const CSkillEx& skill, int strId, int varPos, bool amplify)
|
|
{
|
|
if (0 == skill->var[varPos])
|
|
return "";
|
|
float p = (amplify) ? 100.0f : 1.0f;
|
|
double dValue = (skill->var[varPos+1] + (float)skill.level() * skill->var[varPos+2]) * p;
|
|
return SUIDisplayInfo::Get_B_BitSetText(strId, skill->var[varPos], dValue, amplify);
|
|
}
|
|
|
|
// 2010.05.17 - prodongi
|
|
std::string CSkillPassiveFxDeco::parameterIncAmp(const CSkillEx& skill, bool amplify)
|
|
{
|
|
std::string tooltip, strTemp;
|
|
|
|
// 1
|
|
tooltip = getParameterTypeABitSetText(skill, 7153, 0, amplify);
|
|
// 2
|
|
strTemp = getParameterTypeABitSetText(skill, 7153, 3, amplify);
|
|
if( !strTemp.empty() )
|
|
{
|
|
if( !tooltip.empty() ) tooltip += "<BR>";
|
|
tooltip += strTemp;
|
|
strTemp.clear();
|
|
}
|
|
// 3
|
|
strTemp = getParameterTypeBBitSetText(skill, 7153, 6, amplify);
|
|
if( !strTemp.empty() )
|
|
{
|
|
if( !tooltip.empty() ) tooltip += "<BR>";
|
|
tooltip += strTemp;
|
|
strTemp.clear();
|
|
}
|
|
// 4
|
|
strTemp = getParameterTypeBBitSetText(skill, 7153, 9, amplify);
|
|
if( !strTemp.empty() )
|
|
{
|
|
if( !tooltip.empty() ) tooltip += "<BR>";
|
|
tooltip += strTemp;
|
|
strTemp.clear();
|
|
}
|
|
// 5
|
|
strTemp = getParameterTypeABitSetText(skill, 7153, 12, amplify);
|
|
if( !strTemp.empty() )
|
|
{
|
|
if( !tooltip.empty() ) tooltip += "<BR>";
|
|
tooltip += strTemp;
|
|
strTemp.clear();
|
|
}
|
|
// 6
|
|
strTemp = getParameterTypeABitSetText(skill, 7153, 15, amplify);
|
|
if( !strTemp.empty() )
|
|
{
|
|
if( !tooltip.empty() ) tooltip += "<BR>";
|
|
tooltip += strTemp;
|
|
strTemp.clear();
|
|
}
|
|
|
|
return tooltip;
|
|
}
|
|
|
|
bool CSkillStateFxDeco::isSystemStateFx( int stateFxID ) const
|
|
{
|
|
int SystemStateFxIDs[] = {
|
|
6502,
|
|
6503,
|
|
6504,
|
|
6505,
|
|
6506,
|
|
6507,
|
|
6508,
|
|
6509,
|
|
6510,
|
|
6511,
|
|
6512,
|
|
6513,
|
|
6515,
|
|
6516,
|
|
6517,
|
|
6518,
|
|
6519,
|
|
23492,
|
|
};
|
|
|
|
int IDCount = sizeof( SystemStateFxIDs ) / sizeof( int );
|
|
for( int n = 0; n < IDCount; ++n )
|
|
if( SystemStateFxIDs[ n ] == stateFxID )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// 2010.06.03 - prodongi
|
|
// std::vector< int > CSkillStateFxDeco::gatherStateFxIDFrom( const CSkillEx& Skill )
|
|
void CSkillStateFxDeco::gatherStateFxIDFrom( const CSkillEx& Skill, std::vector<int>& StateFxIDs, std::vector<int>& stateLevel)
|
|
{
|
|
// 2010.06.03 - prodongi
|
|
//std::vector< int > StateFxIDs;
|
|
if( Skill->GetStateId() > 0 )
|
|
{
|
|
StateFxIDs.push_back( Skill->GetStateId() );
|
|
}
|
|
// TODO: gather stateIDs from skill fx db
|
|
switch( Skill->GetEffectType() )
|
|
{
|
|
case SkillBase::EF_ADD_STATE:// 301
|
|
case SkillBase::EF_ADD_STATE_REGION:// 302
|
|
case SkillBase::EF_ADD_STATE_WHEN_RACE_IS_FIT:// 307
|
|
case SkillBase::EF_RECALL_CREATURE_WITH_STATE:// 605
|
|
for( int i = 0; i < 5; ++i )
|
|
if( Skill->var[ i ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ i ] );
|
|
break;
|
|
case SkillBase::EF_TOGGLE_AURA:
|
|
for( int i = 3; i < 5; ++i )
|
|
if( Skill->var[ i ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ i ] );
|
|
break;
|
|
case SkillBase::EF_TOGGLE_DISTRIBUTIVE_AURA:
|
|
for( int i = 3; i < 8; ++i )
|
|
if( Skill->var[ i ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ i ] );
|
|
break;
|
|
case SkillBase::EF_REMOVE_STATE_BY_GROUP:
|
|
for( int i = 12; i < 15; ++i )
|
|
if( Skill->var[ i ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ i ] );
|
|
break;
|
|
// 2010.05.12 - prodongi
|
|
case SkillBase::EF_ADD_SEQ_STATE:
|
|
if( Skill->var[ 10 ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ 10 ] );
|
|
// 2010.06.03 - prodongi
|
|
case SkillBase::EF_ADD_STATE_WHEN_CASTING_CANCELED:
|
|
if( Skill->var[ 4 ] > 0 ) StateFxIDs.push_back( Skill->var[ 4 ] );
|
|
break;
|
|
case SkillBase::EF_ADD_STATE_308:
|
|
if( Skill->var[ 0 ] > 0 ) StateFxIDs.push_back( Skill->var[ 0 ] );
|
|
if( Skill->var[ 1 ] > 0 ) StateFxIDs.push_back( Skill->var[ 1 ] );
|
|
if( Skill->var[ 2 ] > 0 ) StateFxIDs.push_back( Skill->var[ 2 ] );
|
|
break;
|
|
case SkillBase::EF_ADD_STATE_309:
|
|
if( Skill->var[ 0 ] > 0 ) StateFxIDs.push_back( Skill->var[ 0 ] );
|
|
break;
|
|
/// 2011.04.13 - prodongi
|
|
case SkillBase::EF_ADD_STATE_10048:
|
|
case SkillBase::EF_ADD_STATE_10049:
|
|
case SkillBase::EF_ADD_STATE_10050:
|
|
case SkillBase::EF_ADD_STATE_10051:
|
|
case SkillBase::EF_ADD_STATE_10052:
|
|
case SkillBase::EF_ADD_STATE_10053:
|
|
case SkillBase::EF_ADD_STATE_10054:
|
|
case SkillBase::EF_ADD_STATE_10055:
|
|
case SkillBase::EF_ADD_STATE_10056:
|
|
case SkillBase::EF_ADD_STATE_10057:
|
|
case SkillBase::EF_ADD_STATE_10058:
|
|
case SkillBase::EF_ADD_STATE_10059:
|
|
case SkillBase::EF_ADD_STATE_10060:
|
|
case SkillBase::EF_ADD_STATE_10061:
|
|
case SkillBase::EF_ADD_STATE_10062:
|
|
if( Skill->var[ 0 ] > 0 ) StateFxIDs.push_back( Skill->var[ 0 ] );
|
|
break;
|
|
/// 2011.05.03 - prodongi
|
|
case SkillBase::EF_PHYSICAL_SINGLE_DAMAGE_AND_ADD_STATE:
|
|
for( int i = 0; i < 10; ++i )
|
|
if( Skill->var[ i ] > 0 )
|
|
StateFxIDs.push_back( Skill->var[ i ] );
|
|
break;
|
|
}
|
|
|
|
// sonador 10.4.2 지속효과 기본공격 반영률 관련 오류 수정
|
|
// 추가효과 유형중 다른 지속효과를 참조하는 경우를 점검한다.
|
|
int StateSize = StateFxIDs.size();
|
|
for( int index = 0; index < StateSize; ++index )
|
|
{
|
|
StateInfoEx* StateInfo = GetTenacityDB().GetTenacityData( StateFxIDs.at( index ) );
|
|
if( StateInfo && StateInfo->effect_type == 88 && (int)StateInfo->fValue[ 0 ] > 0 )
|
|
StateFxIDs.push_back( (int)StateInfo->fValue[ 0 ] );
|
|
}
|
|
|
|
// 2010.06.03 - prodongi
|
|
int skillLevel = Skill.level();
|
|
float const* var = Skill->var;
|
|
if( Skill->GetStateId() > 0 )
|
|
{
|
|
stateLevel.push_back(-1);
|
|
}
|
|
|
|
switch( Skill->GetEffectType() )
|
|
{
|
|
case SkillBase::EF_ADD_STATE_WHEN_CASTING_CANCELED:
|
|
if( var[ 4 ] > 0 ) stateLevel.push_back(var[5]+skillLevel*var[6]);
|
|
break;
|
|
case SkillBase::EF_ADD_STATE_308:
|
|
if( var[ 0 ] > 0 ) stateLevel.push_back(var[3]+skillLevel*var[4]);
|
|
if( var[ 1 ] > 0 ) stateLevel.push_back(var[7]+skillLevel*var[8]);
|
|
if( var[ 2 ] > 0 ) stateLevel.push_back(var[9]+skillLevel*var[10]);
|
|
break;
|
|
case SkillBase::EF_ADD_STATE_309:
|
|
if( var[ 0 ] > 0 ) stateLevel.push_back(var[1]+skillLevel*var[2]);
|
|
break;
|
|
case SkillBase::EF_ADD_SEQ_STATE:
|
|
if( var[ 10 ] > 0 ) stateLevel.push_back(var[11]+skillLevel*var[12]);
|
|
break;
|
|
}
|
|
|
|
// 2010.06.03 - prodongi
|
|
//return StateFxIDs;
|
|
}
|
|
|
|
// 2010.06.03 - prodongi
|
|
/// 2010.11.18 - prodongi
|
|
void CSkillStateFxDeco::getStateFxDetail( int StateFxID, std::string& StateFxDetail, int _stateFxLevel, int skillEnhance )
|
|
// void CSkillStateFxDeco::getStateFxDetail( int StateFxID, std::string& StateFxDetail )
|
|
{
|
|
// 2010.06.03 - prodongi
|
|
/// 2010.11.18 - prodongi
|
|
int StateFxLevel;
|
|
if (-1 == _stateFxLevel)
|
|
{
|
|
StateFxLevel = m_Subject->getSkill()->GetStateLevel( m_Subject->getSkill().level() );
|
|
StateFxLevel += m_Subject->getSkill()->GetStateEnhanceLv(skillEnhance);
|
|
}
|
|
else
|
|
{
|
|
StateFxLevel = _stateFxLevel;
|
|
}
|
|
//int StateFxLevel = m_Subject->getSkill()->GetStateLevel( m_Subject->getSkill().level() );
|
|
StateFxDetail += m_Helper->GetStateBaseEffectCaseToolTipText( StateFxID, StateFxLevel, m_Subject->getSkill().userAttribute(), m_Subject->getSkill().itemAttribute() ); // sonador 10.4.2 지속효과 기본공격 반영률 관련 오류 수정
|
|
// 2010.05.17 - prodongi
|
|
std::string CaseDetail = m_Helper->GetStateCaseToolTipText( StateFxID, StateFxLevel, m_Subject->getSkill().level() );
|
|
// std::string CaseDetail = m_Helper->GetStateCaseToolTipText( StateFxID, StateFxLevel );
|
|
if( !CaseDetail.empty() && !StateFxDetail.empty() )
|
|
StateFxDetail += tagBR;
|
|
StateFxDetail += CaseDetail;
|
|
}
|
|
|
|
} // namespace rp
|