Mirroristas/rathena
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Grouped bonus arrays into a single struct (#5454)

Browse Source
This commit is contained in:
Jittapan Pluemsumran 2020-10-19 11:08:11 +07:00 committed by GitHub
parent be3aee7f74
commit 8e84f0e9ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 219 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
src/map/battle.cpp
View File

@ -675,14 +675,14 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
case BF_MAGIC: case BF_MAGIC:
// Affected by attacker ATK bonuses // Affected by attacker ATK bonuses
if( sd && !nk[NK_IGNOREATKCARD] ) { if( sd && !nk[NK_IGNOREATKCARD] ) {
cardfix = cardfix * (100 + sd->magic_addrace[tstatus->race] + sd->magic_addrace[RC_ALL] + sd->magic_addrace2[t_race2]) / 100; cardfix = cardfix * (100 + sd->indexed_bonus.magic_addrace[tstatus->race] + sd->indexed_bonus.magic_addrace[RC_ALL] + sd->indexed_bonus.magic_addrace2[t_race2]) / 100;
if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses
cardfix = cardfix * (100 + sd->magic_addele[tstatus->def_ele] + sd->magic_addele[ELE_ALL] + cardfix = cardfix * (100 + sd->indexed_bonus.magic_addele[tstatus->def_ele] + sd->indexed_bonus.magic_addele[ELE_ALL] +
sd->magic_addele_script[tstatus->def_ele] + sd->magic_addele_script[ELE_ALL]) / 100; sd->indexed_bonus.magic_addele_script[tstatus->def_ele] + sd->indexed_bonus.magic_addele_script[ELE_ALL]) / 100;
cardfix = cardfix * (100 + sd->magic_atk_ele[rh_ele] + sd->magic_atk_ele[ELE_ALL]) / 100; cardfix = cardfix * (100 + sd->indexed_bonus.magic_atk_ele[rh_ele] + sd->indexed_bonus.magic_atk_ele[ELE_ALL]) / 100;
} }
cardfix = cardfix * (100 + sd->magic_addsize[tstatus->size] + sd->magic_addsize[SZ_ALL]) / 100; cardfix = cardfix * (100 + sd->indexed_bonus.magic_addsize[tstatus->size] + sd->indexed_bonus.magic_addsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 + sd->magic_addclass[tstatus->class_] + sd->magic_addclass[CLASS_ALL]) / 100; cardfix = cardfix * (100 + sd->indexed_bonus.magic_addclass[tstatus->class_] + sd->indexed_bonus.magic_addclass[CLASS_ALL]) / 100;
for (const auto &it : sd->add_mdmg) { for (const auto &it : sd->add_mdmg) {
if (it.id == t_class) { if (it.id == t_class) {
cardfix = cardfix * (100 + it.val) / 100; cardfix = cardfix * (100 + it.val) / 100;
@ -697,7 +697,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
cardfix = 1000; // reset var for target cardfix = 1000; // reset var for target
if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses
int ele_fix = tsd->subele[rh_ele] + tsd->subele[ELE_ALL] + tsd->subele_script[rh_ele] + tsd->subele_script[ELE_ALL]; int ele_fix = tsd->indexed_bonus.subele[rh_ele] + tsd->indexed_bonus.subele[ELE_ALL] + tsd->indexed_bonus.subele_script[rh_ele] + tsd->indexed_bonus.subele_script[ELE_ALL];
for (const auto &it : tsd->subele2) { for (const auto &it : tsd->subele2) {
if (it.ele != rh_ele) if (it.ele != rh_ele)
@ -709,13 +709,13 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
ele_fix += it.rate; ele_fix += it.rate;
} }
if (s_defele != ELE_NONE) if (s_defele != ELE_NONE)
ele_fix += tsd->magic_subdefele[s_defele] + tsd->magic_subdefele[ELE_ALL]; ele_fix += tsd->indexed_bonus.magic_subdefele[s_defele] + tsd->indexed_bonus.magic_subdefele[ELE_ALL];
cardfix = cardfix * (100 - ele_fix) / 100; cardfix = cardfix * (100 - ele_fix) / 100;
} }
cardfix = cardfix * (100 - tsd->subsize[sstatus->size] - tsd->subsize[SZ_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subsize[sstatus->size] - tsd->indexed_bonus.subsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 - tsd->magic_subsize[sstatus->size] - tsd->magic_subsize[SZ_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.magic_subsize[sstatus->size] - tsd->indexed_bonus.magic_subsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 - tsd->subrace2[s_race2]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subrace2[s_race2]) / 100;
int race_fix = tsd->subrace[sstatus->race] + tsd->subrace[RC_ALL]; int race_fix = tsd->indexed_bonus.subrace[sstatus->race] + tsd->indexed_bonus.subrace[RC_ALL];
for (const auto &it : tsd->subrace3) { for (const auto &it : tsd->subrace3) {
if (it.race != sstatus->race) if (it.race != sstatus->race)
continue; continue;
@ -726,7 +726,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
race_fix += it.rate; race_fix += it.rate;
} }
cardfix = cardfix * (100 - race_fix) / 100; cardfix = cardfix * (100 - race_fix) / 100;
cardfix = cardfix * (100 - tsd->subclass[sstatus->class_] - tsd->subclass[CLASS_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subclass[sstatus->class_] - tsd->indexed_bonus.subclass[CLASS_ALL]) / 100;
for (const auto &it : tsd->add_mdef) { for (const auto &it : tsd->add_mdef) {
if (it.id == s_class) { if (it.id == s_class) {
@ -755,11 +755,11 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
short cardfix_ = 1000; short cardfix_ = 1000;
if( sd->state.arrow_atk ) { // Ranged attack if( sd->state.arrow_atk ) { // Ranged attack
cardfix = cardfix * (100 + sd->right_weapon.addrace[tstatus->race] + sd->arrow_addrace[tstatus->race] + cardfix = cardfix * (100 + sd->right_weapon.addrace[tstatus->race] + sd->indexed_bonus.arrow_addrace[tstatus->race] +
sd->right_weapon.addrace[RC_ALL] + sd->arrow_addrace[RC_ALL]) / 100; sd->right_weapon.addrace[RC_ALL] + sd->indexed_bonus.arrow_addrace[RC_ALL]) / 100;
if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses
int ele_fix = sd->right_weapon.addele[tstatus->def_ele] + sd->arrow_addele[tstatus->def_ele] + int ele_fix = sd->right_weapon.addele[tstatus->def_ele] + sd->indexed_bonus.arrow_addele[tstatus->def_ele] +
sd->right_weapon.addele[ELE_ALL] + sd->arrow_addele[ELE_ALL]; sd->right_weapon.addele[ELE_ALL] + sd->indexed_bonus.arrow_addele[ELE_ALL];
for (const auto &it : sd->right_weapon.addele2) { for (const auto &it : sd->right_weapon.addele2) {
if (it.ele != tstatus->def_ele) if (it.ele != tstatus->def_ele)
@ -772,11 +772,11 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
} }
cardfix = cardfix * (100 + ele_fix) / 100; cardfix = cardfix * (100 + ele_fix) / 100;
} }
cardfix = cardfix * (100 + sd->right_weapon.addsize[tstatus->size] + sd->arrow_addsize[tstatus->size] + cardfix = cardfix * (100 + sd->right_weapon.addsize[tstatus->size] + sd->indexed_bonus.arrow_addsize[tstatus->size] +
sd->right_weapon.addsize[SZ_ALL] + sd->arrow_addsize[SZ_ALL]) / 100; sd->right_weapon.addsize[SZ_ALL] + sd->indexed_bonus.arrow_addsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 + sd->right_weapon.addrace2[t_race2]) / 100; cardfix = cardfix * (100 + sd->right_weapon.addrace2[t_race2]) / 100;
cardfix = cardfix * (100 + sd->right_weapon.addclass[tstatus->class_] + sd->arrow_addclass[tstatus->class_] + cardfix = cardfix * (100 + sd->right_weapon.addclass[tstatus->class_] + sd->indexed_bonus.arrow_addclass[tstatus->class_] +
sd->right_weapon.addclass[CLASS_ALL] + sd->arrow_addclass[CLASS_ALL]) / 100; sd->right_weapon.addclass[CLASS_ALL] + sd->indexed_bonus.arrow_addclass[CLASS_ALL]) / 100;
} else { // Melee attack } else { // Melee attack
int skill = 0; int skill = 0;
@ -892,7 +892,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
// Affected by target DEF bonuses // Affected by target DEF bonuses
else if( tsd && !nk[NK_IGNOREDEFCARD] && !(left&2) ) { else if( tsd && !nk[NK_IGNOREDEFCARD] && !(left&2) ) {
if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses
int ele_fix = tsd->subele[rh_ele] + tsd->subele[ELE_ALL] + tsd->subele_script[rh_ele] + tsd->subele_script[ELE_ALL]; int ele_fix = tsd->indexed_bonus.subele[rh_ele] + tsd->indexed_bonus.subele[ELE_ALL] + tsd->indexed_bonus.subele_script[rh_ele] + tsd->indexed_bonus.subele_script[ELE_ALL];
for (const auto &it : tsd->subele2) { for (const auto &it : tsd->subele2) {
if (it.ele != rh_ele) if (it.ele != rh_ele)
@ -906,7 +906,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
cardfix = cardfix * (100 - ele_fix) / 100; cardfix = cardfix * (100 - ele_fix) / 100;
if( left&1 && lh_ele != rh_ele ) { if( left&1 && lh_ele != rh_ele ) {
int ele_fix_lh = tsd->subele[lh_ele] + tsd->subele[ELE_ALL] + tsd->subele_script[lh_ele] + tsd->subele_script[ELE_ALL]; int ele_fix_lh = tsd->indexed_bonus.subele[lh_ele] + tsd->indexed_bonus.subele[ELE_ALL] + tsd->indexed_bonus.subele_script[lh_ele] + tsd->indexed_bonus.subele_script[ELE_ALL];
for (const auto &it : tsd->subele2) { for (const auto &it : tsd->subele2) {
if (it.ele != lh_ele) if (it.ele != lh_ele)
@ -920,11 +920,11 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
cardfix = cardfix * (100 - ele_fix_lh) / 100; cardfix = cardfix * (100 - ele_fix_lh) / 100;
} }
cardfix = cardfix * (100 - tsd->subdefele[s_defele] - tsd->subdefele[ELE_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subdefele[s_defele] - tsd->indexed_bonus.subdefele[ELE_ALL]) / 100;
} }
cardfix = cardfix * (100 - tsd->subsize[sstatus->size] - tsd->subsize[SZ_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subsize[sstatus->size] - tsd->indexed_bonus.subsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 - tsd->subrace2[s_race2]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subrace2[s_race2]) / 100;
int race_fix = tsd->subrace[sstatus->race] + tsd->subrace[RC_ALL]; int race_fix = tsd->indexed_bonus.subrace[sstatus->race] + tsd->indexed_bonus.subrace[RC_ALL];
for (const auto &it : tsd->subrace3) { for (const auto &it : tsd->subrace3) {
if (it.race != sstatus->race) if (it.race != sstatus->race)
continue; continue;
@ -935,7 +935,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
race_fix += it.rate; race_fix += it.rate;
} }
cardfix = cardfix * (100 - race_fix) / 100; cardfix = cardfix * (100 - race_fix) / 100;
cardfix = cardfix * (100 - tsd->subclass[sstatus->class_] - tsd->subclass[CLASS_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subclass[sstatus->class_] - tsd->indexed_bonus.subclass[CLASS_ALL]) / 100;
for (const auto &it : tsd->add_def) { for (const auto &it : tsd->add_def) {
if (it.id == s_class) { if (it.id == s_class) {
cardfix = cardfix * (100 - it.val) / 100; cardfix = cardfix * (100 - it.val) / 100;
@ -956,7 +956,7 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
// Affected by target DEF bonuses // Affected by target DEF bonuses
if( tsd && !nk[NK_IGNOREDEFCARD] ) { if( tsd && !nk[NK_IGNOREDEFCARD] ) {
if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses if( !nk[NK_IGNOREELEMENT] ) { // Affected by Element modifier bonuses
int ele_fix = tsd->subele[rh_ele] + tsd->subele[ELE_ALL] + tsd->subele_script[rh_ele] + tsd->subele_script[ELE_ALL]; int ele_fix = tsd->indexed_bonus.subele[rh_ele] + tsd->indexed_bonus.subele[ELE_ALL] + tsd->indexed_bonus.subele_script[rh_ele] + tsd->indexed_bonus.subele_script[ELE_ALL];
for (const auto &it : tsd->subele2) { for (const auto &it : tsd->subele2) {
if (it.ele != rh_ele) if (it.ele != rh_ele)
@ -968,10 +968,10 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
ele_fix += it.rate; ele_fix += it.rate;
} }
if (s_defele != ELE_NONE) if (s_defele != ELE_NONE)
ele_fix += tsd->subdefele[s_defele] + tsd->subdefele[ELE_ALL]; ele_fix += tsd->indexed_bonus.subdefele[s_defele] + tsd->indexed_bonus.subdefele[ELE_ALL];
cardfix = cardfix * (100 - ele_fix) / 100; cardfix = cardfix * (100 - ele_fix) / 100;
} }
int race_fix = tsd->subrace[sstatus->race] + tsd->subrace[RC_ALL]; int race_fix = tsd->indexed_bonus.subrace[sstatus->race] + tsd->indexed_bonus.subrace[RC_ALL];
for (const auto &it : tsd->subrace3) { for (const auto &it : tsd->subrace3) {
if (it.race != sstatus->race) if (it.race != sstatus->race)
continue; continue;
@ -983,9 +983,9 @@ int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_li
} }
cardfix = cardfix * (100 - race_fix) / 100; cardfix = cardfix * (100 - race_fix) / 100;
cardfix = cardfix * (100 - tsd->subsize[sstatus->size] - tsd->subsize[SZ_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subsize[sstatus->size] - tsd->indexed_bonus.subsize[SZ_ALL]) / 100;
cardfix = cardfix * (100 - tsd->subrace2[s_race2]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subrace2[s_race2]) / 100;
cardfix = cardfix * (100 - tsd->subclass[sstatus->class_] - tsd->subclass[CLASS_ALL]) / 100; cardfix = cardfix * (100 - tsd->indexed_bonus.subclass[sstatus->class_] - tsd->indexed_bonus.subclass[CLASS_ALL]) / 100;
cardfix = cardfix * (100 - tsd->bonus.misc_def_rate) / 100; cardfix = cardfix * (100 - tsd->bonus.misc_def_rate) / 100;
if( flag&BF_SHORT ) if( flag&BF_SHORT )
cardfix = cardfix * (100 - tsd->bonus.near_attack_def_rate) / 100; cardfix = cardfix * (100 - tsd->bonus.near_attack_def_rate) / 100;
@ -2050,14 +2050,14 @@ static void battle_add_weapon_damage(struct map_session_data *sd, int64 *damage,
if (lr_type == EQI_HAND_L) { if (lr_type == EQI_HAND_L) {
if (sd->left_weapon.overrefine) if (sd->left_weapon.overrefine)
(*damage) = (*damage) + rnd() % sd->left_weapon.overrefine + 1; (*damage) = (*damage) + rnd() % sd->left_weapon.overrefine + 1;
if (sd->weapon_damage_rate[sd->weapontype2]) if (sd->indexed_bonus.weapon_damage_rate[sd->weapontype2])
(*damage) += (*damage) * sd->weapon_damage_rate[sd->weapontype2] / 100; (*damage) += (*damage) * sd->indexed_bonus.weapon_damage_rate[sd->weapontype2] / 100;
} }
else if (lr_type == EQI_HAND_R) { else if (lr_type == EQI_HAND_R) {
if (sd->right_weapon.overrefine) if (sd->right_weapon.overrefine)
(*damage) = (*damage) + rnd() % sd->right_weapon.overrefine + 1; (*damage) = (*damage) + rnd() % sd->right_weapon.overrefine + 1;
if (sd->weapon_damage_rate[sd->weapontype1]) if (sd->indexed_bonus.weapon_damage_rate[sd->weapontype1])
(*damage) += (*damage) * sd->weapon_damage_rate[sd->weapontype1] / 100; (*damage) += (*damage) * sd->indexed_bonus.weapon_damage_rate[sd->weapontype1] / 100;
} }
} }
@ -2587,7 +2587,7 @@ static bool is_attack_critical(struct Damage* wd, struct block_list *src, struct
short cri = sstatus->cri; short cri = sstatus->cri;
if (sd) { if (sd) {
cri += sd->critaddrace[tstatus->race] + sd->critaddrace[RC_ALL]; cri += sd->indexed_bonus.critaddrace[tstatus->race] + sd->indexed_bonus.critaddrace[RC_ALL];
if(!skill_id && is_skill_using_arrow(src, skill_id)) { if(!skill_id && is_skill_using_arrow(src, skill_id)) {
cri += sd->bonus.arrow_cri; cri += sd->bonus.arrow_cri;
cri += sd->bonus.critical_rangeatk; cri += sd->bonus.critical_rangeatk;
@ -5055,8 +5055,8 @@ static void battle_calc_defense_reduction(struct Damage* wd, struct block_list *
short def2 = tstatus->def2; short def2 = tstatus->def2;
if (sd) { if (sd) {
int i = sd->ignore_def_by_race[tstatus->race] + sd->ignore_def_by_race[RC_ALL]; int i = sd->indexed_bonus.ignore_def_by_race[tstatus->race] + sd->indexed_bonus.ignore_def_by_race[RC_ALL];
i += sd->ignore_def_by_class[tstatus->class_] + sd->ignore_def_by_class[CLASS_ALL]; i += sd->indexed_bonus.ignore_def_by_class[tstatus->class_] + sd->indexed_bonus.ignore_def_by_class[CLASS_ALL];
if (i) { if (i) {
i = min(i,100); //cap it to 100 for 0 def min i = min(i,100); //cap it to 100 for 0 def min
def1 -= def1 * i / 100; def1 -= def1 * i / 100;
@ -6734,9 +6734,9 @@ struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list
} }
if(sd) { if(sd) {
i = sd->ignore_mdef_by_race[tstatus->race] + sd->ignore_mdef_by_race[RC_ALL]; i = sd->indexed_bonus.ignore_mdef_by_race[tstatus->race] + sd->indexed_bonus.ignore_mdef_by_race[RC_ALL];
i += sd->ignore_mdef_by_class[tstatus->class_] + sd->ignore_mdef_by_class[CLASS_ALL]; i += sd->indexed_bonus.ignore_mdef_by_class[tstatus->class_] + sd->indexed_bonus.ignore_mdef_by_class[CLASS_ALL];
i += sd->ignore_mdef_by_race2[status_get_race2(target)]; i += sd->indexed_bonus.ignore_mdef_by_race2[status_get_race2(target)];
if (i) if (i)
{ {
if (i > 100) i = 100; if (i > 100) i = 100;

4
src/map/mob.cpp
View File

@ -2756,8 +2756,8 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
drop_rate = (int)(drop_rate*1.25); drop_rate = (int)(drop_rate*1.25);
// Add class and race specific bonuses // Add class and race specific bonuses
drop_rate_bonus += sd->dropaddclass[md->status.class_] + sd->dropaddclass[CLASS_ALL]; drop_rate_bonus += sd->indexed_bonus.dropaddclass[md->status.class_] + sd->indexed_bonus.dropaddclass[CLASS_ALL];
drop_rate_bonus += sd->dropaddrace[md->status.race] + sd->dropaddrace[RC_ALL]; drop_rate_bonus += sd->indexed_bonus.dropaddrace[md->status.race] + sd->indexed_bonus.dropaddrace[RC_ALL];
// Increase drop rate if user has SC_ITEMBOOST // Increase drop rate if user has SC_ITEMBOOST
if (sd->sc.data[SC_ITEMBOOST]) if (sd->sc.data[SC_ITEMBOOST])

112
src/map/pc.cpp
View File

@ -3030,7 +3030,7 @@ void pc_bonus(struct map_session_data *sd,int type,int val)
case SP_DEX: case SP_DEX:
case SP_LUK: case SP_LUK:
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->param_bonus[type-SP_STR]+=val; sd->indexed_bonus.param_bonus[type-SP_STR]+=val;
break; break;
case SP_ATK1: case SP_ATK1:
if(!sd->state.lr_flag) { if(!sd->state.lr_flag) {
@ -3425,25 +3425,25 @@ void pc_bonus(struct map_session_data *sd,int type,int val)
break; break;
case SP_ALL_STATS: // [Valaris] case SP_ALL_STATS: // [Valaris]
if(sd->state.lr_flag!=2) { if(sd->state.lr_flag!=2) {
sd->param_bonus[SP_STR-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_STR-SP_STR]+=val;
sd->param_bonus[SP_AGI-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_AGI-SP_STR]+=val;
sd->param_bonus[SP_VIT-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_VIT-SP_STR]+=val;
sd->param_bonus[SP_INT-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_INT-SP_STR]+=val;
sd->param_bonus[SP_DEX-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_DEX-SP_STR]+=val;
sd->param_bonus[SP_LUK-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_LUK-SP_STR]+=val;
} }
break; break;
case SP_AGI_VIT: // [Valaris] case SP_AGI_VIT: // [Valaris]
if(sd->state.lr_flag!=2) { if(sd->state.lr_flag!=2) {
sd->param_bonus[SP_AGI-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_AGI-SP_STR]+=val;
sd->param_bonus[SP_VIT-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_VIT-SP_STR]+=val;
} }
break; break;
case SP_AGI_DEX_STR: // [Valaris] case SP_AGI_DEX_STR: // [Valaris]
if(sd->state.lr_flag!=2) { if(sd->state.lr_flag!=2) {
sd->param_bonus[SP_AGI-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_AGI-SP_STR]+=val;
sd->param_bonus[SP_DEX-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_DEX-SP_STR]+=val;
sd->param_bonus[SP_STR-SP_STR]+=val; sd->indexed_bonus.param_bonus[SP_STR-SP_STR]+=val;
} }
break; break;
case SP_PERFECT_HIDE: // [Valaris] case SP_PERFECT_HIDE: // [Valaris]
@ -3684,7 +3684,7 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
else if(sd->state.lr_flag == 1) else if(sd->state.lr_flag == 1)
sd->left_weapon.addele[type2]+=val; sd->left_weapon.addele[type2]+=val;
else if(sd->state.lr_flag == 2) else if(sd->state.lr_flag == 2)
sd->arrow_addele[type2]+=val; sd->indexed_bonus.arrow_addele[type2]+=val;
break; break;
case SP_ADDRACE: // bonus2 bAddRace,r,x; case SP_ADDRACE: // bonus2 bAddRace,r,x;
PC_BONUS_CHK_RACE(type2,SP_ADDRACE); PC_BONUS_CHK_RACE(type2,SP_ADDRACE);
@ -3693,7 +3693,7 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
else if(sd->state.lr_flag == 1) else if(sd->state.lr_flag == 1)
sd->left_weapon.addrace[type2]+=val; sd->left_weapon.addrace[type2]+=val;
else if(sd->state.lr_flag == 2) else if(sd->state.lr_flag == 2)
sd->arrow_addrace[type2]+=val; sd->indexed_bonus.arrow_addrace[type2]+=val;
break; break;
case SP_ADDCLASS: // bonus2 bAddClass,c,x; case SP_ADDCLASS: // bonus2 bAddClass,c,x;
PC_BONUS_CHK_CLASS(type2,SP_ADDCLASS); PC_BONUS_CHK_CLASS(type2,SP_ADDCLASS);
@ -3702,7 +3702,7 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
else if(sd->state.lr_flag == 1) else if(sd->state.lr_flag == 1)
sd->left_weapon.addclass[type2]+=val; sd->left_weapon.addclass[type2]+=val;
else if(sd->state.lr_flag == 2) else if(sd->state.lr_flag == 2)
sd->arrow_addclass[type2]+=val; sd->indexed_bonus.arrow_addclass[type2]+=val;
break; break;
case SP_ADDSIZE: // bonus2 bAddSize,s,x; case SP_ADDSIZE: // bonus2 bAddSize,s,x;
PC_BONUS_CHK_SIZE(type2,SP_ADDSIZE); PC_BONUS_CHK_SIZE(type2,SP_ADDSIZE);
@ -3711,22 +3711,22 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
else if(sd->state.lr_flag == 1) else if(sd->state.lr_flag == 1)
sd->left_weapon.addsize[type2]+=val; sd->left_weapon.addsize[type2]+=val;
else if(sd->state.lr_flag == 2) else if(sd->state.lr_flag == 2)
sd->arrow_addsize[type2]+=val; sd->indexed_bonus.arrow_addsize[type2]+=val;
break; break;
case SP_SUBELE: // bonus2 bSubEle,e,x; case SP_SUBELE: // bonus2 bSubEle,e,x;
PC_BONUS_CHK_ELEMENT(type2,SP_SUBELE); PC_BONUS_CHK_ELEMENT(type2,SP_SUBELE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->subele_script[type2] += val; sd->indexed_bonus.subele_script[type2] += val;
break; break;
case SP_SUBRACE: // bonus2 bSubRace,r,x; case SP_SUBRACE: // bonus2 bSubRace,r,x;
PC_BONUS_CHK_RACE(type2,SP_SUBRACE); PC_BONUS_CHK_RACE(type2,SP_SUBRACE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->subrace[type2]+=val; sd->indexed_bonus.subrace[type2]+=val;
break; break;
case SP_SUBCLASS: // bonus2 bSubClass,c,x; case SP_SUBCLASS: // bonus2 bSubClass,c,x;
PC_BONUS_CHK_CLASS(type2,SP_SUBCLASS); PC_BONUS_CHK_CLASS(type2,SP_SUBCLASS);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->subclass[type2]+=val; sd->indexed_bonus.subclass[type2]+=val;
break; break;
case SP_ADDEFF: // bonus2 bAddEff,eff,n; case SP_ADDEFF: // bonus2 bAddEff,eff,n;
PC_BONUS_CHK_SC(type2,SP_ADDEFF); PC_BONUS_CHK_SC(type2,SP_ADDEFF);
@ -3749,27 +3749,27 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
case SP_MAGIC_ADDELE: // bonus2 bMagicAddEle,e,x; case SP_MAGIC_ADDELE: // bonus2 bMagicAddEle,e,x;
PC_BONUS_CHK_ELEMENT(type2,SP_MAGIC_ADDELE); PC_BONUS_CHK_ELEMENT(type2,SP_MAGIC_ADDELE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_addele_script[type2] += val; sd->indexed_bonus.magic_addele_script[type2] += val;
break; break;
case SP_MAGIC_ADDRACE: // bonus2 bMagicAddRace,r,x; case SP_MAGIC_ADDRACE: // bonus2 bMagicAddRace,r,x;
PC_BONUS_CHK_RACE(type2,SP_MAGIC_ADDRACE); PC_BONUS_CHK_RACE(type2,SP_MAGIC_ADDRACE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_addrace[type2]+=val; sd->indexed_bonus.magic_addrace[type2]+=val;
break; break;
case SP_MAGIC_ADDCLASS: // bonus2 bMagicAddClass,c,x; case SP_MAGIC_ADDCLASS: // bonus2 bMagicAddClass,c,x;
PC_BONUS_CHK_CLASS(type2,SP_MAGIC_ADDCLASS); PC_BONUS_CHK_CLASS(type2,SP_MAGIC_ADDCLASS);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_addclass[type2]+=val; sd->indexed_bonus.magic_addclass[type2]+=val;
break; break;
case SP_MAGIC_ADDSIZE: // bonus2 bMagicAddSize,s,x; case SP_MAGIC_ADDSIZE: // bonus2 bMagicAddSize,s,x;
PC_BONUS_CHK_SIZE(type2,SP_MAGIC_ADDSIZE); PC_BONUS_CHK_SIZE(type2,SP_MAGIC_ADDSIZE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_addsize[type2]+=val; sd->indexed_bonus.magic_addsize[type2]+=val;
break; break;
case SP_MAGIC_ATK_ELE: // bonus2 bMagicAtkEle,e,x; case SP_MAGIC_ATK_ELE: // bonus2 bMagicAtkEle,e,x;
PC_BONUS_CHK_ELEMENT(type2,SP_MAGIC_ATK_ELE); PC_BONUS_CHK_ELEMENT(type2,SP_MAGIC_ATK_ELE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_atk_ele[type2]+=val; sd->indexed_bonus.magic_atk_ele[type2]+=val;
break; break;
case SP_ADD_DAMAGE_CLASS: { // bonus2 bAddDamageClass,mid,x; case SP_ADD_DAMAGE_CLASS: { // bonus2 bAddDamageClass,mid,x;
struct weapon_data *wd = (sd->state.lr_flag ? &sd->left_weapon : &sd->right_weapon); struct weapon_data *wd = (sd->state.lr_flag ? &sd->left_weapon : &sd->right_weapon);
@ -3858,35 +3858,35 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
PC_BONUS_CHK_ELEMENT(type2,SP_WEAPON_COMA_ELE); PC_BONUS_CHK_ELEMENT(type2,SP_WEAPON_COMA_ELE);
if(sd->state.lr_flag == 2) if(sd->state.lr_flag == 2)
break; break;
sd->weapon_coma_ele[type2] += val; sd->indexed_bonus.weapon_coma_ele[type2] += val;
sd->special_state.bonus_coma = 1; sd->special_state.bonus_coma = 1;
break; break;
case SP_WEAPON_COMA_RACE: // bonus2 bWeaponComaRace,r,n; case SP_WEAPON_COMA_RACE: // bonus2 bWeaponComaRace,r,n;
PC_BONUS_CHK_RACE(type2,SP_WEAPON_COMA_RACE); PC_BONUS_CHK_RACE(type2,SP_WEAPON_COMA_RACE);
if(sd->state.lr_flag == 2) if(sd->state.lr_flag == 2)
break; break;
sd->weapon_coma_race[type2] += val; sd->indexed_bonus.weapon_coma_race[type2] += val;
sd->special_state.bonus_coma = 1; sd->special_state.bonus_coma = 1;
break; break;
case SP_WEAPON_COMA_CLASS: // bonus2 bWeaponComaClass,c,n; case SP_WEAPON_COMA_CLASS: // bonus2 bWeaponComaClass,c,n;
PC_BONUS_CHK_CLASS(type2,SP_WEAPON_COMA_CLASS); PC_BONUS_CHK_CLASS(type2,SP_WEAPON_COMA_CLASS);
if(sd->state.lr_flag == 2) if(sd->state.lr_flag == 2)
break; break;
sd->weapon_coma_class[type2] += val; sd->indexed_bonus.weapon_coma_class[type2] += val;
sd->special_state.bonus_coma = 1; sd->special_state.bonus_coma = 1;
break; break;
case SP_WEAPON_ATK: // bonus2 bWeaponAtk,w,n; case SP_WEAPON_ATK: // bonus2 bWeaponAtk,w,n;
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->weapon_atk[type2]+=val; sd->indexed_bonus.weapon_atk[type2]+=val;
break; break;
case SP_WEAPON_DAMAGE_RATE: // bonus2 bWeaponDamageRate,w,n; case SP_WEAPON_DAMAGE_RATE: // bonus2 bWeaponDamageRate,w,n;
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->weapon_damage_rate[type2]+=val; sd->indexed_bonus.weapon_damage_rate[type2]+=val;
break; break;
case SP_CRITICAL_ADDRACE: // bonus2 bCriticalAddRace,r,n; case SP_CRITICAL_ADDRACE: // bonus2 bCriticalAddRace,r,n;
PC_BONUS_CHK_RACE(type2,SP_CRITICAL_ADDRACE); PC_BONUS_CHK_RACE(type2,SP_CRITICAL_ADDRACE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->critaddrace[type2] += val*10; sd->indexed_bonus.critaddrace[type2] += val*10;
break; break;
case SP_ADDEFF_WHENHIT: // bonus2 bAddEffWhenHit,eff,n; case SP_ADDEFF_WHENHIT: // bonus2 bAddEffWhenHit,eff,n;
PC_BONUS_CHK_SC(type2,SP_ADDEFF_WHENHIT); PC_BONUS_CHK_SC(type2,SP_ADDEFF_WHENHIT);
@ -3967,17 +3967,17 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
case SP_SUBSIZE: // bonus2 bSubSize,s,x; case SP_SUBSIZE: // bonus2 bSubSize,s,x;
PC_BONUS_CHK_SIZE(type2,SP_SUBSIZE); PC_BONUS_CHK_SIZE(type2,SP_SUBSIZE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->subsize[type2]+=val; sd->indexed_bonus.subsize[type2]+=val;
break; break;
case SP_MAGIC_SUBSIZE: // bonus2 bMagicSubSize,s,x; case SP_MAGIC_SUBSIZE: // bonus2 bMagicSubSize,s,x;
PC_BONUS_CHK_SIZE(type2,SP_MAGIC_SUBSIZE); PC_BONUS_CHK_SIZE(type2,SP_MAGIC_SUBSIZE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_subsize[type2]+=val; sd->indexed_bonus.magic_subsize[type2]+=val;
break; break;
case SP_SUBRACE2: // bonus2 bSubRace2,mr,x; case SP_SUBRACE2: // bonus2 bSubRace2,mr,x;
PC_BONUS_CHK_RACE2(type2,SP_SUBRACE2); PC_BONUS_CHK_RACE2(type2,SP_SUBRACE2);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->subrace2[type2]+=val; sd->indexed_bonus.subrace2[type2]+=val;
break; break;
case SP_ADD_ITEM_HEAL_RATE: // bonus2 bAddItemHealRate,iid,n; case SP_ADD_ITEM_HEAL_RATE: // bonus2 bAddItemHealRate,iid,n;
if(sd->state.lr_flag == 2) if(sd->state.lr_flag == 2)
@ -4010,17 +4010,17 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
case SP_EXP_ADDRACE: // bonus2 bExpAddRace,r,x; case SP_EXP_ADDRACE: // bonus2 bExpAddRace,r,x;
PC_BONUS_CHK_RACE(type2,SP_EXP_ADDRACE); PC_BONUS_CHK_RACE(type2,SP_EXP_ADDRACE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->expaddrace[type2]+=val; sd->indexed_bonus.expaddrace[type2]+=val;
break; break;
case SP_EXP_ADDCLASS: // bonus2 bExpAddClass,c,x; case SP_EXP_ADDCLASS: // bonus2 bExpAddClass,c,x;
PC_BONUS_CHK_CLASS(type2,SP_EXP_ADDCLASS); PC_BONUS_CHK_CLASS(type2,SP_EXP_ADDCLASS);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->expaddclass[type2]+=val; sd->indexed_bonus.expaddclass[type2]+=val;
break; break;
case SP_SP_GAIN_RACE: // bonus2 bSPGainRace,r,n; case SP_SP_GAIN_RACE: // bonus2 bSPGainRace,r,n;
PC_BONUS_CHK_RACE(type2,SP_SP_GAIN_RACE); PC_BONUS_CHK_RACE(type2,SP_SP_GAIN_RACE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->sp_gain_race[type2]+=val; sd->indexed_bonus.sp_gain_race[type2]+=val;
break; break;
case SP_ADD_MONSTER_DROP_ITEM: // bonus2 bAddMonsterDropItem,iid,n; case SP_ADD_MONSTER_DROP_ITEM: // bonus2 bAddMonsterDropItem,iid,n;
if (sd->state.lr_flag != 2) if (sd->state.lr_flag != 2)
@ -4081,22 +4081,22 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
case SP_IGNORE_MDEF_RACE_RATE: // bonus2 bIgnoreMdefRaceRate,r,n; case SP_IGNORE_MDEF_RACE_RATE: // bonus2 bIgnoreMdefRaceRate,r,n;
PC_BONUS_CHK_RACE(type2,SP_IGNORE_MDEF_RACE_RATE); PC_BONUS_CHK_RACE(type2,SP_IGNORE_MDEF_RACE_RATE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->ignore_mdef_by_race[type2] += val; sd->indexed_bonus.ignore_mdef_by_race[type2] += val;
break; break;
case SP_IGNORE_MDEF_CLASS_RATE: // bonus2 bIgnoreMdefClassRate,c,n; case SP_IGNORE_MDEF_CLASS_RATE: // bonus2 bIgnoreMdefClassRate,c,n;
PC_BONUS_CHK_CLASS(type2,SP_IGNORE_MDEF_CLASS_RATE); PC_BONUS_CHK_CLASS(type2,SP_IGNORE_MDEF_CLASS_RATE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->ignore_mdef_by_class[type2] += val; sd->indexed_bonus.ignore_mdef_by_class[type2] += val;
break; break;
case SP_IGNORE_DEF_RACE_RATE: // bonus2 bIgnoreDefRaceRate,r,n; case SP_IGNORE_DEF_RACE_RATE: // bonus2 bIgnoreDefRaceRate,r,n;
PC_BONUS_CHK_RACE(type2,SP_IGNORE_DEF_RACE_RATE); PC_BONUS_CHK_RACE(type2,SP_IGNORE_DEF_RACE_RATE);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->ignore_def_by_race[type2] += val; sd->indexed_bonus.ignore_def_by_race[type2] += val;
break; break;
case SP_IGNORE_DEF_CLASS_RATE: // bonus2 bIgnoreDefClassRate,r,n; case SP_IGNORE_DEF_CLASS_RATE: // bonus2 bIgnoreDefClassRate,r,n;
PC_BONUS_CHK_CLASS(type2, SP_IGNORE_DEF_CLASS_RATE); PC_BONUS_CHK_CLASS(type2, SP_IGNORE_DEF_CLASS_RATE);
if (sd->state.lr_flag != 2) if (sd->state.lr_flag != 2)
sd->ignore_def_by_class[type2] += val; sd->indexed_bonus.ignore_def_by_class[type2] += val;
break; break;
case SP_SKILL_USE_SP_RATE: // bonus2 bSkillUseSPrate,sk,n; case SP_SKILL_USE_SP_RATE: // bonus2 bSkillUseSPrate,sk,n;
if(sd->state.lr_flag == 2) if(sd->state.lr_flag == 2)
@ -4207,41 +4207,41 @@ void pc_bonus2(struct map_session_data *sd,int type,int type2,int val)
break; break;
case SP_SUBDEF_ELE: // bonus2 bSubDefEle,e,x; case SP_SUBDEF_ELE: // bonus2 bSubDefEle,e,x;
PC_BONUS_CHK_ELEMENT(type2,SP_SUBDEF_ELE); PC_BONUS_CHK_ELEMENT(type2,SP_SUBDEF_ELE);
sd->subdefele[type2] += val; sd->indexed_bonus.subdefele[type2] += val;
break; break;
case SP_COMA_CLASS: // bonus2 bComaClass,c,n; case SP_COMA_CLASS: // bonus2 bComaClass,c,n;
PC_BONUS_CHK_CLASS(type2,SP_COMA_CLASS); PC_BONUS_CHK_CLASS(type2,SP_COMA_CLASS);
sd->coma_class[type2] += val; sd->indexed_bonus.coma_class[type2] += val;
sd->special_state.bonus_coma = 1; sd->special_state.bonus_coma = 1;
break; break;
case SP_COMA_RACE: // bonus2 bComaRace,r,n; case SP_COMA_RACE: // bonus2 bComaRace,r,n;
PC_BONUS_CHK_RACE(type2,SP_COMA_RACE); PC_BONUS_CHK_RACE(type2,SP_COMA_RACE);
sd->coma_race[type2] += val; sd->indexed_bonus.coma_race[type2] += val;
sd->special_state.bonus_coma = 1; sd->special_state.bonus_coma = 1;
break; break;
case SP_MAGIC_ADDRACE2: // bonus2 bMagicAddRace2,mr,n; case SP_MAGIC_ADDRACE2: // bonus2 bMagicAddRace2,mr,n;
PC_BONUS_CHK_RACE2(type2, SP_MAGIC_ADDRACE2); PC_BONUS_CHK_RACE2(type2, SP_MAGIC_ADDRACE2);
if(sd->state.lr_flag != 2) if(sd->state.lr_flag != 2)
sd->magic_addrace2[type2] += val; sd->indexed_bonus.magic_addrace2[type2] += val;
break; break;
case SP_IGNORE_MDEF_RACE2_RATE: //bonus2 bIgnoreMdefRace2Rate,mr,n; case SP_IGNORE_MDEF_RACE2_RATE: //bonus2 bIgnoreMdefRace2Rate,mr,n;
PC_BONUS_CHK_RACE2(type2, SP_IGNORE_MDEF_RACE2); PC_BONUS_CHK_RACE2(type2, SP_IGNORE_MDEF_RACE2);
if (sd->state.lr_flag != 2) if (sd->state.lr_flag != 2)
sd->ignore_mdef_by_race2[type2] += val; sd->indexed_bonus.ignore_mdef_by_race2[type2] += val;
break; break;
case SP_DROP_ADDRACE: // bonus2 bDropAddRace,r,x; case SP_DROP_ADDRACE: // bonus2 bDropAddRace,r,x;
PC_BONUS_CHK_RACE(type2, SP_DROP_ADDRACE); PC_BONUS_CHK_RACE(type2, SP_DROP_ADDRACE);
if (sd->state.lr_flag != 2) if (sd->state.lr_flag != 2)
sd->dropaddrace[type2] += val; sd->indexed_bonus.dropaddrace[type2] += val;
break; break;
case SP_DROP_ADDCLASS: // bonus2 bDropAddClass,c,x; case SP_DROP_ADDCLASS: // bonus2 bDropAddClass,c,x;
PC_BONUS_CHK_CLASS(type2, SP_DROP_ADDCLASS); PC_BONUS_CHK_CLASS(type2, SP_DROP_ADDCLASS);
if (sd->state.lr_flag != 2) if (sd->state.lr_flag != 2)
sd->dropaddclass[type2] += val; sd->indexed_bonus.dropaddclass[type2] += val;
break; break;
case SP_MAGIC_SUBDEF_ELE: // bonus2 bMagicSubDefEle,e,x; case SP_MAGIC_SUBDEF_ELE: // bonus2 bMagicSubDefEle,e,x;
PC_BONUS_CHK_ELEMENT(type2, SP_MAGIC_SUBDEF_ELE); PC_BONUS_CHK_ELEMENT(type2, SP_MAGIC_SUBDEF_ELE);
sd->magic_subdefele[type2] += val; sd->indexed_bonus.magic_subdefele[type2] += val;
break; break;
default: default:
if (current_equip_combo_pos > 0) { if (current_equip_combo_pos > 0) {
@ -7168,14 +7168,14 @@ static void pc_calcexp(struct map_session_data *sd, t_exp *base_exp, t_exp *job_
if (src) { if (src) {
struct status_data *status = status_get_status_data(src); struct status_data *status = status_get_status_data(src);
if( sd->expaddrace[status->race] ) if( sd->indexed_bonus.expaddrace[status->race] )
bonus += sd->expaddrace[status->race]; bonus += sd->indexed_bonus.expaddrace[status->race];
if( sd->expaddrace[RC_ALL] ) if( sd->indexed_bonus.expaddrace[RC_ALL] )
bonus += sd->expaddrace[RC_ALL]; bonus += sd->indexed_bonus.expaddrace[RC_ALL];
if( sd->expaddclass[status->class_] ) if( sd->indexed_bonus.expaddclass[status->class_] )
bonus += sd->expaddclass[status->class_]; bonus += sd->indexed_bonus.expaddclass[status->class_];
if( sd->expaddclass[CLASS_ALL] ) if( sd->indexed_bonus.expaddclass[CLASS_ALL] )
bonus += sd->expaddclass[CLASS_ALL]; bonus += sd->indexed_bonus.expaddclass[CLASS_ALL];
if (battle_config.pk_mode && if (battle_config.pk_mode &&
(int)(status_get_lv(src) - sd->status.base_level) >= 20) (int)(status_get_lv(src) - sd->status.base_level) >= 20)

80
src/map/pc.hpp
View File

@ -422,45 +422,47 @@ struct map_session_data {
struct weapon_data right_weapon, left_weapon; struct weapon_data right_weapon, left_weapon;
// here start arrays to be globally zeroed at the beginning of status_calc_pc() // here start arrays to be globally zeroed at the beginning of status_calc_pc()
int param_bonus[6],param_equip[6]; //Stores card/equipment bonuses. struct s_indexed_bonus {
int subele[ELE_MAX]; int param_bonus[6], param_equip[6]; //Stores card/equipment bonuses.
int subele_script[ELE_MAX]; int subele[ELE_MAX];
int subdefele[ELE_MAX]; int subele_script[ELE_MAX];
int subrace[RC_MAX]; int subdefele[ELE_MAX];
int subclass[CLASS_MAX]; int subrace[RC_MAX];
int subrace2[RC2_MAX]; int subclass[CLASS_MAX];
int subsize[SZ_MAX]; int subrace2[RC2_MAX];
short coma_class[CLASS_MAX]; int subsize[SZ_MAX];
short coma_race[RC_MAX]; short coma_class[CLASS_MAX];
short weapon_coma_ele[ELE_MAX]; short coma_race[RC_MAX];
short weapon_coma_race[RC_MAX]; short weapon_coma_ele[ELE_MAX];
short weapon_coma_class[CLASS_MAX]; short weapon_coma_race[RC_MAX];
int weapon_atk[16]; short weapon_coma_class[CLASS_MAX];
int weapon_damage_rate[16]; int weapon_atk[16];
int arrow_addele[ELE_MAX]; int weapon_damage_rate[16];
int arrow_addrace[RC_MAX]; int arrow_addele[ELE_MAX];
int arrow_addclass[CLASS_MAX]; int arrow_addrace[RC_MAX];
int arrow_addsize[SZ_MAX]; int arrow_addclass[CLASS_MAX];
int magic_addele[ELE_MAX]; int arrow_addsize[SZ_MAX];
int magic_addele_script[ELE_MAX]; int magic_addele[ELE_MAX];
int magic_addrace[RC_MAX]; int magic_addele_script[ELE_MAX];
int magic_addclass[CLASS_MAX]; int magic_addrace[RC_MAX];
int magic_addsize[SZ_MAX]; int magic_addclass[CLASS_MAX];
int magic_atk_ele[ELE_MAX]; int magic_addsize[SZ_MAX];
int magic_subsize[SZ_MAX]; int magic_atk_ele[ELE_MAX];
int critaddrace[RC_MAX]; int magic_subsize[SZ_MAX];
int expaddrace[RC_MAX]; int critaddrace[RC_MAX];
int expaddclass[CLASS_MAX]; int expaddrace[RC_MAX];
int ignore_mdef_by_race[RC_MAX]; int expaddclass[CLASS_MAX];
int ignore_mdef_by_class[CLASS_MAX]; int ignore_mdef_by_race[RC_MAX];
int ignore_def_by_race[RC_MAX]; int ignore_mdef_by_class[CLASS_MAX];
int ignore_def_by_class[CLASS_MAX]; int ignore_def_by_race[RC_MAX];
short sp_gain_race[RC_MAX]; int ignore_def_by_class[CLASS_MAX];
int magic_addrace2[RC2_MAX]; short sp_gain_race[RC_MAX];
int ignore_mdef_by_race2[RC2_MAX]; int magic_addrace2[RC2_MAX];
int dropaddrace[RC_MAX]; int ignore_mdef_by_race2[RC2_MAX];
int dropaddclass[CLASS_MAX]; int dropaddrace[RC_MAX];
int magic_subdefele[ELE_MAX]; int dropaddclass[CLASS_MAX];
int magic_subdefele[ELE_MAX];
} indexed_bonus;
// zeroed arrays end here. // zeroed arrays end here.
std::vector<s_autospell> autospell, autospell2, autospell3; std::vector<s_autospell> autospell, autospell2, autospell3;

12
src/map/skill.cpp
View File

@ -2097,13 +2097,13 @@ int skill_additional_effect(struct block_list* src, struct block_list *bl, uint1
rate = 0; rate = 0;
//! TODO: Filter the skills that shouldn't inflict coma bonus, to avoid some non-damage skills inflict coma. [Cydh] //! TODO: Filter the skills that shouldn't inflict coma bonus, to avoid some non-damage skills inflict coma. [Cydh]
if (!skill_id || !skill_get_nk(skill_id, NK_NODAMAGE)) { if (!skill_id || !skill_get_nk(skill_id, NK_NODAMAGE)) {
rate += sd->coma_class[tstatus->class_] + sd->coma_class[CLASS_ALL]; rate += sd->indexed_bonus.coma_class[tstatus->class_] + sd->indexed_bonus.coma_class[CLASS_ALL];
rate += sd->coma_race[tstatus->race] + sd->coma_race[RC_ALL]; rate += sd->indexed_bonus.coma_race[tstatus->race] + sd->indexed_bonus.coma_race[RC_ALL];
} }
if (attack_type&BF_WEAPON) { if (attack_type&BF_WEAPON) {
rate += sd->weapon_coma_ele[tstatus->def_ele] + sd->weapon_coma_ele[ELE_ALL]; rate += sd->indexed_bonus.weapon_coma_ele[tstatus->def_ele] + sd->indexed_bonus.weapon_coma_ele[ELE_ALL];
rate += sd->weapon_coma_race[tstatus->race] + sd->weapon_coma_race[RC_ALL]; rate += sd->indexed_bonus.weapon_coma_race[tstatus->race] + sd->indexed_bonus.weapon_coma_race[RC_ALL];
rate += sd->weapon_coma_class[tstatus->class_] + sd->weapon_coma_class[CLASS_ALL]; rate += sd->indexed_bonus.weapon_coma_class[tstatus->class_] + sd->indexed_bonus.weapon_coma_class[CLASS_ALL];
} }
if (rate > 0) if (rate > 0)
status_change_start(src,bl, SC_COMA, rate, 0, 0, src->id, 0, 0, SCSTART_NONE); status_change_start(src,bl, SC_COMA, rate, 0, 0, src->id, 0, 0, SCSTART_NONE);
@ -2467,7 +2467,7 @@ int skill_counter_additional_effect (struct block_list* src, struct block_list *
int sp = 0, hp = 0; int sp = 0, hp = 0;
if( (attack_type&(BF_WEAPON|BF_SHORT)) == (BF_WEAPON|BF_SHORT) ) { if( (attack_type&(BF_WEAPON|BF_SHORT)) == (BF_WEAPON|BF_SHORT) ) {
sp += sd->bonus.sp_gain_value; sp += sd->bonus.sp_gain_value;
sp += sd->sp_gain_race[status_get_race(bl)] + sd->sp_gain_race[RC_ALL]; sp += sd->indexed_bonus.sp_gain_race[status_get_race(bl)] + sd->indexed_bonus.sp_gain_race[RC_ALL];
hp += sd->bonus.hp_gain_value; hp += sd->bonus.hp_gain_value;
} }
if( (attack_type&(BF_WEAPON|BF_LONG)) == (BF_WEAPON|BF_LONG) ) { if( (attack_type&(BF_WEAPON|BF_LONG)) == (BF_WEAPON|BF_LONG) ) {

182
src/map/status.cpp
View File

@ -3815,49 +3815,7 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
sd->regen.state.block = 0; sd->regen.state.block = 0;
sd->add_max_weight = 0; sd->add_max_weight = 0;
// Zeroed arrays, order follows the order in pc.hpp. sd->indexed_bonus = {};
// Add new arrays to the end of zeroed area in pc.hpp (see comments) and size here. [zzo]
memset (sd->param_bonus, 0, sizeof(sd->param_bonus)
+ sizeof(sd->param_equip)
+ sizeof(sd->subele)
+ sizeof(sd->subele_script)
+ sizeof(sd->subdefele)
+ sizeof(sd->subrace)
+ sizeof(sd->subclass)
+ sizeof(sd->subrace2)
+ sizeof(sd->subsize)
+ sizeof(sd->coma_class)
+ sizeof(sd->coma_race)
+ sizeof(sd->weapon_coma_ele)
+ sizeof(sd->weapon_coma_race)
+ sizeof(sd->weapon_coma_class)
+ sizeof(sd->weapon_atk)
+ sizeof(sd->weapon_damage_rate)
+ sizeof(sd->arrow_addele)
+ sizeof(sd->arrow_addrace)
+ sizeof(sd->arrow_addclass)
+ sizeof(sd->arrow_addsize)
+ sizeof(sd->magic_addele)
+ sizeof(sd->magic_addele_script)
+ sizeof(sd->magic_addrace)
+ sizeof(sd->magic_addclass)
+ sizeof(sd->magic_addsize)
+ sizeof(sd->magic_atk_ele)
+ sizeof(sd->magic_subsize)
+ sizeof(sd->critaddrace)
+ sizeof(sd->expaddrace)
+ sizeof(sd->expaddclass)
+ sizeof(sd->ignore_mdef_by_race)
+ sizeof(sd->ignore_mdef_by_class)
+ sizeof(sd->ignore_def_by_race)
+ sizeof(sd->ignore_def_by_class)
+ sizeof(sd->sp_gain_race)
+ sizeof(sd->magic_addrace2)
+ sizeof(sd->ignore_mdef_by_race2)
+ sizeof(sd->dropaddrace)
+ sizeof(sd->dropaddclass)
+ sizeof(sd->magic_subdefele)
);
memset (&sd->right_weapon.overrefine, 0, sizeof(sd->right_weapon) - sizeof(sd->right_weapon.atkmods)); memset (&sd->right_weapon.overrefine, 0, sizeof(sd->right_weapon) - sizeof(sd->right_weapon.atkmods));
memset (&sd->left_weapon.overrefine, 0, sizeof(sd->left_weapon) - sizeof(sd->left_weapon.atkmods)); memset (&sd->left_weapon.overrefine, 0, sizeof(sd->left_weapon) - sizeof(sd->left_weapon.atkmods));
@ -4095,8 +4053,8 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
} }
// Store equipment script bonuses // Store equipment script bonuses
memcpy(sd->param_equip,sd->param_bonus,sizeof(sd->param_equip)); memcpy(sd->indexed_bonus.param_equip,sd->indexed_bonus.param_bonus,sizeof(sd->indexed_bonus.param_equip));
memset(sd->param_bonus, 0, sizeof(sd->param_bonus)); memset(sd->indexed_bonus.param_bonus, 0, sizeof(sd->indexed_bonus.param_bonus));
base_status->def += (refinedef+50)/100; base_status->def += (refinedef+50)/100;
@ -4276,17 +4234,17 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
base_status->int_ += 20; base_status->int_ += 20;
// Bonuses from cards and equipment as well as base stat, remember to avoid overflows. // Bonuses from cards and equipment as well as base stat, remember to avoid overflows.
i = base_status->str + sd->status.str + sd->param_bonus[0] + sd->param_equip[0]; i = base_status->str + sd->status.str + sd->indexed_bonus.param_bonus[0] + sd->indexed_bonus.param_equip[0];
base_status->str = cap_value(i,0,USHRT_MAX); base_status->str = cap_value(i,0,USHRT_MAX);
i = base_status->agi + sd->status.agi + sd->param_bonus[1] + sd->param_equip[1]; i = base_status->agi + sd->status.agi + sd->indexed_bonus.param_bonus[1] + sd->indexed_bonus.param_equip[1];
base_status->agi = cap_value(i,0,USHRT_MAX); base_status->agi = cap_value(i,0,USHRT_MAX);
i = base_status->vit + sd->status.vit + sd->param_bonus[2] + sd->param_equip[2]; i = base_status->vit + sd->status.vit + sd->indexed_bonus.param_bonus[2] + sd->indexed_bonus.param_equip[2];
base_status->vit = cap_value(i,0,USHRT_MAX); base_status->vit = cap_value(i,0,USHRT_MAX);
i = base_status->int_+ sd->status.int_+ sd->param_bonus[3] + sd->param_equip[3]; i = base_status->int_+ sd->status.int_+ sd->indexed_bonus.param_bonus[3] + sd->indexed_bonus.param_equip[3];
base_status->int_ = cap_value(i,0,USHRT_MAX); base_status->int_ = cap_value(i,0,USHRT_MAX);
i = base_status->dex + sd->status.dex + sd->param_bonus[4] + sd->param_equip[4]; i = base_status->dex + sd->status.dex + sd->indexed_bonus.param_bonus[4] + sd->indexed_bonus.param_equip[4];
base_status->dex = cap_value(i,0,USHRT_MAX); base_status->dex = cap_value(i,0,USHRT_MAX);
i = base_status->luk + sd->status.luk + sd->param_bonus[5] + sd->param_equip[5]; i = base_status->luk + sd->status.luk + sd->indexed_bonus.param_bonus[5] + sd->indexed_bonus.param_equip[5];
base_status->luk = cap_value(i,0,USHRT_MAX); base_status->luk = cap_value(i,0,USHRT_MAX);
if (sd->special_state.no_walk_delay) { if (sd->special_state.no_walk_delay) {
@ -4557,10 +4515,10 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
// Anti-element and anti-race // Anti-element and anti-race
if((skill=pc_checkskill(sd,CR_TRUST))>0) if((skill=pc_checkskill(sd,CR_TRUST))>0)
sd->subele[ELE_HOLY] += skill*5; sd->indexed_bonus.subele[ELE_HOLY] += skill*5;
if((skill=pc_checkskill(sd,BS_SKINTEMPER))>0) { if((skill=pc_checkskill(sd,BS_SKINTEMPER))>0) {
sd->subele[ELE_NEUTRAL] += skill; sd->indexed_bonus.subele[ELE_NEUTRAL] += skill;
sd->subele[ELE_FIRE] += skill*5; sd->indexed_bonus.subele[ELE_FIRE] += skill*5;
} }
if((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0) { if((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0) {
#ifdef RENEWAL #ifdef RENEWAL
@ -4570,31 +4528,31 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
#endif #endif
sd->right_weapon.addrace[RC_DRAGON]+=skill; sd->right_weapon.addrace[RC_DRAGON]+=skill;
sd->left_weapon.addrace[RC_DRAGON]+=skill; sd->left_weapon.addrace[RC_DRAGON]+=skill;
sd->magic_addrace[RC_DRAGON]+=skill; sd->indexed_bonus.magic_addrace[RC_DRAGON]+=skill;
sd->subrace[RC_DRAGON]+=skill; sd->indexed_bonus.subrace[RC_DRAGON]+=skill;
} }
if ((skill = pc_checkskill(sd, AB_EUCHARISTICA)) > 0) { if ((skill = pc_checkskill(sd, AB_EUCHARISTICA)) > 0) {
sd->right_weapon.addrace[RC_DEMON] += skill; sd->right_weapon.addrace[RC_DEMON] += skill;
sd->right_weapon.addele[ELE_DARK] += skill; sd->right_weapon.addele[ELE_DARK] += skill;
sd->left_weapon.addrace[RC_DEMON] += skill; sd->left_weapon.addrace[RC_DEMON] += skill;
sd->left_weapon.addele[ELE_DARK] += skill; sd->left_weapon.addele[ELE_DARK] += skill;
sd->magic_addrace[RC_DEMON] += skill; sd->indexed_bonus.magic_addrace[RC_DEMON] += skill;
sd->magic_addele[ELE_DARK] += skill; sd->indexed_bonus.magic_addele[ELE_DARK] += skill;
sd->subrace[RC_DEMON] += skill; sd->indexed_bonus.subrace[RC_DEMON] += skill;
sd->subele[ELE_DARK] += skill; sd->indexed_bonus.subele[ELE_DARK] += skill;
} }
if(sc->count) { if(sc->count) {
if(sc->data[SC_CONCENTRATE]) { // Update the card-bonus data if(sc->data[SC_CONCENTRATE]) { // Update the card-bonus data
sc->data[SC_CONCENTRATE]->val3 = sd->param_bonus[1]; // Agi sc->data[SC_CONCENTRATE]->val3 = sd->indexed_bonus.param_bonus[1]; // Agi
sc->data[SC_CONCENTRATE]->val4 = sd->param_bonus[4]; // Dex sc->data[SC_CONCENTRATE]->val4 = sd->indexed_bonus.param_bonus[4]; // Dex
} }
if(sc->data[SC_SIEGFRIED]) { if(sc->data[SC_SIEGFRIED]) {
i = sc->data[SC_SIEGFRIED]->val2; i = sc->data[SC_SIEGFRIED]->val2;
sd->subele[ELE_WATER] += i; sd->indexed_bonus.subele[ELE_WATER] += i;
sd->subele[ELE_EARTH] += i; sd->indexed_bonus.subele[ELE_EARTH] += i;
sd->subele[ELE_FIRE] += i; sd->indexed_bonus.subele[ELE_FIRE] += i;
sd->subele[ELE_WIND] += i; sd->indexed_bonus.subele[ELE_WIND] += i;
#ifndef RENEWAL #ifndef RENEWAL
sd->subele[ELE_POISON] += i; sd->subele[ELE_POISON] += i;
sd->subele[ELE_HOLY] += i; sd->subele[ELE_HOLY] += i;
@ -4610,20 +4568,20 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
sd->right_weapon.addele[ELE_UNDEAD] += i; sd->right_weapon.addele[ELE_UNDEAD] += i;
sd->left_weapon.addele[ELE_DARK] += i; sd->left_weapon.addele[ELE_DARK] += i;
sd->left_weapon.addele[ELE_UNDEAD] += i; sd->left_weapon.addele[ELE_UNDEAD] += i;
sd->magic_atk_ele[ELE_HOLY] += sc->data[SC_BASILICA]->val1 * 3; sd->indexed_bonus.magic_atk_ele[ELE_HOLY] += sc->data[SC_BASILICA]->val1 * 3;
} }
if (sc->data[SC_FIREWEAPON]) if (sc->data[SC_FIREWEAPON])
sd->magic_atk_ele[ELE_FIRE] += sc->data[SC_FIREWEAPON]->val1; sd->indexed_bonus.magic_atk_ele[ELE_FIRE] += sc->data[SC_FIREWEAPON]->val1;
if (sc->data[SC_WINDWEAPON]) if (sc->data[SC_WINDWEAPON])
sd->magic_atk_ele[ELE_WIND] += sc->data[SC_WINDWEAPON]->val1; sd->indexed_bonus.magic_atk_ele[ELE_WIND] += sc->data[SC_WINDWEAPON]->val1;
if (sc->data[SC_WATERWEAPON]) if (sc->data[SC_WATERWEAPON])
sd->magic_atk_ele[ELE_WATER] += sc->data[SC_WATERWEAPON]->val1; sd->indexed_bonus.magic_atk_ele[ELE_WATER] += sc->data[SC_WATERWEAPON]->val1;
if (sc->data[SC_EARTHWEAPON]) if (sc->data[SC_EARTHWEAPON])
sd->magic_atk_ele[ELE_EARTH] += sc->data[SC_EARTHWEAPON]->val1; sd->indexed_bonus.magic_atk_ele[ELE_EARTH] += sc->data[SC_EARTHWEAPON]->val1;
#endif #endif
if(sc->data[SC_PROVIDENCE]) { if(sc->data[SC_PROVIDENCE]) {
sd->subele[ELE_HOLY] += sc->data[SC_PROVIDENCE]->val2; sd->indexed_bonus.subele[ELE_HOLY] += sc->data[SC_PROVIDENCE]->val2;
sd->subrace[RC_DEMON] += sc->data[SC_PROVIDENCE]->val2; sd->indexed_bonus.subrace[RC_DEMON] += sc->data[SC_PROVIDENCE]->val2;
} }
if (sc->data[SC_GEFFEN_MAGIC1]) { if (sc->data[SC_GEFFEN_MAGIC1]) {
sd->right_weapon.addrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC1]->val1; sd->right_weapon.addrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC1]->val1;
@ -4632,70 +4590,70 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
sd->left_weapon.addrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC1]->val1; sd->left_weapon.addrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC1]->val1;
} }
if (sc->data[SC_GEFFEN_MAGIC2]) { if (sc->data[SC_GEFFEN_MAGIC2]) {
sd->magic_addrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC2]->val1; sd->indexed_bonus.magic_addrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC2]->val1;
sd->magic_addrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC2]->val1; sd->indexed_bonus.magic_addrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC2]->val1;
} }
if(sc->data[SC_GEFFEN_MAGIC3]) { if(sc->data[SC_GEFFEN_MAGIC3]) {
sd->subrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC3]->val1; sd->indexed_bonus.subrace[RC_PLAYER_HUMAN] += sc->data[SC_GEFFEN_MAGIC3]->val1;
sd->subrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC3]->val1; sd->indexed_bonus.subrace[RC_DEMIHUMAN] += sc->data[SC_GEFFEN_MAGIC3]->val1;
} }
if(sc->data[SC_ARMOR_ELEMENT_WATER]) { // This status change should grant card-type elemental resist. if(sc->data[SC_ARMOR_ELEMENT_WATER]) { // This status change should grant card-type elemental resist.
sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_WATER]->val1; sd->indexed_bonus.subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_WATER]->val1;
sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_WATER]->val2; sd->indexed_bonus.subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_WATER]->val2;
sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_WATER]->val3; sd->indexed_bonus.subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_WATER]->val3;
sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_WATER]->val4; sd->indexed_bonus.subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_WATER]->val4;
} }
if(sc->data[SC_ARMOR_ELEMENT_EARTH]) { // This status change should grant card-type elemental resist. if(sc->data[SC_ARMOR_ELEMENT_EARTH]) { // This status change should grant card-type elemental resist.
sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val1; sd->indexed_bonus.subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val1;
sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val2; sd->indexed_bonus.subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val2;
sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val3; sd->indexed_bonus.subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val3;
sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val4; sd->indexed_bonus.subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_EARTH]->val4;
} }
if(sc->data[SC_ARMOR_ELEMENT_FIRE]) { // This status change should grant card-type elemental resist. if(sc->data[SC_ARMOR_ELEMENT_FIRE]) { // This status change should grant card-type elemental resist.
sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val1; sd->indexed_bonus.subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val1;
sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val2; sd->indexed_bonus.subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val2;
sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val3; sd->indexed_bonus.subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val3;
sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val4; sd->indexed_bonus.subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_FIRE]->val4;
} }
if(sc->data[SC_ARMOR_ELEMENT_WIND]) { // This status change should grant card-type elemental resist. if(sc->data[SC_ARMOR_ELEMENT_WIND]) { // This status change should grant card-type elemental resist.
sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_WIND]->val1; sd->indexed_bonus.subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT_WIND]->val1;
sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_WIND]->val2; sd->indexed_bonus.subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT_WIND]->val2;
sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_WIND]->val3; sd->indexed_bonus.subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT_WIND]->val3;
sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_WIND]->val4; sd->indexed_bonus.subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT_WIND]->val4;
} }
if(sc->data[SC_ARMOR_RESIST]) { // Undead Scroll if(sc->data[SC_ARMOR_RESIST]) { // Undead Scroll
sd->subele[ELE_WATER] += sc->data[SC_ARMOR_RESIST]->val1; sd->indexed_bonus.subele[ELE_WATER] += sc->data[SC_ARMOR_RESIST]->val1;
sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_RESIST]->val2; sd->indexed_bonus.subele[ELE_EARTH] += sc->data[SC_ARMOR_RESIST]->val2;
sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_RESIST]->val3; sd->indexed_bonus.subele[ELE_FIRE] += sc->data[SC_ARMOR_RESIST]->val3;
sd->subele[ELE_WIND] += sc->data[SC_ARMOR_RESIST]->val4; sd->indexed_bonus.subele[ELE_WIND] += sc->data[SC_ARMOR_RESIST]->val4;
} }
if( sc->data[SC_FIRE_CLOAK_OPTION] ) { if( sc->data[SC_FIRE_CLOAK_OPTION] ) {
i = sc->data[SC_FIRE_CLOAK_OPTION]->val2; i = sc->data[SC_FIRE_CLOAK_OPTION]->val2;
sd->subele[ELE_FIRE] += i; sd->indexed_bonus.subele[ELE_FIRE] += i;
sd->subele[ELE_WATER] -= i; sd->indexed_bonus.subele[ELE_WATER] -= i;
} }
if( sc->data[SC_WATER_DROP_OPTION] ) { if( sc->data[SC_WATER_DROP_OPTION] ) {
i = sc->data[SC_WATER_DROP_OPTION]->val2; i = sc->data[SC_WATER_DROP_OPTION]->val2;
sd->subele[ELE_WATER] += i; sd->indexed_bonus.subele[ELE_WATER] += i;
sd->subele[ELE_WIND] -= i; sd->indexed_bonus.subele[ELE_WIND] -= i;
} }
if( sc->data[SC_WIND_CURTAIN_OPTION] ) { if( sc->data[SC_WIND_CURTAIN_OPTION] ) {
i = sc->data[SC_WIND_CURTAIN_OPTION]->val2; i = sc->data[SC_WIND_CURTAIN_OPTION]->val2;
sd->subele[ELE_WIND] += i; sd->indexed_bonus.subele[ELE_WIND] += i;
sd->subele[ELE_EARTH] -= i; sd->indexed_bonus.subele[ELE_EARTH] -= i;
} }
if( sc->data[SC_STONE_SHIELD_OPTION] ) { if( sc->data[SC_STONE_SHIELD_OPTION] ) {
i = sc->data[SC_STONE_SHIELD_OPTION]->val2; i = sc->data[SC_STONE_SHIELD_OPTION]->val2;
sd->subele[ELE_EARTH] += i; sd->indexed_bonus.subele[ELE_EARTH] += i;
sd->subele[ELE_FIRE] -= i; sd->indexed_bonus.subele[ELE_FIRE] -= i;
} }
if (sc->data[SC_MTF_MLEATKED] ) if (sc->data[SC_MTF_MLEATKED] )
sd->subele[ELE_NEUTRAL] += sc->data[SC_MTF_MLEATKED]->val3; sd->indexed_bonus.subele[ELE_NEUTRAL] += sc->data[SC_MTF_MLEATKED]->val3;
if (sc->data[SC_MTF_CRIDAMAGE]) if (sc->data[SC_MTF_CRIDAMAGE])
sd->bonus.crit_atk_rate += sc->data[SC_MTF_CRIDAMAGE]->val1; sd->bonus.crit_atk_rate += sc->data[SC_MTF_CRIDAMAGE]->val1;
if (sc->data[SC_GLASTHEIM_ATK]) { if (sc->data[SC_GLASTHEIM_ATK]) {
sd->ignore_mdef_by_race[RC_UNDEAD] += sc->data[SC_GLASTHEIM_ATK]->val1; sd->indexed_bonus.ignore_mdef_by_race[RC_UNDEAD] += sc->data[SC_GLASTHEIM_ATK]->val1;
sd->ignore_mdef_by_race[RC_DEMON] += sc->data[SC_GLASTHEIM_ATK]->val1; sd->indexed_bonus.ignore_mdef_by_race[RC_DEMON] += sc->data[SC_GLASTHEIM_ATK]->val1;
} }
if (sc->data[SC_LAUDARAMUS]) if (sc->data[SC_LAUDARAMUS])
sd->bonus.crit_atk_rate += 5 * sc->data[SC_LAUDARAMUS]->val1; sd->bonus.crit_atk_rate += 5 * sc->data[SC_LAUDARAMUS]->val1;
@ -4704,8 +4662,8 @@ int status_calc_pc_sub(struct map_session_data* sd, enum e_status_calc_opt opt)
sd->bonus.crit_atk_rate += 2 * sc->data[SC_FORTUNE]->val1; sd->bonus.crit_atk_rate += 2 * sc->data[SC_FORTUNE]->val1;
#endif #endif
if (sc->data[SC_SYMPHONYOFLOVER]) { if (sc->data[SC_SYMPHONYOFLOVER]) {
sd->subele[ELE_GHOST] += sc->data[SC_SYMPHONYOFLOVER]->val1 * 3; sd->indexed_bonus.subele[ELE_GHOST] += sc->data[SC_SYMPHONYOFLOVER]->val1 * 3;
sd->subele[ELE_HOLY] += sc->data[SC_SYMPHONYOFLOVER]->val1 * 3; sd->indexed_bonus.subele[ELE_HOLY] += sc->data[SC_SYMPHONYOFLOVER]->val1 * 3;
} }
if (sc->data[SC_PYREXIA] && sc->data[SC_PYREXIA]->val3 == 0) if (sc->data[SC_PYREXIA] && sc->data[SC_PYREXIA]->val3 == 0)
sd->bonus.crit_atk_rate += sc->data[SC_PYREXIA]->val2; sd->bonus.crit_atk_rate += sc->data[SC_PYREXIA]->val2;
@ -10981,8 +10939,8 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
case SC_CONCENTRATE: case SC_CONCENTRATE:
val2 = 2 + val1; val2 = 2 + val1;
if (sd) { // Store the card-bonus data that should not count in the % if (sd) { // Store the card-bonus data that should not count in the %
val3 = sd->param_bonus[1]; // Agi val3 = sd->indexed_bonus.param_bonus[1]; // Agi
val4 = sd->param_bonus[4]; // Dex val4 = sd->indexed_bonus.param_bonus[4]; // Dex
} else } else
val3 = val4 = 0; val3 = val4 = 0;
break; break;