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

Converts the SCB flags to bitset (#6661)

Browse Source
This commit is contained in:
Aleos 2022-03-16 15:59:23 -04:00 committed by GitHub
parent e3262d0be1
commit d739e8f44e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 200 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/map/script.cpp
View File

@ -18791,7 +18791,7 @@ BUILDIN_FUNC(setunitdata)
return SCRIPT_CMD_FAILURE; return SCRIPT_CMD_FAILURE;
} }
if (calc_status) if (calc_status)
status_calc_bl(&md->bl, SCB_BATTLE); status_calc_bl(&md->bl, status_db.getSCB_BATTLE());
break; break;
case BL_HOM: case BL_HOM:
@ -18858,7 +18858,7 @@ BUILDIN_FUNC(setunitdata)
return SCRIPT_CMD_FAILURE; return SCRIPT_CMD_FAILURE;
} }
if (calc_status) if (calc_status)
status_calc_bl(&hd->bl, SCB_BATTLE); status_calc_bl(&hd->bl, status_db.getSCB_BATTLE());
break; break;
case BL_PET: case BL_PET:
@ -18972,7 +18972,7 @@ BUILDIN_FUNC(setunitdata)
return SCRIPT_CMD_FAILURE; return SCRIPT_CMD_FAILURE;
} }
if (calc_status) if (calc_status)
status_calc_bl(&mc->bl, SCB_BATTLE); status_calc_bl(&mc->bl, status_db.getSCB_BATTLE());
break; break;
case BL_ELEM: case BL_ELEM:
@ -19039,7 +19039,7 @@ BUILDIN_FUNC(setunitdata)
return SCRIPT_CMD_FAILURE; return SCRIPT_CMD_FAILURE;
} }
if (calc_status) if (calc_status)
status_calc_bl(&ed->bl, SCB_BATTLE); status_calc_bl(&ed->bl, status_db.getSCB_BATTLE());
break; break;
case BL_NPC: case BL_NPC:

2
src/map/script_constants.hpp
View File

@ -8772,7 +8772,6 @@
export_constant(SCB_RANGE); export_constant(SCB_RANGE);
export_constant(SCB_REGEN); export_constant(SCB_REGEN);
export_constant(SCB_DYE); export_constant(SCB_DYE);
export_constant(SCB_BATTLE);
export_constant(SCB_MAXAP); export_constant(SCB_MAXAP);
export_constant(SCB_POW); export_constant(SCB_POW);
export_constant(SCB_STA); export_constant(SCB_STA);
@ -8786,7 +8785,6 @@
export_constant(SCB_MRES); export_constant(SCB_MRES);
export_constant(SCB_HPLUS); export_constant(SCB_HPLUS);
export_constant(SCB_CRATE); export_constant(SCB_CRATE);
export_constant(SCB_ALL);
/* status change states */ /* status change states */
export_constant(SCS_NONE); export_constant(SCS_NONE);

190
src/map/status.cpp
View File

@ -558,10 +558,10 @@ efst_type StatusDatabase::getIcon(sc_type type) {
* @param type: SC type * @param type: SC type
* @return cal_flag: Calc value * @return cal_flag: Calc value
**/ **/
uint64 StatusDatabase::getCalcFlag(sc_type type) { std::bitset<SCB_MAX> StatusDatabase::getCalcFlag(sc_type type) {
std::shared_ptr<s_status_change_db> status = status_db.find(type); std::shared_ptr<s_status_change_db> status = status_db.find(type);
return status ? status->calc_flag : SCB_NONE; return status ? status->calc_flag : std::bitset<SCB_MAX> {};
} }
/** /**
@ -618,6 +618,22 @@ bool StatusDatabase::hasSCF(status_change *sc, e_status_change_flag flag) {
return false; return false;
} }
/**
* Returns the SCB_BATTLE constant.
* return SCB_BATTLE
*/
std::bitset<SCB_MAX> StatusDatabase::getSCB_BATTLE() {
return this->SCB_BATTLE;
}
/**
* Returns the SCB_ALL constant.
* @return SCB_ALL
*/
std::bitset<SCB_MAX> StatusDatabase::getSCB_ALL() {
return this->SCB_ALL;
}
/** /**
* Removes statuses from skills that aren't part of the new class skill tree. * Removes statuses from skills that aren't part of the new class skill tree.
* @param sd: Player data * @param sd: Player data
@ -4883,7 +4899,7 @@ void status_calc_state( struct block_list *bl, struct status_change *sc, std::bi
* @param bl: Object whose status has changed [PC|MOB|HOM|MER|ELEM] * @param bl: Object whose status has changed [PC|MOB|HOM|MER|ELEM]
* @param flag: Which status has changed on bl * @param flag: Which status has changed on bl
*/ */
void status_calc_bl_main(struct block_list *bl, uint64 flag) void status_calc_bl_main(struct block_list *bl, std::bitset<SCB_MAX> flag)
{ {
const struct status_data *b_status = status_get_base_status(bl); // Base Status const struct status_data *b_status = status_get_base_status(bl); // Base Status
struct status_data *status = status_get_status_data(bl); // Battle Status struct status_data *status = status_get_status_data(bl); // Battle Status
@ -4898,7 +4914,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
* This needs to be done even if there is currently no status change active, because * This needs to be done even if there is currently no status change active, because
* we need to update the speed on the client when the last status change ends. * we need to update the speed on the client when the last status change ends.
**/ **/
if(flag&SCB_SPEED) { if(flag[SCB_SPEED]) {
struct unit_data *ud = unit_bl2ud(bl); struct unit_data *ud = unit_bl2ud(bl);
/** [Skotlex] /** [Skotlex]
* Re-walk to adjust speed (we do not check if walktimer != INVALID_TIMER * Re-walk to adjust speed (we do not check if walktimer != INVALID_TIMER
@ -4909,14 +4925,14 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
ud->state.change_walk_target = ud->state.speed_changed = 1; ud->state.change_walk_target = ud->state.speed_changed = 1;
} }
if(flag&SCB_STR) { if(flag[SCB_STR]) {
status->str = status_calc_str(bl, sc, b_status->str); status->str = status_calc_str(bl, sc, b_status->str);
flag|=SCB_BATK; flag|=SCB_BATK;
if( bl->type&BL_HOM ) if( bl->type&BL_HOM )
flag |= SCB_WATK; flag |= SCB_WATK;
} }
if(flag&SCB_AGI) { if(flag[SCB_AGI]) {
status->agi = status_calc_agi(bl, sc, b_status->agi); status->agi = status_calc_agi(bl, sc, b_status->agi);
flag|=SCB_FLEE flag|=SCB_FLEE
#ifdef RENEWAL #ifdef RENEWAL
@ -4927,7 +4943,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
flag |= SCB_ASPD|SCB_DSPD; flag |= SCB_ASPD|SCB_DSPD;
} }
if(flag&SCB_VIT) { if(flag[SCB_VIT]) {
status->vit = status_calc_vit(bl, sc, b_status->vit); status->vit = status_calc_vit(bl, sc, b_status->vit);
flag|=SCB_DEF2|SCB_MDEF2; flag|=SCB_DEF2|SCB_MDEF2;
if( bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM) ) if( bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM) )
@ -4936,7 +4952,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
flag |= SCB_DEF; flag |= SCB_DEF;
} }
if(flag&SCB_INT) { if(flag[SCB_INT]) {
status->int_ = status_calc_int(bl, sc, b_status->int_); status->int_ = status_calc_int(bl, sc, b_status->int_);
flag|=SCB_MATK|SCB_MDEF2; flag|=SCB_MATK|SCB_MDEF2;
if( bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM) ) if( bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM) )
@ -4945,7 +4961,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
flag |= SCB_MDEF; flag |= SCB_MDEF;
} }
if(flag&SCB_DEX) { if(flag[SCB_DEX]) {
status->dex = status_calc_dex(bl, sc, b_status->dex); status->dex = status_calc_dex(bl, sc, b_status->dex);
flag|=SCB_BATK|SCB_HIT flag|=SCB_BATK|SCB_HIT
#ifdef RENEWAL #ifdef RENEWAL
@ -4958,7 +4974,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
flag |= SCB_WATK; flag |= SCB_WATK;
} }
if(flag&SCB_LUK) { if(flag[SCB_LUK]) {
status->luk = status_calc_luk(bl, sc, b_status->luk); status->luk = status_calc_luk(bl, sc, b_status->luk);
flag|=SCB_BATK|SCB_CRI|SCB_FLEE2 flag|=SCB_BATK|SCB_CRI|SCB_FLEE2
#ifdef RENEWAL #ifdef RENEWAL
@ -4968,38 +4984,38 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
#ifdef RENEWAL #ifdef RENEWAL
if (flag&SCB_POW) { if (flag[SCB_POW]) {
status->pow = status_calc_pow(bl, sc, b_status->pow); status->pow = status_calc_pow(bl, sc, b_status->pow);
flag |= SCB_BATK|SCB_PATK; flag |= SCB_BATK|SCB_PATK;
} }
if (flag&SCB_STA) { if (flag[SCB_STA]) {
status->sta = status_calc_sta(bl, sc, b_status->sta); status->sta = status_calc_sta(bl, sc, b_status->sta);
flag |= SCB_RES; flag |= SCB_RES;
} }
if (flag&SCB_WIS) { if (flag[SCB_WIS]) {
status->wis = status_calc_wis(bl, sc, b_status->wis); status->wis = status_calc_wis(bl, sc, b_status->wis);
flag |= SCB_MRES; flag |= SCB_MRES;
} }
if (flag&SCB_SPL) { if (flag[SCB_SPL]) {
status->spl = status_calc_spl(bl, sc, b_status->spl); status->spl = status_calc_spl(bl, sc, b_status->spl);
flag |= SCB_MATK|SCB_SMATK; flag |= SCB_MATK|SCB_SMATK;
} }
if (flag&SCB_CON) { if (flag[SCB_CON]) {
status->con = status_calc_con(bl, sc, b_status->con); status->con = status_calc_con(bl, sc, b_status->con);
flag |= SCB_HIT|SCB_FLEE|SCB_PATK|SCB_SMATK; flag |= SCB_HIT|SCB_FLEE|SCB_PATK|SCB_SMATK;
} }
if (flag&SCB_CRT) { if (flag[SCB_CRT]) {
status->crt = status_calc_crt(bl, sc, b_status->crt); status->crt = status_calc_crt(bl, sc, b_status->crt);
flag |= SCB_HPLUS|SCB_CRATE; flag |= SCB_HPLUS|SCB_CRATE;
} }
#endif #endif
if(flag&SCB_BATK && b_status->batk) { if(flag[SCB_BATK] && b_status->batk) {
int lv = status_get_lv(bl); int lv = status_get_lv(bl);
status->batk = status_base_atk(bl, status, lv); status->batk = status_base_atk(bl, status, lv);
temp = b_status->batk - status_base_atk(bl, b_status, lv); temp = b_status->batk - status_base_atk(bl, b_status, lv);
@ -5010,7 +5026,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
status->batk = status_calc_batk(bl, sc, status->batk); status->batk = status_calc_batk(bl, sc, status->batk);
} }
if(flag&SCB_WATK) { if(flag[SCB_WATK]) {
#ifndef RENEWAL #ifndef RENEWAL
status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk); status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk);
if (!sd) // Should not affect weapon refine bonus if (!sd) // Should not affect weapon refine bonus
@ -5037,7 +5053,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
#endif #endif
} }
if(flag&SCB_HIT) { if(flag[SCB_HIT]) {
if (status->dex == b_status->dex if (status->dex == b_status->dex
#ifdef RENEWAL #ifdef RENEWAL
&& status->luk == b_status->luk && status->con == b_status->con && status->luk == b_status->luk && status->con == b_status->con
@ -5052,7 +5068,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
); );
} }
if(flag&SCB_FLEE) { if(flag[SCB_FLEE]) {
if (status->agi == b_status->agi if (status->agi == b_status->agi
#ifdef RENEWAL #ifdef RENEWAL
&& status->luk == b_status->luk && status->con == b_status->con && status->luk == b_status->luk && status->con == b_status->con
@ -5067,14 +5083,14 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
); );
} }
if(flag&SCB_DEF) { if(flag[SCB_DEF]) {
status->def = status_calc_def(bl, sc, b_status->def); status->def = status_calc_def(bl, sc, b_status->def);
if( bl->type&BL_HOM ) if( bl->type&BL_HOM )
status->def += (status->vit/5 - b_status->vit/5); status->def += (status->vit/5 - b_status->vit/5);
} }
if(flag&SCB_DEF2) { if(flag[SCB_DEF2]) {
if (status->vit == b_status->vit if (status->vit == b_status->vit
#ifdef RENEWAL #ifdef RENEWAL
&& status->agi == b_status->agi && status->agi == b_status->agi
@ -5091,14 +5107,14 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
); );
} }
if(flag&SCB_MDEF) { if(flag[SCB_MDEF]) {
status->mdef = status_calc_mdef(bl, sc, b_status->mdef); status->mdef = status_calc_mdef(bl, sc, b_status->mdef);
if( bl->type&BL_HOM ) if( bl->type&BL_HOM )
status->mdef += (status->int_/5 - b_status->int_/5); status->mdef += (status->int_/5 - b_status->int_/5);
} }
if(flag&SCB_MDEF2) { if(flag[SCB_MDEF2]) {
if (status->int_ == b_status->int_ && status->vit == b_status->vit if (status->int_ == b_status->int_ && status->vit == b_status->vit
#ifdef RENEWAL #ifdef RENEWAL
&& status->dex == b_status->dex && status->dex == b_status->dex
@ -5115,7 +5131,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
); );
} }
if(flag&SCB_SPEED) { if(flag[SCB_SPEED]) {
status->speed = status_calc_speed(bl, sc, b_status->speed); status->speed = status_calc_speed(bl, sc, b_status->speed);
if( bl->type&BL_PC && !(sd && sd->state.permanent_speed) && status->speed < battle_config.max_walk_speed ) if( bl->type&BL_PC && !(sd && sd->state.permanent_speed) && status->speed < battle_config.max_walk_speed )
@ -5131,7 +5147,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
status->speed = status_get_speed(&((TBL_ELEM*)bl)->master->bl); status->speed = status_get_speed(&((TBL_ELEM*)bl)->master->bl);
} }
if(flag&SCB_CRI && b_status->cri) { if(flag[SCB_CRI] && b_status->cri) {
if (status->luk == b_status->luk) if (status->luk == b_status->luk)
status->cri = status_calc_critical(bl, sc, b_status->cri); status->cri = status_calc_critical(bl, sc, b_status->cri);
else else
@ -5144,26 +5160,26 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
} }
if(flag&SCB_FLEE2 && b_status->flee2) { if(flag[SCB_FLEE2] && b_status->flee2) {
if (status->luk == b_status->luk) if (status->luk == b_status->luk)
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2); status->flee2 = status_calc_flee2(bl, sc, b_status->flee2);
else else
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk)); status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk));
} }
if(flag&SCB_ATK_ELE) { if(flag[SCB_ATK_ELE]) {
status->rhw.ele = status_calc_attack_element(bl, sc, b_status->rhw.ele); status->rhw.ele = status_calc_attack_element(bl, sc, b_status->rhw.ele);
if (sd) sd->state.lr_flag = 1; if (sd) sd->state.lr_flag = 1;
status->lhw.ele = status_calc_attack_element(bl, sc, b_status->lhw.ele); status->lhw.ele = status_calc_attack_element(bl, sc, b_status->lhw.ele);
if (sd) sd->state.lr_flag = 0; if (sd) sd->state.lr_flag = 0;
} }
if(flag&SCB_DEF_ELE) { if(flag[SCB_DEF_ELE]) {
status->def_ele = status_calc_element(bl, sc, b_status->def_ele); status->def_ele = status_calc_element(bl, sc, b_status->def_ele);
status->ele_lv = status_calc_element_lv(bl, sc, b_status->ele_lv); status->ele_lv = status_calc_element_lv(bl, sc, b_status->ele_lv);
} }
if(flag&SCB_MODE) { if(flag[SCB_MODE]) {
status->mode = status_calc_mode(bl, sc, b_status->mode); status->mode = status_calc_mode(bl, sc, b_status->mode);
if (status_has_mode(status, MD_STATUSIMMUNE|MD_SKILLIMMUNE)) if (status_has_mode(status, MD_STATUSIMMUNE|MD_SKILLIMMUNE))
@ -5184,12 +5200,12 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
/** /**
* No status changes alter these yet. * No status changes alter these yet.
* if(flag&SCB_SIZE) * if(flag[SCB_SIZE])
* if(flag&SCB_RACE) * if(flag[SCB_RACE])
* if(flag&SCB_RANGE) * if(flag[SCB_RANGE])
**/ **/
if(flag&SCB_MAXHP) { if(flag[SCB_MAXHP]) {
if( bl->type&BL_PC ) { if( bl->type&BL_PC ) {
status->max_hp = status_calc_maxhpsp_pc(sd,status->vit,true); status->max_hp = status_calc_maxhpsp_pc(sd,status->vit,true);
@ -5212,7 +5228,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
} }
if(flag&SCB_MAXSP) { if(flag[SCB_MAXSP]) {
if( bl->type&BL_PC ) { if( bl->type&BL_PC ) {
status->max_sp = status_calc_maxhpsp_pc(sd,status->int_,false); status->max_sp = status_calc_maxhpsp_pc(sd,status->int_,false);
@ -5230,7 +5246,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
} }
if(flag&SCB_MATK) { if(flag[SCB_MATK]) {
#ifndef RENEWAL #ifndef RENEWAL
status->matk_min = status_base_matk_min(status) + (sd?sd->bonus.ematk:0); status->matk_min = status_base_matk_min(status) + (sd?sd->bonus.ematk:0);
status->matk_max = status_base_matk_max(status) + (sd?sd->bonus.ematk:0); status->matk_max = status_base_matk_max(status) + (sd?sd->bonus.ematk:0);
@ -5315,7 +5331,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
status->matk_min = status_calc_matk(bl, sc, status->matk_min); status->matk_min = status_calc_matk(bl, sc, status->matk_min);
} }
if(flag&SCB_ASPD) { if(flag[SCB_ASPD]) {
int amotion; int amotion;
if ( bl->type&BL_HOM ) { if ( bl->type&BL_HOM ) {
@ -5374,7 +5390,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
} }
if(flag&SCB_DSPD) { if(flag[SCB_DSPD]) {
int dmotion; int dmotion;
if( bl->type&BL_PC ) { if( bl->type&BL_PC ) {
if (b_status->agi == status->agi) if (b_status->agi == status->agi)
@ -5397,49 +5413,49 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
#ifdef RENEWAL #ifdef RENEWAL
if (flag&SCB_PATK) { if (flag[SCB_PATK]) {
if (status->pow == b_status->pow && status->con == b_status->con) if (status->pow == b_status->pow && status->con == b_status->con)
status->patk = status_calc_patk(bl, sc, b_status->patk); status->patk = status_calc_patk(bl, sc, b_status->patk);
else else
status->patk = status_calc_patk(bl, sc, b_status->patk + (status->pow - b_status->pow) / 3 + (status->con - b_status->con) / 5); status->patk = status_calc_patk(bl, sc, b_status->patk + (status->pow - b_status->pow) / 3 + (status->con - b_status->con) / 5);
} }
if (flag&SCB_SMATK) { if (flag[SCB_SMATK]) {
if (status->spl == b_status->spl && status->con == b_status->con) if (status->spl == b_status->spl && status->con == b_status->con)
status->smatk = status_calc_smatk(bl, sc, b_status->smatk); status->smatk = status_calc_smatk(bl, sc, b_status->smatk);
else else
status->smatk = status_calc_smatk(bl, sc, b_status->smatk) + (status->spl - b_status->spl) / 3 + (status->con - b_status->con) / 5; status->smatk = status_calc_smatk(bl, sc, b_status->smatk) + (status->spl - b_status->spl) / 3 + (status->con - b_status->con) / 5;
} }
if (flag&SCB_RES) { if (flag[SCB_RES]) {
if (status->sta == b_status->sta) if (status->sta == b_status->sta)
status->res = status_calc_res(bl, sc, b_status->res); status->res = status_calc_res(bl, sc, b_status->res);
else else
status->res = status_calc_res(bl, sc, b_status->res + (status->sta - b_status->sta) + (status->sta - b_status->sta) / 3 * 5); status->res = status_calc_res(bl, sc, b_status->res + (status->sta - b_status->sta) + (status->sta - b_status->sta) / 3 * 5);
} }
if (flag&SCB_MRES) { if (flag[SCB_MRES]) {
if (status->wis == b_status->wis) if (status->wis == b_status->wis)
status->mres = status_calc_mres(bl, sc, b_status->mres); status->mres = status_calc_mres(bl, sc, b_status->mres);
else else
status->mres = status_calc_mres(bl, sc, b_status->mres + (status->wis - b_status->wis) + (status->wis - b_status->wis) / 3 * 5); status->mres = status_calc_mres(bl, sc, b_status->mres + (status->wis - b_status->wis) + (status->wis - b_status->wis) / 3 * 5);
} }
if (flag&SCB_HPLUS) { if (flag[SCB_HPLUS]) {
if (status->crt == b_status->crt) if (status->crt == b_status->crt)
status->hplus = status_calc_hplus(bl, sc, b_status->hplus); status->hplus = status_calc_hplus(bl, sc, b_status->hplus);
else else
status->hplus = status_calc_hplus(bl, sc, b_status->hplus + (status->crt - b_status->crt)); status->hplus = status_calc_hplus(bl, sc, b_status->hplus + (status->crt - b_status->crt));
} }
if (flag&SCB_CRATE) { if (flag[SCB_CRATE]) {
if (status->crt == b_status->crt) if (status->crt == b_status->crt)
status->crate = status_calc_crate(bl, sc, b_status->crate); status->crate = status_calc_crate(bl, sc, b_status->crate);
else else
status->crate = status_calc_crate(bl, sc, b_status->crate + (status->crt - b_status->crt) / 3); status->crate = status_calc_crate(bl, sc, b_status->crate + (status->crt - b_status->crt) / 3);
} }
if (flag&SCB_MAXAP) { if (flag[SCB_MAXAP]) {
if (bl->type&BL_PC) { if (bl->type&BL_PC) {
status->max_ap = status_calc_maxap_pc(sd); status->max_ap = status_calc_maxap_pc(sd);
@ -5457,10 +5473,10 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
} }
#endif #endif
if(flag&(SCB_VIT|SCB_MAXHP|SCB_INT|SCB_MAXSP) && bl->type&BL_REGEN) if((flag[SCB_VIT] || flag[SCB_MAXHP] || flag[SCB_INT] || flag[SCB_MAXSP]) && bl->type &BL_REGEN)
status_calc_regen(bl, status, status_get_regen_data(bl)); status_calc_regen(bl, status, status_get_regen_data(bl));
if(flag&SCB_REGEN && bl->type&BL_REGEN) if(flag[SCB_REGEN] && bl->type&BL_REGEN)
status_calc_regen_rate(bl, status_get_regen_data(bl), sc); status_calc_regen_rate(bl, status_get_regen_data(bl), sc);
} }
@ -5472,7 +5488,7 @@ void status_calc_bl_main(struct block_list *bl, uint64 flag)
* @param flag: Which status has changed on bl * @param flag: Which status has changed on bl
* @param opt: If true, will cause status_calc_* functions to run their base status initialization code * @param opt: If true, will cause status_calc_* functions to run their base status initialization code
*/ */
void status_calc_bl_(struct block_list* bl, uint64 flag, uint8 opt) void status_calc_bl_(struct block_list* bl, std::bitset<SCB_MAX> flag, uint8 opt)
{ {
struct status_data b_status; // Previous battle status struct status_data b_status; // Previous battle status
struct status_data* status; // Pointer to current battle status struct status_data* status; // Pointer to current battle status
@ -5494,7 +5510,7 @@ void status_calc_bl_(struct block_list* bl, uint64 flag, uint8 opt)
status = status_get_status_data(bl); status = status_get_status_data(bl);
memcpy(&b_status, status, sizeof(struct status_data)); memcpy(&b_status, status, sizeof(struct status_data));
if( flag&SCB_BASE ) { // Calculate the object's base status too if( flag[SCB_BASE] ) { // Calculate the object's base status too
switch( bl->type ) { switch( bl->type ) {
case BL_PC: status_calc_pc_(BL_CAST(BL_PC,bl), opt); break; case BL_PC: status_calc_pc_(BL_CAST(BL_PC,bl), opt); break;
case BL_MOB: status_calc_mob_(BL_CAST(BL_MOB,bl), opt); break; case BL_MOB: status_calc_mob_(BL_CAST(BL_MOB,bl), opt); break;
@ -9135,7 +9151,6 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
struct status_data *status; struct status_data *status;
struct view_data *vd; struct view_data *vd;
int undead_flag, tick_time = 0; int undead_flag, tick_time = 0;
uint64 calc_flag;
bool sc_isnew = true; bool sc_isnew = true;
std::shared_ptr<s_status_change_db> scdb = status_db.find(type); std::shared_ptr<s_status_change_db> scdb = status_db.find(type);
@ -9666,7 +9681,8 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
} }
vd = status_get_viewdata(bl); vd = status_get_viewdata(bl);
calc_flag = scdb->calc_flag; std::bitset<SCB_MAX> calc_flag = scdb->calc_flag;
if(!(flag&SCSTART_LOADED)) // &4 - Do not parse val settings when loading SCs if(!(flag&SCSTART_LOADED)) // &4 - Do not parse val settings when loading SCs
switch(type) switch(type)
{ {
@ -10021,7 +10037,7 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
val3 = max(val3, 100); // Incubation time val3 = max(val3, 100); // Incubation time
val4 = max(tick-val3, 100); // Petrify time val4 = max(tick-val3, 100); // Petrify time
tick = val3; tick = val3;
calc_flag = SCB_NONE; // Actual status changes take effect on petrified state. calc_flag.reset(); // Actual status changes take effect on petrified state.
break; break;
case SC_DPOISON: case SC_DPOISON:
@ -11802,7 +11818,7 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
break; break;
default: default:
if (calc_flag == SCB_NONE && scdb->skill_id == 0 && scdb->icon == EFST_BLANK && scdb->opt1 == OPT1_NONE && scdb->opt2 == OPT2_NONE && scdb->state.none() && scdb->flag.none() && scdb->end.empty() && scdb->fail.empty()) { if (calc_flag.none() && scdb->skill_id == 0 && scdb->icon == EFST_BLANK && scdb->opt1 == OPT1_NONE && scdb->opt2 == OPT2_NONE && scdb->state.none() && scdb->flag.none() && scdb->end.empty() && scdb->fail.empty()) {
// Status change with no calc, no icon, and no skill associated...? // Status change with no calc, no icon, and no skill associated...?
ShowWarning("status_change_start: Status %s (%d) is bare. Add the NoWarning flag to suppress this message.\n", script_get_constant_str("SC_", type), type); ShowWarning("status_change_start: Status %s (%d) is bare. Add the NoWarning flag to suppress this message.\n", script_get_constant_str("SC_", type), type);
return 0; return 0;
@ -11975,22 +11991,22 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
} }
} }
if (calc_flag&SCB_DYE) { // Reset DYE color if (calc_flag[SCB_DYE]) { // Reset DYE color
if (vd && vd->cloth_color) { if (vd && vd->cloth_color) {
val4 = vd->cloth_color; val4 = vd->cloth_color;
clif_changelook(bl,LOOK_CLOTHES_COLOR,0); clif_changelook(bl,LOOK_CLOTHES_COLOR,0);
} }
calc_flag&=~SCB_DYE; calc_flag.reset(SCB_DYE);
} }
/*if (calc_flag&SCB_BODY)// Might be needed in the future. [Rytech] /*if (calc_flag[SCB_BODY])// Might be needed in the future. [Rytech]
{ //Reset body style { //Reset body style
if (vd && vd->body_style) if (vd && vd->body_style)
{ {
val4 = vd->body_style; val4 = vd->body_style;
clif_changelook(bl,LOOK_BODY2,0); clif_changelook(bl,LOOK_BODY2,0);
} }
calc_flag&=~SCB_BODY; calc_flag.reset(SCB_BODY);
}*/ }*/
if (!(flag&SCSTART_NOICON) && !(flag&SCSTART_LOADED && scdb->flag[SCF_DISPLAYPC] || scdb->flag[SCF_DISPLAYNPC])) { if (!(flag&SCSTART_NOICON) && !(flag&SCSTART_LOADED && scdb->flag[SCF_DISPLAYPC] || scdb->flag[SCF_DISPLAYNPC])) {
@ -12026,14 +12042,14 @@ int status_change_start(struct block_list* src, struct block_list* bl,enum sc_ty
else else
sce->timer = INVALID_TIMER; // Infinite duration sce->timer = INVALID_TIMER; // Infinite duration
if (calc_flag) { if (calc_flag.any()) {
if (sd) { if (sd) {
switch(type) { switch(type) {
// Statuses that adjust HP/SP and heal after starting // Statuses that adjust HP/SP and heal after starting
case SC_BERSERK: case SC_BERSERK:
case SC_MERC_HPUP: case SC_MERC_HPUP:
case SC_MERC_SPUP: case SC_MERC_SPUP:
status_calc_bl_(bl, static_cast<e_scb_flag>(calc_flag), SCO_FORCE); status_calc_bl_(bl, calc_flag, SCO_FORCE);
break; break;
default: default:
status_calc_bl(bl, calc_flag); status_calc_bl(bl, calc_flag);
@ -12225,7 +12241,6 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
struct status_change_entry *sce; struct status_change_entry *sce;
struct status_data *status; struct status_data *status;
struct view_data *vd; struct view_data *vd;
e_scb_flag calc_flag = SCB_NONE;
std::shared_ptr<s_status_change_db> scdb = status_db.find(type); std::shared_ptr<s_status_change_db> scdb = status_db.find(type);
nullpo_ret(bl); nullpo_ret(bl);
@ -12314,7 +12329,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
status_display_remove(bl,type); status_display_remove(bl,type);
vd = status_get_viewdata(bl); vd = status_get_viewdata(bl);
calc_flag = static_cast<e_scb_flag>(scdb->calc_flag); std::bitset<SCB_MAX> calc_flag = scdb->calc_flag;
switch(type) { switch(type) {
case SC_KEEPING: case SC_KEEPING:
@ -12701,7 +12716,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
clif_status_load(bl, EFST_ACTIVE_MONSTER_TRANSFORM, 0); clif_status_load(bl, EFST_ACTIVE_MONSTER_TRANSFORM, 0);
break; break;
case SC_INTRAVISION: case SC_INTRAVISION:
calc_flag = SCB_ALL; // Required for overlapping calc_flag = status_db.getSCB_ALL(); // Required for overlapping
break; break;
case SC_SUNSTANCE: case SC_SUNSTANCE:
@ -12879,17 +12894,17 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
if (scdb->look) if (scdb->look)
sc->option &= ~scdb->look; sc->option &= ~scdb->look;
if (calc_flag&SCB_DYE) { // Restore DYE color if (calc_flag[SCB_DYE]) { // Restore DYE color
if (vd && !vd->cloth_color && sce->val4) if (vd && !vd->cloth_color && sce->val4)
clif_changelook(bl,LOOK_CLOTHES_COLOR,sce->val4); clif_changelook(bl,LOOK_CLOTHES_COLOR,sce->val4);
calc_flag = static_cast<e_scb_flag>(calc_flag&~SCB_DYE); calc_flag.reset(SCB_DYE);
} }
/*if (calc_flag&SCB_BODY)// Might be needed in the future. [Rytech] /*if (calc_flag[SCB_BODY])// Might be needed in the future. [Rytech]
{ //Restore body style { //Restore body style
if (vd && !vd->body_style && sce->val4) if (vd && !vd->body_style && sce->val4)
clif_changelook(bl,LOOK_BODY2,sce->val4); clif_changelook(bl,LOOK_BODY2,sce->val4);
calc_flag = static_cast<scb_flag>(calc_flag&~SCB_BODY); calc_flag.reset(SCB_BODY);
}*/ }*/
// On Aegis, when turning off a status change, first goes the sc packet, then the option packet. // On Aegis, when turning off a status change, first goes the sc packet, then the option packet.
@ -12915,7 +12930,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
clif_changelook(bl,LOOK_BODY2,cap_value(sd->status.body,0,battle_config.max_body_style)); clif_changelook(bl,LOOK_BODY2,cap_value(sd->status.body,0,battle_config.max_body_style));
} }
} }
if (calc_flag) { if (calc_flag.any()) {
#ifndef RENEWAL #ifndef RENEWAL
if (type == SC_MAGICPOWER) { if (type == SC_MAGICPOWER) {
//If Mystical Amplification ends, MATK is immediately recalculated //If Mystical Amplification ends, MATK is immediately recalculated
@ -14100,24 +14115,24 @@ void status_change_clear_buffs(struct block_list* bl, uint8 type)
//Clears buffs with specified flag and type //Clears buffs with specified flag and type
for (const auto &it : status_db) { for (const auto &it : status_db) {
sc_type status = static_cast<sc_type>(it.first); sc_type status = static_cast<sc_type>(it.first);
e_scb_flag flag = static_cast<e_scb_flag>(it.second->calc_flag); std::bitset<SCF_MAX> flag = it.second->flag;
if (!sc->data[status] || flag&SCF_NOCLEARBUFF) //Skip status with SCF_NOCLEARBUFF, no matter what if (!sc->data[status] || flag[SCF_NOCLEARBUFF]) //Skip status with SCF_NOCLEARBUFF, no matter what
continue; continue;
// &SCCB_LUXANIMA : Cleared by RK_LUXANIMA // &SCCB_LUXANIMA : Cleared by RK_LUXANIMA
if (!(type&SCCB_LUXANIMA) && flag&SCF_REMOVEONLUXANIMA) if (!(type&SCCB_LUXANIMA) && flag[SCF_REMOVEONLUXANIMA])
continue; continue;
// &SCCB_CHEM_PROTECT : Clears AM_CP_ARMOR/HELP/SHIELD/WEAPON // &SCCB_CHEM_PROTECT : Clears AM_CP_ARMOR/HELP/SHIELD/WEAPON
if (!(type&SCCB_CHEM_PROTECT) && flag&SCF_REMOVECHEMICALPROTECT) if (!(type&SCCB_CHEM_PROTECT) && flag[SCF_REMOVECHEMICALPROTECT])
continue; continue;
// &SCCB_REFRESH : Cleared by RK_REFRESH // &SCCB_REFRESH : Cleared by RK_REFRESH
if (!(type&SCCB_REFRESH) && flag&SCF_REMOVEONREFRESH) if (!(type&SCCB_REFRESH) && flag[SCF_REMOVEONREFRESH])
continue; continue;
// &SCCB_DEBUFFS : Clears debuffs // &SCCB_DEBUFFS : Clears debuffs
if (!(type&SCCB_DEBUFFS) && flag&SCF_DEBUFF) if (!(type&SCCB_DEBUFFS) && flag[SCF_DEBUFF])
continue; continue;
// &SCCB_BUFFS : Clears buffs // &SCCB_BUFFS : Clears buffs
if (!(type&SCCB_BUFFS) && !(flag&SCF_DEBUFF)) if (!(type&SCCB_BUFFS) && !(flag[SCF_DEBUFF]))
continue; continue;
if (status == SC_SATURDAYNIGHTFEVER || status == SC_BERSERK) // Mark to not lose HP if (status == SC_SATURDAYNIGHTFEVER || status == SC_BERSERK) // Mark to not lose HP
sc->data[status]->val2 = 0; sc->data[status]->val2 = 0;
@ -14658,16 +14673,32 @@ uint64 StatusDatabase::parseBodyNode(const YAML::Node &node) {
} }
} else { } else {
if (!exists) if (!exists)
status->state = SCS_NONE; status->state.reset();
} }
if (this->nodeExists(node, "CalcFlags")) { if (this->nodeExists(node, "CalcFlags")) {
const YAML::Node &flagNode = node["CalcFlags"]; const YAML::Node &flagNode = node["CalcFlags"];
if (this->nodeExists(flagNode, "All")) {
bool active;
if (!this->asBool(flagNode, "All", active))
return 0;
if (active)
status->calc_flag = status_db.SCB_ALL;
else
status->calc_flag.reset();
}
for (const auto &it : flagNode) { for (const auto &it : flagNode) {
std::string flag = it.first.as<std::string>(), flag_constant = "SCB_" + flag; std::string flag = it.first.as<std::string>(), flag_constant = "SCB_" + flag;
int64 constant; int64 constant;
// Skipped because processed above the loop
if (flag.compare("All") == 0)
continue;
if (!script_get_constant(flag_constant.c_str(), &constant)) { if (!script_get_constant(flag_constant.c_str(), &constant)) {
this->invalidWarning(flagNode, "CalcFlag %s is invalid.\n", flag.c_str()); this->invalidWarning(flagNode, "CalcFlag %s is invalid.\n", flag.c_str());
return 0; return 0;
@ -14684,13 +14715,13 @@ uint64 StatusDatabase::parseBodyNode(const YAML::Node &node) {
return 0; return 0;
if (active) if (active)
status->calc_flag |= static_cast<e_scb_flag>(constant); status->calc_flag.set(static_cast<e_scb_flag>(constant));
else else
status->calc_flag &= ~static_cast<e_scb_flag>(constant); status->calc_flag.reset(static_cast<e_scb_flag>(constant));
} }
} else { } else {
if (!exists) if (!exists)
status->calc_flag = SCB_NONE; status->calc_flag.reset();
} }
if (this->nodeExists(node, "Opt1")) { if (this->nodeExists(node, "Opt1")) {
@ -14841,6 +14872,9 @@ uint64 StatusDatabase::parseBodyNode(const YAML::Node &node) {
else else
status->flag.reset(static_cast<e_status_change_flag>(constant)); status->flag.reset(static_cast<e_status_change_flag>(constant));
} }
} else {
if (!exists)
status->flag.reset();
} }
if (this->nodeExists(node, "MinRate")) { if (this->nodeExists(node, "MinRate")) {

162
src/map/status.hpp
View File

@ -2693,62 +2693,57 @@ enum e_scs_flag : uint8 {
}; };
///Define flags for the status_calc_bl function. [Skotlex] ///Define flags for the status_calc_bl function. [Skotlex]
enum e_scb_flag : uint64 { enum e_scb_flag : uint8 {
SCB_NONE = 0x0, SCB_NONE = 0,
SCB_BASE = 0x00000001, SCB_BASE,
SCB_MAXHP = 0x00000002, SCB_MAXHP,
SCB_MAXSP = 0x00000004, SCB_MAXSP,
SCB_STR = 0x00000008, SCB_STR,
SCB_AGI = 0x00000010, SCB_AGI,
SCB_VIT = 0x00000020, SCB_VIT,
SCB_INT = 0x00000040, SCB_INT,
SCB_DEX = 0x00000080, SCB_DEX,
SCB_LUK = 0x00000100, SCB_LUK,
SCB_BATK = 0x00000200, SCB_BATK,
SCB_WATK = 0x00000400, SCB_WATK,
SCB_MATK = 0x00000800, SCB_MATK,
SCB_HIT = 0x00001000, SCB_HIT,
SCB_FLEE = 0x00002000, SCB_FLEE,
SCB_DEF = 0x00004000, SCB_DEF,
SCB_DEF2 = 0x00008000, SCB_DEF2,
SCB_MDEF = 0x00010000, SCB_MDEF,
SCB_MDEF2 = 0x00020000, SCB_MDEF2,
SCB_SPEED = 0x00040000, SCB_SPEED,
SCB_ASPD = 0x00080000, SCB_ASPD,
SCB_DSPD = 0x00100000, SCB_DSPD,
SCB_CRI = 0x00200000, SCB_CRI,
SCB_FLEE2 = 0x00400000, SCB_FLEE2,
SCB_ATK_ELE = 0x00800000, SCB_ATK_ELE,
SCB_DEF_ELE = 0x01000000, SCB_DEF_ELE,
SCB_MODE = 0x02000000, SCB_MODE,
SCB_SIZE = 0x04000000, SCB_SIZE,
SCB_RACE = 0x08000000, SCB_RACE,
SCB_RANGE = 0x10000000, SCB_RANGE,
SCB_REGEN = 0x20000000, SCB_REGEN,
// 4th Job T.Stat/T.Sub-Stat Flags // 4th Job T.Stat/T.Sub-Stat Flags
SCB_MAXAP = 0x40000000, SCB_MAXAP,
SCB_POW = 0x80000000, SCB_POW,
SCB_STA = 0x000100000000, SCB_STA,
SCB_WIS = 0x000200000000, SCB_WIS,
SCB_SPL = 0x000400000000, SCB_SPL,
SCB_CON = 0x000800000000, SCB_CON,
SCB_CRT = 0x001000000000, SCB_CRT,
SCB_PATK = 0x002000000000, SCB_PATK,
SCB_SMATK = 0x004000000000, SCB_SMATK,
SCB_RES = 0x008000000000, SCB_RES,
SCB_MRES = 0x010000000000, SCB_MRES,
SCB_HPLUS = 0x020000000000, SCB_HPLUS,
SCB_CRATE = 0x040000000000, SCB_CRATE,
// Extra Flags // Extra Flags
// These are flags not sent through battle/all flags. Always keep these last. SCB_DYE, // force cloth-dye change to 0 to avoid client crashes.
SCB_DYE = 0x080000000000, // force cloth-dye change to 0 to avoid client crashes. SCB_MAX,
// Special flags for updating all stat/sub-stat stuff on request.
SCB_BATTLE = 0x07FFFFFFFFFE, // All except BASE and extra flags.
SCB_ALL = 0x07FFFFFFFFFF, // All except extra flags.
SCB_MAX = 0x0FFFFFFFFFFF,
}; };
enum e_status_calc_opt : uint8 { enum e_status_calc_opt : uint8 {
@ -2859,28 +2854,34 @@ enum e_status_change_flag : uint16 {
/// Struct of SC configs [Cydh] /// Struct of SC configs [Cydh]
struct s_status_change_db { struct s_status_change_db {
sc_type type; ///< SC_ sc_type type; ///< SC_
efst_type icon; ///< EFST_ efst_type icon; ///< EFST_
std::bitset<SCS_MAX> state; ///< SCS_ std::bitset<SCS_MAX> state; ///< SCS_
uint64 calc_flag; ///< SCB_ flags std::bitset<SCB_MAX> calc_flag; ///< SCB_ flags
uint16 opt1; ///< OPT1_ uint16 opt1; ///< OPT1_
uint16 opt2; ///< OPT2_ uint16 opt2; ///< OPT2_
uint32 opt3; ///< OPT3_ uint32 opt3; ///< OPT3_
uint32 look; ///, OPTION_ Changelook uint32 look; ///< OPTION_ Changelook
std::bitset<SCF_MAX> flag; ///< SCF_ Flags, enum e_status_change_flag std::bitset<SCF_MAX> flag; ///< SCF_ Flags, enum e_status_change_flag
bool display; ///< Display status effect/icon (for certain state) bool display; ///< Display status effect/icon (for certain state)
uint16 skill_id; ///< Associated skill for (addeff) duration lookups uint16 skill_id; ///< Associated skill for (addeff) duration lookups
std::vector<sc_type> end; ///< List of SC that will be ended when this SC is activated std::vector<sc_type> end; ///< List of SC that will be ended when this SC is activated
std::vector<sc_type> fail; ///< List of SC that causing this SC cannot be activated std::vector<sc_type> fail; ///< List of SC that causing this SC cannot be activated
bool end_return; ///< After SC ends the SC from end list, it does nothing bool end_return; ///< After SC ends the SC from end list, it does nothing
t_tick min_duration; ///< Minimum duration effect (after all status reduction) t_tick min_duration; ///< Minimum duration effect (after all status reduction)
uint16 min_rate; ///< Minimum rate to be applied (after all status reduction) uint16 min_rate; ///< Minimum rate to be applied (after all status reduction)
}; };
class StatusDatabase : public TypesafeCachedYamlDatabase<uint16, s_status_change_db> { class StatusDatabase : public TypesafeCachedYamlDatabase<uint16, s_status_change_db> {
public: public:
StatusDatabase() : TypesafeCachedYamlDatabase("STATUS_DB", 1) { StatusDatabase() : TypesafeCachedYamlDatabase("STATUS_DB", 1) {
// All except BASE and extra flags.
SCB_BATTLE.set();
SCB_BATTLE.reset(SCB_BASE);
SCB_BATTLE.reset(SCB_DYE);
// All except extra flags.
SCB_ALL.set();
SCB_ALL.reset(SCB_DYE);
} }
const std::string getDefaultLocation() override; const std::string getDefaultLocation() override;
@ -2892,13 +2893,18 @@ public:
// Extras // Extras
efst_type getIcon(sc_type type); efst_type getIcon(sc_type type);
uint64 getCalcFlag(sc_type type); std::bitset<SCB_MAX> getCalcFlag(sc_type type);
std::vector<sc_type> getEnd(sc_type type); std::vector<sc_type> getEnd(sc_type type);
uint16 getSkill(sc_type type); uint16 getSkill(sc_type type);
bool hasSCF(status_change *sc, e_status_change_flag flag); bool hasSCF(status_change *sc, e_status_change_flag flag);
void removeByStatusFlag(block_list *bl, std::vector<e_status_change_flag> flag); void removeByStatusFlag(block_list *bl, std::vector<e_status_change_flag> flag);
void changeSkillTree(map_session_data *sd, int32 class_ = 0); void changeSkillTree(map_session_data *sd, int32 class_ = 0);
bool validateStatus(sc_type type); bool validateStatus(sc_type type);
std::bitset<SCB_MAX> getSCB_BATTLE();
std::bitset<SCB_MAX> getSCB_ALL();
private:
std::bitset<SCB_MAX> SCB_BATTLE, SCB_ALL;
}; };
extern StatusDatabase status_db; extern StatusDatabase status_db;
@ -3220,17 +3226,17 @@ void status_change_clear_buffs(struct block_list* bl, uint8 type);
void status_change_clear_onChangeMap(struct block_list *bl, struct status_change *sc); void status_change_clear_onChangeMap(struct block_list *bl, struct status_change *sc);
#define status_calc_bl(bl, flag) status_calc_bl_(bl, flag, SCO_NONE) #define status_calc_bl(bl, flag) status_calc_bl_(bl, flag, SCO_NONE)
#define status_calc_mob(md, opt) status_calc_bl_(&(md)->bl, SCB_ALL, opt) #define status_calc_mob(md, opt) status_calc_bl_(&(md)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_pet(pd, opt) status_calc_bl_(&(pd)->bl, SCB_ALL, opt) #define status_calc_pet(pd, opt) status_calc_bl_(&(pd)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_pc(sd, opt) status_calc_bl_(&(sd)->bl, SCB_ALL, opt) #define status_calc_pc(sd, opt) status_calc_bl_(&(sd)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_homunculus(hd, opt) status_calc_bl_(&(hd)->bl, SCB_ALL, opt) #define status_calc_homunculus(hd, opt) status_calc_bl_(&(hd)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_mercenary(md, opt) status_calc_bl_(&(md)->bl, SCB_ALL, opt) #define status_calc_mercenary(md, opt) status_calc_bl_(&(md)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_elemental(ed, opt) status_calc_bl_(&(ed)->bl, SCB_ALL, opt) #define status_calc_elemental(ed, opt) status_calc_bl_(&(ed)->bl, status_db.getSCB_ALL(), opt)
#define status_calc_npc(nd, opt) status_calc_bl_(&(nd)->bl, SCB_ALL, opt) #define status_calc_npc(nd, opt) status_calc_bl_(&(nd)->bl, status_db.getSCB_ALL(), opt)
bool status_calc_weight(struct map_session_data *sd, enum e_status_calc_weight_opt flag); bool status_calc_weight(struct map_session_data *sd, enum e_status_calc_weight_opt flag);
bool status_calc_cart_weight(struct map_session_data *sd, enum e_status_calc_weight_opt flag); bool status_calc_cart_weight(struct map_session_data *sd, enum e_status_calc_weight_opt flag);
void status_calc_bl_(struct block_list *bl, uint64 flag, uint8 opt); void status_calc_bl_(struct block_list *bl, std::bitset<SCB_MAX> flag, uint8 opt);
int status_calc_mob_(struct mob_data* md, uint8 opt); int status_calc_mob_(struct mob_data* md, uint8 opt);
void status_calc_pet_(struct pet_data* pd, uint8 opt); void status_calc_pet_(struct pet_data* pd, uint8 opt);
int status_calc_pc_(struct map_session_data* sd, uint8 opt); int status_calc_pc_(struct map_session_data* sd, uint8 opt);