1416 lines
124 KiB
C++
1416 lines
124 KiB
C++
#include "stdafx.h"
|
||
#include "Attribute.h"
|
||
|
||
#include <Const.h>
|
||
#include "Struct.h"
|
||
#include "ItemInfoParser.h"
|
||
|
||
|
||
//==================================================================================================
|
||
static BoundPolicies s_BoundPolicies;
|
||
|
||
BoundPolicies::BoundPolicies()
|
||
{
|
||
policy_list_[eBOUNDTYPE_MP_100] = &policy_mp_100_;
|
||
policy_list_[eBOUNDTYPE_MP_1000] = &policy_mp_1000_;
|
||
policy_list_[eBOUNDTYPE_MP_10000] = &policy_mp_10000_;
|
||
policy_list_[eBOUNDTYPE_MP_INFINITE] = &policy_mp_infinite_;
|
||
policy_list_[eBOUNDTYPE_ZP_100] = &policy_zp_100_;
|
||
policy_list_[eBOUNDTYPE_ZP_1000] = &policy_zp_1000_;
|
||
policy_list_[eBOUNDTYPE_ZP_10000] = &policy_zp_10000_;
|
||
policy_list_[eBOUNDTYPE_ZP_INFINITE] = &policy_zp_infinite_;
|
||
}
|
||
|
||
inline int BoundPolicies::touch(eBOUNDTYPE bound_type, int check_value) const
|
||
{
|
||
assert(0 <= bound_type && bound_type < _countof(policy_list_));
|
||
return policy_list_[bound_type]->touch(check_value);
|
||
}
|
||
|
||
//==================================================================================================
|
||
|
||
int INTValue::touch(eBOUNDTYPE bound_type)
|
||
{
|
||
value_ = s_BoundPolicies.touch(bound_type, value_);
|
||
return value_;
|
||
}
|
||
|
||
//==================================================================================================
|
||
INTValue AttrValue::calc_ratio_static_;
|
||
|
||
INTValue& AttrValue::operator[](eATTR_KIND eAttr)
|
||
{
|
||
assert(eAttr < eATTR_KIND_MAX);
|
||
switch (eAttr)
|
||
{
|
||
case eATTR_KIND_BASE:
|
||
return base_value_;
|
||
case eATTR_KIND_ITEM:
|
||
return item_value_;
|
||
case eATTR_KIND_SKILL:
|
||
return skill_value_;
|
||
case eATTR_KIND_ITEM_RATIO:
|
||
return item_ratio_;
|
||
case eATTR_KIND_SKILL_RATIO:
|
||
return skill_ratio_;
|
||
case eATTR_KIND_RATIO :
|
||
{
|
||
INTValue calc_ratio;
|
||
calc_ratio.value_ += item_ratio_.value_;
|
||
calc_ratio.value_ += skill_ratio_.value_;
|
||
calc_ratio.touch(eBOUNDTYPE_MP_10000);
|
||
calc_ratio_static_ = calc_ratio;
|
||
return calc_ratio_static_;
|
||
};
|
||
}
|
||
return calc_value_;
|
||
}
|
||
|
||
int AttrValue::operator[](eATTR_KIND eAttr) const
|
||
{
|
||
assert(eAttr < eATTR_KIND_MAX);
|
||
switch (eAttr)
|
||
{
|
||
case eATTR_KIND_BASE:
|
||
return base_value_;
|
||
case eATTR_KIND_ITEM:
|
||
return item_value_;
|
||
case eATTR_KIND_SKILL:
|
||
return skill_value_;
|
||
case eATTR_KIND_ITEM_RATIO:
|
||
return item_ratio_;
|
||
case eATTR_KIND_SKILL_RATIO:
|
||
return skill_ratio_;
|
||
case eATTR_KIND_RATIO:
|
||
{
|
||
INTValue calc_ratio;
|
||
calc_ratio.value_ += item_ratio_.value_;
|
||
calc_ratio.value_ += skill_ratio_.value_;
|
||
calc_ratio.touch(eBOUNDTYPE_MP_10000);
|
||
return calc_ratio.value_;
|
||
};
|
||
}
|
||
return calc_value_.value_;
|
||
}
|
||
|
||
void AttrValue::Update()
|
||
{
|
||
//s_AttrUpdatePolicies[update_type_].Update(calc_value_,
|
||
// base_value_, item_value_, skill_value_, item_ratio_, skill_ratio_);
|
||
if (item_value_.value_ != 0) {
|
||
item_value_.touch(eBOUNDTYPE_MP_INFINITE);
|
||
}
|
||
if (skill_value_.value_ != 0) {
|
||
skill_value_.touch(eBOUNDTYPE_MP_INFINITE);
|
||
}
|
||
if (item_ratio_.value_ != 0) {
|
||
item_ratio_.touch(eBOUNDTYPE_MP_10000);
|
||
}
|
||
if (skill_ratio_.value_ != 0) {
|
||
skill_ratio_.touch(eBOUNDTYPE_MP_10000);
|
||
}
|
||
if (base_value_.value_ != 0) {
|
||
base_value_.touch(static_cast<eBOUNDTYPE>(bound_type_));
|
||
}
|
||
|
||
if (update_type_ == eUPDATETYPE_NOTHING)
|
||
{
|
||
if (calc_value_.value_ != 0) {
|
||
calc_value_.touch(static_cast<eBOUNDTYPE>(bound_type_));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (update_type_ == eUPDATETYPE_NOT_RATIO)
|
||
{
|
||
//不应用比率值的原因是将比率值本身应用到其他值。.
|
||
calc_value_.value_ = base_value_.value_;
|
||
calc_value_.value_ += item_value_.value_;
|
||
calc_value_.value_ += skill_value_.value_;
|
||
if (calc_value_.value_ != 0) {
|
||
calc_value_.touch(static_cast<eBOUNDTYPE>(bound_type_));
|
||
}
|
||
}
|
||
else if (update_type_ == eUPDATETYPE_SUM_RATIO)
|
||
{
|
||
INTValue calc_ratio;
|
||
calc_ratio.value_ += item_ratio_.value_;
|
||
calc_ratio.value_ += skill_ratio_.value_;
|
||
if (calc_ratio.value_ != 0) {
|
||
calc_ratio.touch(eBOUNDTYPE_MP_10000);
|
||
}
|
||
//
|
||
calc_value_.value_ = base_value_.value_;
|
||
calc_value_.value_ += item_value_.value_;
|
||
calc_value_.value_ += skill_value_.value_;
|
||
if (calc_value_.value_ != 0 && calc_ratio.value_ != 0)
|
||
{
|
||
calc_value_.value_ *= (100L + calc_ratio.value_);
|
||
calc_value_.value_ /= 100L;
|
||
}
|
||
if (calc_value_.value_ != 0) {
|
||
calc_value_.touch(static_cast<eBOUNDTYPE>(bound_type_));
|
||
}
|
||
}
|
||
}
|
||
|
||
//==================================================================================================
|
||
AttrValue Attributes::attr_value_static_;
|
||
|
||
const eATTACK_TYPE Attributes::Physicals::kPhysicalsMappedArray[Counts] =
|
||
{
|
||
eATTACK_TYPE_MELEE, // 1
|
||
eATTACK_TYPE_RANGE, // 2
|
||
};
|
||
|
||
#define PHYSICAL_INDEX_INVALID (_countof(Attributes::Physicals::kPhysicalsMappedArray))
|
||
const int Attributes::Physicals::kToPhysicalIndex[eATTACK_TYPE_MAX] =
|
||
{
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_ALL_OPTION = 0, //所有选项
|
||
0, //eATTACK_TYPE_MELEE, // 近程
|
||
1, //eATTACK_TYPE_RANGE, // 范围
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_WATER, // 水
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_FIRE, // 火
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_WIND, // 风
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_EARTH, // 土
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_DARKNESS, // 暗
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_DIVINE, //神
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_PHYSICAL_OPTION, //物理选项
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_MAGIC_OPTION, //魔法选项
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_ALL_MAGIC, //所有魔法属性
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_MAGIC, //魔法
|
||
#if !defined(_NA001605_EP2_ATTRIBUTES_RENEWAL_)
|
||
PHYSICAL_INDEX_INVALID, //eATTACK_TYPE_INVALID,
|
||
#endif
|
||
//eATTACK_TYPE_MAX,
|
||
};
|
||
|
||
const eATTACK_TYPE Attributes::Elements::kElementsMappedArray[Counts] =
|
||
{
|
||
eATTACK_TYPE_WATER, // 3
|
||
eATTACK_TYPE_FIRE, // 4
|
||
eATTACK_TYPE_WIND, // 5
|
||
eATTACK_TYPE_EARTH, // 6
|
||
eATTACK_TYPE_DARKNESS // 7
|
||
};
|
||
|
||
#define ELEMENT_INDEX_INVALID (_countof(Attributes::Elements::kElementsMappedArray))
|
||
const int Attributes::Elements::kToElementIndex[eATTACK_TYPE_MAX] =
|
||
{
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_ALL_OPTION = 0, //所有选项
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_MELEE, //近程
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_RANGE, //范围
|
||
0, //eATTACK_TYPE_WATER, // 水
|
||
1, //eATTACK_TYPE_FIRE, // 火
|
||
2, //eATTACK_TYPE_WIND, // 风
|
||
3, //eATTACK_TYPE_EARTH, //土
|
||
4, //eATTACK_TYPE_DARKNESS, //暗
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_DIVINE, //神
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_PHYSICAL_OPTION, //物理选项
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_MAGIC_OPTION, //魔法选项
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_ALL_MAGIC, //所有魔法属性
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_MAGIC, //魔法
|
||
#if !defined(_NA001605_EP2_ATTRIBUTES_RENEWAL_)
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_INVALID,
|
||
#endif
|
||
#ifdef _NA_004965_20120613_NEW_CHARACTER_MYSTIC
|
||
ELEMENT_INDEX_INVALID, //eATTACK_TYPE_SKILL, //技能
|
||
#endif //_NA_004965_20120613_NEW_CHARACTER_MYSTIC
|
||
//eATTACK_TYPE_MAX,
|
||
};
|
||
#ifdef _NA_004965_20120613_NEW_CHARACTER_MYSTIC
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Physicals::kToPhysicalIndex) == 14));
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Elements::kToElementIndex) == 14));
|
||
#else
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Physicals::kToPhysicalIndex) == 13));
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Elements::kToElementIndex) == 13));
|
||
#else
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Physicals::kToPhysicalIndex) == 14));
|
||
BOOST_STATIC_ASSERT((_countof(Attributes::Elements::kToElementIndex) == 14));
|
||
#endif
|
||
#endif
|
||
//
|
||
// Unused ...
|
||
void Attributes::RegisterAttr(eATTR_TYPE attr_type, AttrValue* attr_value,
|
||
eBOUNDTYPE bound_type, eUPDATETYPE update_type)
|
||
{
|
||
ASSERT(attr_type < eATTR_MAX);
|
||
attr_values_[attr_type].attr_value = attr_value;
|
||
|
||
if (attr_value) {
|
||
attr_value->SetType(bound_type, update_type);
|
||
}
|
||
}
|
||
|
||
Attributes::Attributes()
|
||
{
|
||
RegisterAll();
|
||
}
|
||
|
||
Attributes::~Attributes()
|
||
{
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------------------------
|
||
|
||
// NOTE: f110217.4L, 添加不使用运算符的接口函数类型属性
|
||
int Attributes::GetAttrValue(eATTR_TYPE attr_type, eATTR_KIND attr_kind) const
|
||
{
|
||
if (attr_type < eATTR_MAX && attr_kind < eATTR_KIND_MAX)
|
||
{
|
||
const AttrValue* attr_value = attr_values_[attr_type].attr_value;
|
||
if (attr_value && attr_value != &attr_value_static_) {
|
||
return (*attr_value)[attr_kind];
|
||
}
|
||
assert(attr_value && attr_value != &attr_value_static_);
|
||
return 0;
|
||
}
|
||
assert(attr_type < eATTR_MAX && attr_kind < eATTR_KIND_MAX);
|
||
return 0;
|
||
}
|
||
|
||
void Attributes::SetAttrValue(eATTR_TYPE attr_type, eATTR_KIND attr_kind, int value)
|
||
{
|
||
if (attr_type < eATTR_MAX && attr_kind < eATTR_KIND_MAX)
|
||
{
|
||
AttrValue* attr_value = attr_values_[attr_type].attr_value;
|
||
if (attr_value && attr_value != &attr_value_static_) {
|
||
(*attr_value)[attr_kind].value_ = value;
|
||
return;
|
||
}
|
||
assert(attr_value && attr_value != &attr_value_static_);
|
||
return;
|
||
}
|
||
assert(attr_type < eATTR_MAX && attr_kind < eATTR_KIND_MAX);
|
||
}
|
||
|
||
//--------------------------------------------------------------------------------------------------
|
||
|
||
// (f100720.3L) 特殊用途接口
|
||
// eATTR_KIND_SKILL = clear fields { eATTR_KIND_SKILL, eATTR_KIND_SKILL_RATIO }
|
||
// eATTR_KIND_ITEM = clear fields { eATTR_KIND_ITEM, eATTR_KIND_ITEM_RATIO }
|
||
void Attributes::ClearRelatedAttrKind(eATTR_KIND attr_kind)
|
||
{
|
||
if (false);
|
||
else if (attr_kind == eATTR_KIND_ITEM)
|
||
{
|
||
AttrNode* it = attr_values_,
|
||
* const end = &attr_values_[eATTR_MAX];
|
||
for ( ; it != end; ++it)
|
||
{
|
||
AttrValue* attr_value = it->attr_value;
|
||
if (attr_value == NULL) {
|
||
continue;
|
||
}
|
||
attr_value->item_value_.value_ = 0;
|
||
attr_value->item_ratio_.value_ = 0;
|
||
}
|
||
}
|
||
else if (attr_kind == eATTR_KIND_SKILL)
|
||
{
|
||
AttrNode* it = attr_values_,
|
||
* const end = &attr_values_[eATTR_MAX];
|
||
for ( ; it != end; ++it)
|
||
{
|
||
AttrValue* attr_value = it->attr_value;
|
||
if (attr_value == NULL) {
|
||
continue;
|
||
}
|
||
attr_value->skill_value_.value_ = 0;
|
||
attr_value->skill_ratio_.value_ = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool Attributes::GroupOperate(const Operation::eOper operate_cmd, const eATTR_KIND attr_kind,
|
||
const Operation* attr_array, const int* value_array,
|
||
const int number_of_data)
|
||
{
|
||
if (number_of_data <= 0 ||
|
||
operate_cmd >= attr_array->eOper_Counts ||
|
||
attr_kind >= eATTR_KIND_MAX)
|
||
{
|
||
return false;
|
||
}
|
||
const Operation* attr_it = attr_array;
|
||
for (int index = 0; index < number_of_data; ++index, ++attr_it)
|
||
{
|
||
if (attr_it->attr_type == eATTR_TYPE_INVALID ||
|
||
attr_it->attr_type >= eATTR_MAX)
|
||
{
|
||
return false;
|
||
}
|
||
const int value = value_array[index];
|
||
if (operate_cmd != attr_it->eOper_Set && value == 0) {
|
||
continue;
|
||
}
|
||
|
||
AttrValue* const attr_value = attr_values_[attr_it->attr_type].attr_value;
|
||
if (attr_value == NULL || attr_value == &attr_value_static_) {
|
||
continue;
|
||
}
|
||
|
||
INTValue* int_value = NULL;
|
||
switch (attr_kind)
|
||
{
|
||
case eATTR_KIND_BASE:
|
||
int_value = &attr_value->base_value_;
|
||
break;
|
||
case eATTR_KIND_ITEM:
|
||
int_value = &attr_value->item_value_;
|
||
break;
|
||
case eATTR_KIND_SKILL:
|
||
int_value = &attr_value->skill_value_;
|
||
break;
|
||
case eATTR_KIND_ITEM_RATIO:
|
||
int_value = &attr_value->item_ratio_;
|
||
break;
|
||
case eATTR_KIND_SKILL_RATIO:
|
||
int_value = &attr_value->skill_ratio_;
|
||
break;
|
||
};
|
||
if (int_value == NULL) {
|
||
continue;
|
||
};
|
||
//
|
||
|
||
switch (operate_cmd)
|
||
{
|
||
case attr_it->eOper_Set:
|
||
int_value->value_ = value;
|
||
break;
|
||
case attr_it->eOper_Add:
|
||
int_value->value_ += value;
|
||
break;
|
||
case attr_it->eOper_Sub:
|
||
int_value->value_ -= value;
|
||
break;
|
||
//case attr_it->eOper_Mul:
|
||
// int_value->value_ *= value;
|
||
// break;
|
||
//case attr_it->eOper_Div:
|
||
// if (value != 0) {
|
||
// int_value->value_ /= value;
|
||
// }
|
||
break;
|
||
};
|
||
} //cmd_end 'for'
|
||
return true;
|
||
}
|
||
|
||
// (f100809.3L) 外部多操作命令支持接口，支持记录更新
|
||
bool Attributes::GroupBatchOperate(const OperationRecord* records, const int number_of_records)
|
||
{
|
||
if (number_of_records <= 0) {
|
||
return false;
|
||
}
|
||
const OperationRecord* record_it = records;
|
||
for (int index = 0; index < number_of_records; ++index, ++record_it)
|
||
{
|
||
if (record_it->operate >= Operation::eOper_Counts ||
|
||
record_it->attr_kind >= eATTR_KIND_MAX ||
|
||
record_it->attr_type == eATTR_TYPE_INVALID ||
|
||
record_it->attr_type >= eATTR_MAX)
|
||
{
|
||
return false;
|
||
}
|
||
const int value = record_it->attr_value;
|
||
if (record_it->operate != Operation::eOper_Set && value == 0) {
|
||
continue;
|
||
}
|
||
//
|
||
AttrValue* const attr_value = attr_values_[record_it->attr_type].attr_value;
|
||
if (attr_value == NULL || attr_value == &attr_value_static_) {
|
||
continue;
|
||
}
|
||
//
|
||
INTValue* int_value = NULL;
|
||
switch (record_it->attr_kind)
|
||
{
|
||
case eATTR_KIND_BASE:
|
||
int_value = &attr_value->base_value_;
|
||
break;
|
||
case eATTR_KIND_ITEM:
|
||
int_value = &attr_value->item_value_;
|
||
break;
|
||
case eATTR_KIND_SKILL:
|
||
int_value = &attr_value->skill_value_;
|
||
break;
|
||
case eATTR_KIND_ITEM_RATIO:
|
||
int_value = &attr_value->item_ratio_;
|
||
break;
|
||
case eATTR_KIND_SKILL_RATIO:
|
||
int_value = &attr_value->skill_ratio_;
|
||
break;
|
||
};
|
||
if (int_value == NULL) {
|
||
continue;
|
||
};
|
||
//
|
||
|
||
switch (record_it->operate)
|
||
{
|
||
case Operation::eOper_Set:
|
||
int_value->value_ = value;
|
||
break;
|
||
case Operation::eOper_Add:
|
||
int_value->value_ += value;
|
||
break;
|
||
case Operation::eOper_Sub:
|
||
int_value->value_ -= value;
|
||
break;
|
||
//case Operation::eOper_Mul:
|
||
// int_value->value_ *= value;
|
||
// break;
|
||
//case Operation::eOper_Div:
|
||
// if (value != 0) {
|
||
// int_value->value_ /= value;
|
||
// }
|
||
break;
|
||
};
|
||
} //cmd_end 'for'
|
||
return true;
|
||
}
|
||
|
||
#if !defined(_SERVER)
|
||
int Attributes::GetAttrMaxBoundValue(eATTR_TYPE attr_type) const
|
||
{
|
||
if (attr_type < eATTR_MAX)
|
||
{
|
||
const AttrValue* attr_value = attr_values_[attr_type].attr_value;
|
||
if (attr_value && attr_value != &attr_value_static_) {
|
||
return s_BoundPolicies.GetMaxValue(static_cast<eBOUNDTYPE>(attr_value->bound_type_));
|
||
}
|
||
assert(attr_value && attr_value != &attr_value_static_);
|
||
return 0;
|
||
}
|
||
assert(attr_type < eATTR_MAX);
|
||
return 0;
|
||
}
|
||
#endif //!defined(_SERVER)
|
||
|
||
void Attributes::RegisterAll(bool is_reuse_data)
|
||
{
|
||
if (is_reuse_data == false) {
|
||
ZeroMemory(attr_values_,
|
||
static_cast<size_t>(last_field_end_ - reinterpret_cast<int8_t*>(attr_values_)));
|
||
};
|
||
assert(((&m_ArmorPhysicalAvoidRate + 1) == &m_MoveSpeedRatio) &&
|
||
((&m_MoveSpeedRatio + 1) == &m_AttSpeedRatio));
|
||
//==================================================================================================
|
||
#if defined(_DEBUG) || defined(_SERVER)
|
||
#define REGISTER_ATTR(AttrType, AttrValuePtr, BoundType, UpdateType, Desc) \
|
||
;{ \
|
||
BOOST_STATIC_ASSERT(AttrType < eATTR_MAX); \
|
||
AttrNode* node = &attr_values_[AttrType]; \
|
||
node->attr_value = AttrValuePtr; \
|
||
node->attr_type = AttrType; \
|
||
node->attr_type_str = #AttrType; \
|
||
node->attr_field = #AttrValuePtr;\
|
||
node->attr_desc = Desc; \
|
||
if (AttrValuePtr) { \
|
||
(AttrValuePtr)->bound_type_ = (BoundType); \
|
||
(AttrValuePtr)->update_type_ = (UpdateType); \
|
||
} \
|
||
};
|
||
#else
|
||
#define REGISTER_ATTR(AttrType, AttrValuePtr, BoundType, UpdateType, Desc) \
|
||
;{ \
|
||
BOOST_STATIC_ASSERT(AttrType < eATTR_MAX); \
|
||
AttrNode* node = &attr_values_[AttrType]; \
|
||
node->attr_value = AttrValuePtr; \
|
||
if (AttrValuePtr) { \
|
||
(AttrValuePtr)->bound_type_ = (BoundType); \
|
||
(AttrValuePtr)->update_type_ = (UpdateType); \
|
||
} \
|
||
};
|
||
#endif
|
||
//==================================================================================================
|
||
#define REGISTER_ATTR_UNUSED(AttrType) \
|
||
REGISTER_ATTR(AttrType, &attr_value_static_, eBOUNDTYPE_MAX, eUPDATETYPE_NOT_RATIO, "")
|
||
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
#define REGISTER_ATTR_EP1(AttrType, AttrValuePtr, BoundType, UpdateType, Desc) \
|
||
REGISTER_ATTR_UNUSED(##AttrType)
|
||
#else
|
||
#define REGISTER_ATTR_EP1(AttrType, AttrValuePtr, BoundType, UpdateType, Desc) \
|
||
REGISTER_ATTR(AttrType, AttrValuePtr, BoundType, UpdateType, Desc)
|
||
#endif
|
||
//==================================================================================================
|
||
// initialize all
|
||
for (AttrNode* it = attr_values_; it != &attr_values_[_countof(attr_values_)]; ++it) {
|
||
it->attr_value = &attr_value_static_;
|
||
};
|
||
//
|
||
//REGISTER_ATTR(eATTR_TYPE_INVALID, NULL,
|
||
// eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
// "无效的属性");
|
||
//
|
||
;{
|
||
REGISTER_ATTR(eATTR_STR, &m_STR,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"23:增加力量");
|
||
REGISTER_ATTR(eATTR_DEX, &m_DEX,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"24:增加敏捷性");
|
||
REGISTER_ATTR(eATTR_VIT, &m_VIT,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"25:增加体力");
|
||
REGISTER_ATTR(eATTR_INT, &m_INT,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"26:增加智力");
|
||
REGISTER_ATTR(eATTR_SPR, &m_SPR,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"27:增加精神力");
|
||
};
|
||
;{
|
||
REGISTER_ATTR_EP1(eATTR_EXPERTY1, &m_Experty1,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"技能1");
|
||
REGISTER_ATTR_EP1(eATTR_EXPERTY2, &m_Experty2,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"技能2");
|
||
};
|
||
;{
|
||
// HP, MP
|
||
REGISTER_ATTR(eATTR_MAX_HP, &m_MaxHP,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"28:最大 HP");
|
||
REGISTER_ATTR(eATTR_MAX_MP, &m_MaxMP,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"29:最大 MP/SP");
|
||
REGISTER_ATTR(eATTR_CUR_HP, &m_CurHP,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"当前 HP");
|
||
REGISTER_ATTR(eATTR_CUR_MP, &m_CurMP,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"当前 MP");
|
||
REGISTER_ATTR(eATTR_RECOVERY_HP, &m_RecoverHP,
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"39:HP 恢复量");
|
||
REGISTER_ATTR(eATTR_RECOVERY_MP, &m_RecoverMP,
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"40:MP 恢复量");
|
||
};
|
||
//-----------------------------------------------------------------
|
||
//攻击相关参数
|
||
//-----------------------------------------------------------------
|
||
;{
|
||
//基础物理和魔法攻击力
|
||
REGISTER_ATTR(eATTR_BASE_MELEE_MIN_ATTACK_POWER, &m_BaseMeleeMinAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"最低基础物理攻击");
|
||
REGISTER_ATTR(eATTR_BASE_MELEE_MAX_ATTACK_POWER, &m_BaseMeleeMaxAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"最大基础物理攻击力");
|
||
REGISTER_ATTR(eATTR_BASE_RANGE_MIN_ATTACK_POWER, &m_BaseRangeMinAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"基础范围内的最小攻击伤害");
|
||
REGISTER_ATTR(eATTR_BASE_RANGE_MAX_ATTACK_POWER, &m_BaseRangeMaxAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"基础范围内最大攻击力");
|
||
REGISTER_ATTR_EP1(eATTR_BASE_MAGICAL_MIN_ATTACK_POWER, &m_BaseMagicMinAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"最低基础魔法攻击");
|
||
REGISTER_ATTR_EP1(eATTR_BASE_MAGICAL_MAX_ATTACK_POWER, &m_BaseMagicMaxAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"最大基础魔法攻击");
|
||
};
|
||
;{
|
||
//可选的物理和魔法攻击力
|
||
REGISTER_ATTR(eATTR_OPTION_PHYSICAL_ATTACK_POWER, &m_OptionPhysicalAttPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"47:可选物理攻击力");
|
||
REGISTER_ATTR_EP1(eATTR_OPTION_MAGICAL_ATTACK_POWER, &m_OptionMagicAttPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"48:可选魔法攻击");
|
||
REGISTER_ATTR_EP1(eATTR_OPTION_ALL_ATTACK_POWER, &m_OptionAllAttPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"21:可选总攻击");
|
||
};
|
||
;{
|
||
//魔法攻击力
|
||
REGISTER_ATTR(eATTR_MAGICAL_WATER_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_WATER],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"4:增加魔法属性攻击力（水）");
|
||
REGISTER_ATTR(eATTR_MAGICAL_FIRE_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_FIRE],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"3:增加魔法属性攻击力（火）");
|
||
REGISTER_ATTR(eATTR_MAGICAL_WIND_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_WIND],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"6:增加魔法属性攻击力（风）");
|
||
REGISTER_ATTR(eATTR_MAGICAL_EARTH_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_EARTH],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"5:增加魔法属性攻击力（土）");
|
||
REGISTER_ATTR(eATTR_MAGICAL_DARKNESS_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_DARKNESS],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"7增加魔法属性攻击力（暗）");
|
||
REGISTER_ATTR(eATTR_MAGICAL_DIVINE_ATTACK_POWER,
|
||
&m_MagicalAttPower[eATTACK_TYPE_DIVINE],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"");
|
||
|
||
REGISTER_ATTR(eATTR_MAGICAL_ALL_ATTACK_POWER, &m_MagicalAllAttPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"35:增加了所有元素攻击力");
|
||
};
|
||
;{
|
||
//技能攻击力、技能百分比附加伤害
|
||
REGISTER_ATTR(eATTR_ADD_SKILL_ATTACK_POWER, &m_SkillAttackPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"30:技能攻击");
|
||
REGISTER_ATTR(eATTR_ADD_SKILL_DAMAGE_RATIO, &m_SkillPercentDamage,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"31:技能伤害加成率：技能额外伤害百分比");
|
||
// eBOUNDTYPE_ZP_1000->INFINITE 변경[CHANGUP_INTENSIFY_SKILLDAMAGE_STATUS]
|
||
};
|
||
//-----------------------------------------------------------------
|
||
// 防御相关参数
|
||
//-----------------------------------------------------------------
|
||
;{
|
||
//基础物理和魔法防御
|
||
REGISTER_ATTR(eATTR_BASE_MELEE_DEFENSE_POWER, &m_BaseMeleeDefPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"基本物理防御");
|
||
REGISTER_ATTR(eATTR_BASE_RANGE_DEFENSE_POWER, &m_BaseRangeDefPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"根据地物理防御");
|
||
REGISTER_ATTR_EP1(eATTR_BASE_MAGICAL_DEFENSE_POWER, &m_BaseMagicDefPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"基础魔法防御");
|
||
};
|
||
;{
|
||
//可选的物理和魔法防御
|
||
REGISTER_ATTR(eATTR_OPTION_PHYSICAL_DEFENSE_POWER, &m_OptionPhysicalDefPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"49:增加物理防御");
|
||
REGISTER_ATTR_EP1(eATTR_OPTION_MAGICAL_DEFENSE_POWER, &m_OptionMagicDefPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"50:添加魔法防御");
|
||
REGISTER_ATTR_EP1(eATTR_OPTION_ALL_DEFENSE_POWER, &m_OptionAllDefPower,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"22:增加总防御（物理+魔法）");
|
||
};
|
||
;{
|
||
//魔法防御（最低）
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_WATER_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_WATER],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"17:增加魔法属性抗性（水）");
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_FIRE_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_FIRE],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"16:增加魔法属性抗性（火）");
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_WIND_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_WIND],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"19:增加魔法属性抗性（风）");
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_EARTH_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_EARTH],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"18:增加魔法属性抗性（土）");
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_DARKNESS_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_DARKNESS],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"20:增加魔法属性抗性（暗）");
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_DIVINE_DEFENSE_POWER,
|
||
&m_MagicalDefPower[eATTACK_TYPE_DIVINE],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"");
|
||
|
||
REGISTER_ATTR_EP1(eATTR_MAGICAL_ALL_DEFENSE_POWER,
|
||
&m_MagicalAllDefPower,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"36:新增全属性防御");
|
||
};
|
||
;{
|
||
//攻击类型的额外防御
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ALL_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_ALL_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"针对所有攻击类型的额外防御");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_MELEE_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_MELEE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"添加近战攻击防御");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RANGE_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_RANGE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"增加范围攻击防御");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_WATER_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_WATER],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(水)攻击防御添加");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_FIRE_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_FIRE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(火)攻击防御增加");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_WIND_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_WIND],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（风）攻击防御添加");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_EARTH_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_EARTH],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（土）攻击防御添加");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_DARKNESS_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_DARKNESS],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（暗）攻击防御添加");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_DIVINE_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_DIVINE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(城堡)增加攻击防御");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_PHYSICAL_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_PHYSICAL_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"增加了（物理）攻击防御");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_MAGICAL_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_MAGIC_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(魔法) 攻击防御加成");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_MAGICAL_ALL_DEFENSE_POWER,
|
||
&m_BonusDefense[eATTACK_TYPE_ALL_MAGIC],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(全魔法)攻击防御加成");
|
||
};
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
;{
|
||
//攻击目标的防御降低率
|
||
REGISTER_ATTR(eATTR_DEL_PHYSICAL_TARGET_DEFENSE_RATIO,
|
||
&m_ReducePhysicalTargetDefenseRatio,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"8:降低目标对物理攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_WATER_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatio[Elements::kToElementIndex[eATTACK_TYPE_WATER]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"10:降低目标对元素（水）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_FIRE_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatio[Elements::kToElementIndex[eATTACK_TYPE_FIRE]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"9:降低目标对元素（火）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_WIND_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatio[Elements::kToElementIndex[eATTACK_TYPE_WIND]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"12:降低目标对元素（风）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_EARTH_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatio[Elements::kToElementIndex[eATTACK_TYPE_EARTH]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"11:降低目标对元素（土）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_DARKNESS_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatio[Elements::kToElementIndex[eATTACK_TYPE_DARKNESS]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"13:降低目标对元素（暗）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_MAGICAL_ALL_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceElementTargetDefenseRatioAll,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"降低目标对元素（所有元素）攻击的防御率");
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_ALL_TARGET_DEFENSE_RATIO);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_MELEE_TARGET_DEFENSE_RATIO);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_RANGE_TARGET_DEFENSE_RATIO);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_DIVINE_TARGET_DEFENSE_RATIO);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_MAGICAL_TARGET_DEFENSE_RATIO);
|
||
};
|
||
#else
|
||
;{
|
||
//攻击目标的防御降低率
|
||
REGISTER_ATTR_EP1(eATTR_DEL_ALL_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_ALL_OPTION],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"降低目标对（所有）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_MELEE_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_MELEE],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"降低目标对（近战）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_RANGE_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_RANGE],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"(Range) 降低目标对攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_WATER_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_WATER],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"10:降低目标对（水）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_FIRE_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_FIRE],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"9:(火) 降低目标对攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_WIND_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_WIND],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"12:降低目标对（风）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_EARTH_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_EARTH],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"11:降低目标对（地）攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_DARKNESS_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_DARKNESS],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"13:（暗）目标对攻击的防御降低率");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_DIVINE_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_DIVINE],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"（神圣）降低目标防御攻击的速度");
|
||
REGISTER_ATTR(eATTR_DEL_PHYSICAL_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_PHYSICAL_OPTION],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"8:(物理)降低目标对攻击的防御率");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_MAGICAL_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_MAGIC_OPTION],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"(魔法) 降低目标对攻击的防御率");
|
||
REGISTER_ATTR(eATTR_DEL_MAGICAL_ALL_TARGET_DEFENSE_RATIO,
|
||
&m_ReduceDefenseRate[eATTACK_TYPE_ALL_MAGIC],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"(全魔法) 降低目标对攻击的防御率");
|
||
};
|
||
#endif
|
||
//-----------------------------------------------------------------
|
||
//损坏相关参数
|
||
//-----------------------------------------------------------------
|
||
;{
|
||
//护甲类型的额外伤害
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ARMOR_HARD_DAMAGE, &m_BonusDamage[eARMOR_HARD],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(Hard)对装甲的额外伤害");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ARMOR_MEDIUM_DAMAGE, &m_BonusDamage[eARMOR_MEDIUM],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(Medium)对装甲的额外伤害");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ARMOR_SOFT_DAMAGE, &m_BonusDamage[eARMOR_SOFT],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(Soft)对装甲的额外伤害");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ARMOR_SIEGE_DAMAGE, &m_BonusDamage[eARMOR_SIEGE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(Siege)对装甲的额外伤害");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_ARMOR_UNARMOR_DAMAGE, &m_BonusDamage[eARMOR_UNARMOR],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"(Unarmor)对装甲的额外伤害");
|
||
};
|
||
;{
|
||
//护甲类型的额外伤害（百分比）
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RATIO_ARMOR_HARD_DAMAGE, &m_BonusPercentDamage[eARMOR_HARD],
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"(Hard)对护甲的额外伤害（比率值）");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RATIO_ARMOR_MEDIUM_DAMAGE, &m_BonusPercentDamage[eARMOR_MEDIUM],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"(Medium)对护甲的额外伤害（比率值）");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RATIO_ARMOR_SOFT_DAMAGE, &m_BonusPercentDamage[eARMOR_SOFT],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"(Soft)对护甲的额外伤害（比率值）");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RATIO_ARMOR_SIEGE_DAMAGE, &m_BonusPercentDamage[eARMOR_SIEGE],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"（攻城）对护甲的额外伤害（百分比值）");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_RATIO_ARMOR_UNARMOR_DAMAGE, &m_BonusPercentDamage[eARMOR_UNARMOR],
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"(Unarmor) 对护甲的额外伤害（百分比值）");
|
||
};
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
;{
|
||
REGISTER_ATTR(eATTR_DEL_PHYSICAL_DAMAGE,
|
||
&m_ReducePhysicalDamageRatio,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"对物理攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_WATER_DAMAGE,
|
||
&m_ReduceElementDamageRatio[Elements::kToElementIndex[eATTACK_TYPE_WATER]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（水）攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_FIRE_DAMAGE,
|
||
&m_ReduceElementDamageRatio[Elements::kToElementIndex[eATTACK_TYPE_FIRE]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（火）攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_WIND_DAMAGE,
|
||
&m_ReduceElementDamageRatio[Elements::kToElementIndex[eATTACK_TYPE_WIND]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（风）攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_EARTH_DAMAGE,
|
||
&m_ReduceElementDamageRatio[Elements::kToElementIndex[eATTACK_TYPE_EARTH]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（土）攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_DARKNESS_DAMAGE,
|
||
&m_ReduceElementDamageRatio[Elements::kToElementIndex[eATTACK_TYPE_DARKNESS]],
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（暗）攻击的伤害减免率");
|
||
REGISTER_ATTR(eATTR_DEL_MAGICAL_ALL_DAMAGE,
|
||
&m_ReduceElementDamageRatioAll,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"元素（所有）攻击的伤害减免率");
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_ALL_DAMAGE);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_MELEE_DAMAGE);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_RANGE_DAMAGE);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_DIVINE_DAMAGE);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_PHYSICAL_DAMAGE);
|
||
REGISTER_ATTR_UNUSED(eATTR_DEL_MAGICAL_DAMAGE);
|
||
};
|
||
#else
|
||
;{
|
||
REGISTER_ATTR_EP1(eATTR_DEL_ALL_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_ALL_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（所有）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_MELEE_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_MELEE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（近战）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_RANGE_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_RANGE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（范围）对攻击的伤害减免");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_WATER_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_WATER],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（水）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_FIRE_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_FIRE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（火）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_WIND_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_WIND],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（风）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_EARTH_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_EARTH],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（土）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_DARKNESS_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_DARKNESS],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"减少对（暗）攻击的伤害");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_DIVINE_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_DIVINE],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（神圣）对攻击的伤害减免");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_PHYSICAL_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_PHYSICAL_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（物理）对攻击的伤害减免");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_MAGICAL_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_MAGIC_OPTION],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（魔法）对攻击的伤害减免");
|
||
REGISTER_ATTR_EP1(eATTR_DEL_MAGICAL_ALL_DAMAGE, &m_ReduceDamage[eATTACK_TYPE_ALL_MAGIC],
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"（全魔法）对攻击的伤害减免");
|
||
};
|
||
#endif
|
||
;{
|
||
//攻击成功率、回避率
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
uint8_t update_type_select = eUPDATETYPE_NOTHING;
|
||
#else
|
||
uint8_t update_type_select = eUPDATETYPE_SUM_RATIO;
|
||
#endif
|
||
REGISTER_ATTR(eATTR_PHYSICAL_ATTACK_SUCCESS_RATIO, &m_PhysicalAttackRate,
|
||
eBOUNDTYPE_ZP_10000, update_type_select,
|
||
"2:整体物理攻击成功率（百分比）");
|
||
REGISTER_ATTR(eATTR_PHYSICAL_ATTACK_BLOCK_RATIO, &m_PhysicalAvoidRate,
|
||
eBOUNDTYPE_ZP_10000, update_type_select,
|
||
"15:[R][ 15]攻防率(Option) 加成率(Ratio)");
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
REGISTER_ATTR(eATTR_PHYSICAL_ATTACK_BLOCK_BASE_ARMOR_RATIO, &m_ArmorPhysicalAvoidRate,
|
||
eBOUNDTYPE_ZP_10000, eUPDATETYPE_NOTHING,
|
||
"EP2:added,总攻防率项（总和/5）");
|
||
#endif
|
||
};
|
||
;{
|
||
REGISTER_ATTR(eATTR_MOVE_SPEED, &m_MoveSpeedRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOTHING,
|
||
"14:增加移动速度");
|
||
REGISTER_ATTR(eATTR_ATTACK_SPEED, &m_AttSpeedRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOTHING,
|
||
"1:增加了整体攻击速度");
|
||
};
|
||
;{
|
||
REGISTER_ATTR(eATTR_ALL_ATTACK_RANGE, &m_AllRangeBonus,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"所有攻击范围");
|
||
REGISTER_ATTR(eATTR_NORMAL_ATTACK_RANGE, &m_NormalRangeBonus,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"普通攻击范围");
|
||
REGISTER_ATTR(eATTR_SKILL_ATTACK_RANGE, &m_SkillRangeBonus,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"技能范围");
|
||
};
|
||
;{
|
||
REGISTER_ATTR(eATTR_SIGHT_RANGE, &m_SightRange,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"视线");
|
||
};
|
||
;{
|
||
REGISTER_ATTR(eATTR_CRITICAL_RATIO_CHANGE, &m_CriticalRatioChange,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"暴击几率增加或减少");
|
||
REGISTER_ATTR_EP1(eATTR_ADD_MAGICAL_CRITICAL_RATIO, &m_MagicCriticalRatio,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"添加魔法暴击率");
|
||
REGISTER_ATTR(eATTR_ADD_ALL_CRITICAL_RATIO, &m_CriticalRatioBonus,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_NOT_RATIO,
|
||
"41:增加了整体暴击率");
|
||
REGISTER_ATTR(eATTR_CRITICAL_DAMAGE_CHANGE, &m_CriticalDamageBonus,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"42:增加致命伤害");
|
||
};
|
||
;{
|
||
REGISTER_ATTR(eATTR_ADD_ATTACK_INC_RATIO, &m_AttackIncRate,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"增加额外攻击的机会（百分比）");
|
||
REGISTER_ATTR(eATTR_ADD_DEFENSE_INC_RATIO, &m_DefenseIncRate,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"增加防御额外攻击的机会（百分比）");
|
||
REGISTER_ATTR(eATTR_INCREASE_SKILL_LEVEL, &m_SkillLevelAll,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"技能等级提升1");
|
||
// (NOTE) 使用选项标志的特殊属性
|
||
//REGISTER_ATTR(eATTR_INCREASE_STAT_POINT, NULL,
|
||
// eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
// "32 添加所有统计信息"); //<没有价值 只有状态.
|
||
};
|
||
;{
|
||
// taiyo
|
||
REGISTER_ATTR(eATTR_DECREASE_LIMIT_STAT, &m_DecreaseLimitStat,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"33:降低统计限制");
|
||
REGISTER_ATTR(eATTR_MP_SPEND_INCREASE, &m_MPSpendIncrease,
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_NOT_RATIO,
|
||
"34:MP消耗增减");
|
||
};
|
||
;{
|
||
//添加了商业项目选项
|
||
REGISTER_ATTR(eATTR_ABSORB_HP, &m_AbsorbHP,
|
||
eBOUNDTYPE_ZP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"37:HP吸收");
|
||
REGISTER_ATTR(eATTR_ABSORB_MP, &m_AbsorbMP,
|
||
eBOUNDTYPE_ZP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"38:MP/SP吸收");
|
||
REGISTER_ATTR(eATTR_REFLECT_DAMAGE_RATIO, &m_ReflectDamageRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"43:伤害反射");
|
||
REGISTER_ATTR(eATTR_BONUS_MONEY_RATIO, &m_BonusMoneyRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"44:奖金增加");
|
||
REGISTER_ATTR(eATTR_BONUS_EXP_RATIO, &m_BonusExpRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"45:经验增加");
|
||
REGISTER_ATTR(eATTR_AREA_ATTACK_RATIO, &m_AreaAttackRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"46:多次攻击概率");
|
||
REGISTER_ATTR(eATTR_BONUS_CASTING_TIME, &m_BonusCastingTime,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"65:技能施法时间增加");
|
||
REGISTER_ATTR(eATTR_BONUS_SKILL_COOL_TIME, &m_BonusSkillCoolTime,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"EP2:75:[R]技能冷却增加");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE, &m_DecDamage,
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_NOT_RATIO,
|
||
"51:减少伤害");
|
||
|
||
REGISTER_ATTR(eATTR_RESURRECTION_RATIO, &m_ResurrectionRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"52:死亡时自我复活的机会");
|
||
REGISTER_ATTR(eATTR_DOUBLE_DAMAGE_RATIO, &m_DoubleDamageRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"53:几率双倍伤害");
|
||
REGISTER_ATTR(eATTR_LUCKMON_INC_DAMAGE, &m_LuckMonIncDamage,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"54:攻击幸运怪物时的额外伤害");
|
||
REGISTER_ATTR(eATTR_COPOSITE_INC_RATIO, &m_CompositeIncRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"55:提高组合成功率");
|
||
REGISTER_ATTR(eATTR_BYPASS_DEFENCE_RATIO, &m_BypassDeffenceRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"56:防御忽略几率");
|
||
// 57最小伤害增加（数量）/减少概率[使用m_iItemRatio作为减少概率]
|
||
REGISTER_ATTR(eATTR_INCREASE_MIN_DAMAGE, &m_IncreaseMinDamage,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"57:最小伤害增加");
|
||
// 58 最大伤害增加（数量）/减少概率[使用m_iItemRatio作为减少率]
|
||
REGISTER_ATTR(eATTR_INCREASE_MAX_DAMAGE, &m_IncreaseMaxDamage,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"58:最大伤害加成");
|
||
REGISTER_ATTR(eATTR_DECREASE_ITEMDURA_RATIO, &m_DecreaseItemDuraRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"59:有几率无视物品耐久度降低");
|
||
//状态抗性几率/技能持续时间
|
||
REGISTER_ATTR(eATTR_RESISTANCE_BADSTATUS_RATIO, &m_ResistBadStatusRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"60:有几率无视技能效果（debuff + 特殊状态）");
|
||
REGISTER_ATTR(eATTR_INCREASE_SKILLDURATION, &m_IncreaseSkillDuration,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"61:技能效果时间增加（buff）");
|
||
REGISTER_ATTR(eATTR_DECREASE_SKILL_SKILLDURATION, &m_DecreaseSkillDuration,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"62:减少技能效果时间（debuff）"); // CHANGES: f110603.2L, f110531.6L
|
||
|
||
// eATTR_TYPE 根据定义移除定义移除
|
||
REGISTER_ATTR(eATTR_OPTION_ETHER_DAMAGE_RATIO, &m_EhterDamageRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"63:以太武器伤害变化");
|
||
REGISTER_ATTR(eATTR_OPTION_ETHER_PvE_DAMAGE_RATIO, &m_EhterPvEDamageRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"76:以太武器伤害变化（PvE）"); // NOTE: f110601.4L
|
||
//__NA_001196_20081110_RECOVERY_ADD_OPTION
|
||
REGISTER_ATTR(eATTR_INCREASE_RESERVE_HP, &m_IncreaseReserveHPRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"64:获得的HP增加");
|
||
|
||
//#ifdef _NA_001231_20081216_ADD_OPTION_KIND
|
||
REGISTER_ATTR(eATTR_RESIST_HOLDING, &m_ResistHolding,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"66:持有阻力");
|
||
REGISTER_ATTR(eATTR_RESIST_SLEEP, &m_ResistSleep,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"67:防滑性");
|
||
REGISTER_ATTR(eATTR_RESIST_POISON, &m_ResistPoison,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"68:毒耐受");
|
||
REGISTER_ATTR(eATTR_RESIST_KNOCKBACK, &m_ResistKnockBack,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"69:击退抗性");
|
||
REGISTER_ATTR(eATTR_RESIST_DOWN, &m_ResistDown,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"70:向下阻力");
|
||
REGISTER_ATTR(eATTR_RESIST_STUN, &m_ResistStun,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"71:眩晕抗性");
|
||
REGISTER_ATTR(eATTR_DECREASE_PVPDAMAGE, &m_DecreasePVPDamage,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"72:PVP伤害减免");
|
||
//#endif
|
||
// __NA_S00015_20080828_NEW_HOPE_SHADOW
|
||
REGISTER_ATTR(eATTR_ADD_DAMAGE, &m_AddDamage,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"73:额外伤害");
|
||
//__NA_1241_AUTO_PICKUP_PET_OPTION
|
||
REGISTER_ATTR(eATTR_AUTO_ITEM_PICK_UP, &m_AutoPickup,
|
||
eBOUNDTYPE_ZP_100, eUPDATETYPE_SUM_RATIO,
|
||
"74:物品自动拾取");
|
||
// _NA_003966_20111227_ADD_ENCHANT
|
||
REGISTER_ATTR(eATTR_INCREASE_ENCHANT_RATIO, &m_IncreaseEnchantRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"77:附魔成功率增加");
|
||
#ifdef _20220109_ADD_ATTACKDECDAMAGE
|
||
REGISTER_ATTR(eATTR_BYPASS_DECDAMAGE, &m_PassDecDamage,
|
||
eBOUNDTYPE_MP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"78:贯穿");
|
||
#endif
|
||
};
|
||
;{
|
||
//__NA_001290_20090525_SHIELD_SYSTEM
|
||
REGISTER_ATTR(eATTR_MAX_SD, &m_MaxSD,
|
||
eBOUNDTYPE_ZP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"93:最大SD");
|
||
REGISTER_ATTR(eATTR_RECOVERY_SD, &m_RecoverSD,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"94:SD恢复量");
|
||
};
|
||
#ifdef _NA_006731_20130521_ENCHANT_ADD_OPTION
|
||
;{
|
||
REGISTER_ATTR(eATTR_ENEMY_CRITICAL_RATIO_CHANGE, &m_EnemyCriticalRatioChange,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"96:攻击时增加/减少对手的暴击率");
|
||
};
|
||
#endif // _NA_006731_20130521_ENCHANT_ADD_OPTION
|
||
;{
|
||
REGISTER_ATTR(eATTR_PREMIUMSERVICE_PCBANG, &m_PCBang,
|
||
eBOUNDTYPE_ZP_100, eUPDATETYPE_NOT_RATIO,
|
||
"97:网吧效果");
|
||
};
|
||
#ifdef _NA_006680_20130426_ITEM_OPTION_ADD_AND_MODIFY
|
||
;{
|
||
REGISTER_ATTR(eATTR_ATTACK_DAMAGE_ABSORB_SD_RATIO, &m_AttackDamageAbsorbSDRatio,
|
||
eBOUNDTYPE_ZP_100, eUPDATETYPE_SUM_RATIO,
|
||
"98:伤害造成的 SD 转换量");
|
||
REGISTER_ATTR(eATTR_ATTACK_DAMAGE_ABSORB_HP_RATIO, &m_AttackDamageAbsorbHPRatio,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"99:造成伤害的HP转换量");
|
||
};
|
||
#endif // _NA_006680_20130426_ITEM_OPTION_ADD_AND_MODIFY
|
||
#ifdef _NA_006937_20131030_ABILITY_AND_STATE_CHANGE_CRITICAL
|
||
;{
|
||
REGISTER_ATTR(eATTR_ENEMY_CRITICAL_DAMAGE_CHANGE, &m_EnemyCriticalDamageChange,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"100:被攻击时增加或减少对手的暴击伤害");
|
||
};
|
||
#endif //_NA_006937_20131030_ABILITY_AND_STATE_CHANGE_CRITICAL
|
||
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
|
||
;{
|
||
REGISTER_ATTR(eATTR_CRAFT_COST_RATIO, &m_CraftCostRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"101:生产成本增减");
|
||
REGISTER_ATTR(eATTR_CRAFT_PREVENT_EXTINCTION_MATERIAL_RATIO, &m_CraftPreventExtinctionMaterialRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"102:生产故障时防止材料损坏");
|
||
REGISTER_ATTR(eATTR_ENCHANT_COST_RATIO, &m_EnchantCostRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"103:附魔费用增加或减少");
|
||
REGISTER_ATTR(eATTR_ENCHANT_PREVENT_DESTROY_N_DOWNGRADE_ITEM_RATIO, &m_EnchantPreventDestroyNDowngradeItemRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"104:附魔失败时防止物品破坏和等级下降");
|
||
REGISTER_ATTR(eATTR_RECOVER_POTION_COOLTIME_RATIO, &m_RecoverPotionCooltimeRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"105:恢复药水冷却时间增加/减少");
|
||
REGISTER_ATTR(eATTR_RECOVER_POTION_RECOVERY_RATIO, &m_RecoverPotionRecoveryRatio,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"106:恢复药水恢复量增减");
|
||
REGISTER_ATTR(eATTR_QUEST_REWARD_EXP_RATIO, &m_QuestRewardExpRatio,
|
||
eBOUNDTYPE_MP_INFINITE, eUPDATETYPE_SUM_RATIO,
|
||
"107:增加或减少任务奖励经验");
|
||
REGISTER_ATTR(eATTR_MAX_DAMAGE_RATIO, &m_MaxDamageRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"108:增加/减少最大伤害几率");
|
||
REGISTER_ATTR(eATTR_DOMINATION_MAPOBJECT_DAMAGE_RATIO, &m_DominationMapobjectDamageRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"109:增加或减少攻城对象伤害");
|
||
REGISTER_ATTR(eATTR_SHOP_REPAIR_HEIM_RATIO, &m_ShopRepairHeimRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"110:店铺维修海姆增减");
|
||
REGISTER_ATTR(eATTR_SHOP_BUY_HEIM_RATIO, &m_ShopBuyHeimRatio,
|
||
eBOUNDTYPE_MP_100, eUPDATETYPE_SUM_RATIO,
|
||
"111:商店购买海姆增加或减少");
|
||
};
|
||
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
|
||
#ifdef _NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
||
REGISTER_ATTR(eATTR_MAX_FP, &m_MaxFP,
|
||
eBOUNDTYPE_ZP_100, eUPDATETYPE_SUM_RATIO,
|
||
"112:最大 FP");
|
||
REGISTER_ATTR(eATTR_RECOVERY_FP, &m_RecoverFP,
|
||
eBOUNDTYPE_ZP_100, eUPDATETYPE_SUM_RATIO,
|
||
"113:FP恢复量");
|
||
#endif //_NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
||
REGISTER_ATTR(eATTR_INCREASE_DAMAGE_RATIO, &m_IncreaseDamageRatio,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"114:伤害增加");
|
||
#ifdef _NA_008124_20150313_AWAKENING_SYSTEM
|
||
REGISTER_ATTR(eATTR_AWAKENING_PROBABILITY, &m_AwakeningProbability,
|
||
eBOUNDTYPE_MP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"115:觉醒概率增加/减少");
|
||
#endif // _NA_008124_20150313_AWAKENING_SYSTEM
|
||
#ifdef _NA_008486_20150914_TOTAL_BALANCE
|
||
REGISTER_ATTR(eATTR_DEBUFF_DURATION, &m_DebuffDuration,
|
||
eBOUNDTYPE_ZP_10000, eUPDATETYPE_SUM_RATIO,
|
||
"116:减益效果持续时间增强");
|
||
#endif //_NA_008486_20150914_TOTAL_BALANCE
|
||
|
||
#ifdef _NA_008540_20151027_ADD_ITEMOPTION_ELITE4
|
||
;{
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_NPC, &m_DecreaseDamageNPC,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"117:减少 NPC 造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_BERSERKER, &m_DecreaseDamageBerserker,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"118:减少狂战士造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_DRAGONKNIGHT, &m_DecreaseDamageDragonKnight,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"119:减少龙骑士造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_VALKYRIE, &m_DecreaseDamageValkyrie,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"120:降低瓦尔基里造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_ELEMENTALIST, &m_DecreaseDamageElementalist,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"121:减少元素使造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_SHADOW, &m_DecreaseDamageShadow,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"122:减少阴影造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_MYSTIC, &m_DecreaseDamageMystic,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"123:减少神秘主义者造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_HELLROID, &m_DecreaseDamageHellroid,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"124:降低 Helloids 造成的伤害");
|
||
REGISTER_ATTR(eATTR_DECREASE_DAMAGE_WITCHBLADE, &m_DecreaseDamageWitchBlade,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOT_RATIO,
|
||
"125:女巫之刃造成的伤害降低");
|
||
REGISTER_ATTR(eATTR_INCREASE_SKILL_LEVEL, &m_SkillLevelAll,
|
||
eBOUNDTYPE_ZP_1000, eUPDATETYPE_SUM_RATIO,
|
||
"126:技能等级提升1");
|
||
#ifdef _NA_003740_20210704_SKILL_LEVLEUP_OPTION
|
||
REGISTER_ATTR(eATTR_LEVELUP_SKILL,&m_SkillLevelUp, //技能等级提升 by:十里坡剑神 2021-07-04
|
||
eBOUNDTYPE_ZP_1000,eUPDATETYPE_NOT_RATIO,
|
||
"技能等级提升");
|
||
#endif //_NA_003740_20210704_SKILL_LEVLEUP_OPTION
|
||
};
|
||
#endif //_NA_008540_20151027_ADD_ITEMOPTION_ELITE4
|
||
|
||
//-----__NA001390_090915_RIDING_SYSTEM__------
|
||
//----这未在 attr_values_ 中注册---
|
||
m_RiderSpeedRatio.SetType(eBOUNDTYPE_ZP_1000, eUPDATETYPE_NOTHING);
|
||
//--------------------------------------------
|
||
|
||
#ifdef _DEBUG
|
||
for (int i = eATTR_TYPE_INVALID + 1; i < eATTR_MAX; ++i)
|
||
{
|
||
if (i != eATTR_INCREASE_STAT_POINT) {
|
||
ASSERT(attr_values_[i].attr_value != NULL);
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
// added by _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
void Attributes::GetDefaultMagicalAttributes(
|
||
Elements* const attack,
|
||
Elements* const rate_of_defense_power_reduction_of_target,
|
||
Elements* const damage_reduction_against_attack) const
|
||
{
|
||
BOOST_STATIC_ASSERT(_countof(attack->values) == _countof(Elements::kElementsMappedArray));
|
||
if (attack) {
|
||
ZeroMemory(attack, sizeof(*attack));
|
||
}
|
||
if (rate_of_defense_power_reduction_of_target) {
|
||
ZeroMemory(rate_of_defense_power_reduction_of_target,
|
||
sizeof(*rate_of_defense_power_reduction_of_target));
|
||
};
|
||
if (damage_reduction_against_attack) {
|
||
ZeroMemory(damage_reduction_against_attack,
|
||
sizeof(*damage_reduction_against_attack));
|
||
};
|
||
#ifdef _NA001605_EP2_ATTRIBUTES_RENEWAL_
|
||
//属性攻击
|
||
if (attack)
|
||
{
|
||
const eATTACK_TYPE* search_it = Elements::kElementsMappedArray;
|
||
for (int* it = attack->values;
|
||
it != &attack->values[_countof(attack->values)];
|
||
++it, ++search_it)
|
||
{
|
||
//属性攻击（基础）
|
||
*it = m_MagicalAttPower[*search_it].calc_value_.value_;
|
||
}
|
||
};
|
||
#if SUN_CODE_BACKUP
|
||
//属性防御
|
||
if (defense)
|
||
{
|
||
const eATTACK_TYPE* search_it = Elements::kElementsMappedArray;
|
||
for (int* it = defense->values;
|
||
it != &defense->values[_countof(defense->values)];
|
||
++it, ++search_it)
|
||
{
|
||
//属性防御（默认）
|
||
*it = m_MagicalDefPower[*search_it].calc_value_.value_;
|
||
//攻击类型的额外防御
|
||
*it += m_BonusDefense[*search_it].calc_value_.value_;
|
||
}
|
||
};
|
||
#endif
|
||
//目标防御降低率
|
||
if (rate_of_defense_power_reduction_of_target)
|
||
{
|
||
const AttrValue* src_attr_it = m_ReduceElementTargetDefenseRatio;
|
||
for (int* it = rate_of_defense_power_reduction_of_target->values;
|
||
it != &rate_of_defense_power_reduction_of_target->values[
|
||
_countof(rate_of_defense_power_reduction_of_target->values)];
|
||
++it, ++src_attr_it)
|
||
{
|
||
*it = src_attr_it->calc_value_.value_;
|
||
}
|
||
};
|
||
//对攻击的伤害减免率
|
||
if (damage_reduction_against_attack)
|
||
{
|
||
const AttrValue* src_attr_it = m_ReduceElementDamageRatio;
|
||
for (int* it = damage_reduction_against_attack->values;
|
||
it != &damage_reduction_against_attack->values[
|
||
_countof(damage_reduction_against_attack->values)];
|
||
++it, ++src_attr_it)
|
||
{
|
||
*it = src_attr_it->calc_value_.value_;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|