Revert "Status Change display in status window (#1481)"
This reverts commit a75133eb4d8976c1c890d5420665e7a76349e226.
This commit is contained in:
aleos89
parent
9ba2513ff4
commit
4bb6aa13a0
@ -172,10 +172,6 @@ min_npc_vendchat_distance: 3
|
||||
// Default is 25. 100 = 100% Increase.
|
||||
rental_mount_speed_boost: 25
|
||||
|
||||
// Display Katar critical bonus in the status window? (Note 1)
|
||||
// Default (official): no
|
||||
show_status_katar_crit: no
|
||||
|
||||
//===================================
|
||||
// VIP system
|
||||
//===================================
|
||||
|
||||
117
src/map/battle.c
117
src/map/battle.c
@ -15,7 +15,6 @@
|
||||
#include "map.h"
|
||||
#include "path.h"
|
||||
#include "pc.h"
|
||||
#include "status.h"
|
||||
#include "homunculus.h"
|
||||
#include "mercenary.h"
|
||||
#include "elemental.h"
|
||||
@ -2338,8 +2337,6 @@ static bool is_attack_critical(struct Damage wd, struct block_list *src, struct
|
||||
short cri = sstatus->cri;
|
||||
|
||||
if (sd) {
|
||||
if (!battle_config.show_status_katar_crit && sd->status.weapon == W_KATAR)
|
||||
cri <<= 1; // Double critical bonus from Katars aren't shown in the status display
|
||||
cri += sd->critaddrace[tstatus->race] + sd->critaddrace[RC_ALL];
|
||||
if(is_skill_using_arrow(src, skill_id)) {
|
||||
cri += sd->bonus.arrow_cri;
|
||||
@ -4537,15 +4534,15 @@ struct Damage battle_attack_sc_bonus(struct Damage wd, struct block_list *src, s
|
||||
return wd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates defense based on src and target
|
||||
* @param src: Source object
|
||||
* @param target: Target object
|
||||
* @param skill_id: Skill used
|
||||
* @param flag: 0 - Return armor defense, 1 - Return status defense
|
||||
* @return defense
|
||||
/*====================================
|
||||
* Calc defense damage reduction
|
||||
*------------------------------------
|
||||
* Credits:
|
||||
* Original coder Skotlex
|
||||
* Initial refactoring by Baalberith
|
||||
* Refined and optimized by helvetica
|
||||
*/
|
||||
static short battle_get_defense(struct block_list *src, struct block_list *target, uint16 skill_id, uint8 flag)
|
||||
struct Damage battle_calc_defense_reduction(struct Damage wd, struct block_list *src,struct block_list *target, uint16 skill_id, uint16 skill_lv)
|
||||
{
|
||||
struct map_session_data *sd = BL_CAST(BL_PC, src);
|
||||
struct map_session_data *tsd = BL_CAST(BL_PC, target);
|
||||
@ -4554,30 +4551,29 @@ static short battle_get_defense(struct block_list *src, struct block_list *targe
|
||||
struct status_data *sstatus = status_get_status_data(src);
|
||||
struct status_data *tstatus = status_get_status_data(target);
|
||||
|
||||
// Don't use tstatus->def1 due to skill timer reductions.
|
||||
defType def1 = status_get_def(target); // eDEF
|
||||
short def2 = tstatus->def2, vit_def; // sDEF
|
||||
//Defense reduction
|
||||
short vit_def;
|
||||
defType def1 = status_get_def(target); //Don't use tstatus->def1 due to skill timer reductions.
|
||||
short def2 = tstatus->def2;
|
||||
|
||||
def1 = status_calc_def(target, tsc, def1, false);
|
||||
def2 = status_calc_def2(target, tsc, def2, false);
|
||||
#ifdef RENEWAL
|
||||
if( tsc && tsc->data[SC_ASSUMPTIO] )
|
||||
def1 <<= 1; // only eDEF is doubled
|
||||
#endif
|
||||
|
||||
if (sd) {
|
||||
int i = sd->ignore_def_by_race[tstatus->race] + sd->ignore_def_by_race[RC_ALL];
|
||||
i += sd->ignore_def_by_class[tstatus->class_] + sd->ignore_def_by_class[CLASS_ALL];
|
||||
if (i) {
|
||||
i = min(i,100); //cap it to 100 for 0 def min
|
||||
def1 -= def1 * i / 100;
|
||||
def2 -= def2 * i / 100;
|
||||
}
|
||||
|
||||
//Kagerou/Oboro Earth Charm effect +10% eDEF
|
||||
if(sd->spiritcharm_type == CHARM_TYPE_LAND && sd->spiritcharm > 0) {
|
||||
short si = 10 * sd->spiritcharm;
|
||||
|
||||
def1 = def1 * (100 + si) / 100;
|
||||
}
|
||||
|
||||
i += sd->ignore_def_by_class[tstatus->class_] + sd->ignore_def_by_class[CLASS_ALL];
|
||||
if (i) {
|
||||
i = min(i, 100); //cap it to 100 for 0 def min
|
||||
def1 -= def1 * i / 100;
|
||||
#ifndef RENEWAL
|
||||
def2 -= def2 * i / 100;
|
||||
#endif
|
||||
def1 = (def1 * (100 + si)) / 100;
|
||||
}
|
||||
}
|
||||
|
||||
@ -4586,9 +4582,29 @@ static short battle_get_defense(struct block_list *src, struct block_list *targe
|
||||
|
||||
i = min(i,100); //cap it to 100 for 0 def min
|
||||
def1 = (def1*(100-i))/100;
|
||||
#ifndef RENEWAL
|
||||
def2 = (def2*(100-i))/100;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (tsc) {
|
||||
if (tsc->data[SC_FORCEOFVANGUARD]) {
|
||||
short i = 2 * tsc->data[SC_FORCEOFVANGUARD]->val1;
|
||||
|
||||
def1 = (def1 * (100 + i)) / 100;
|
||||
}
|
||||
|
||||
if( tsc->data[SC_CAMOUFLAGE] ){
|
||||
short i = 5 * tsc->data[SC_CAMOUFLAGE]->val3; //5% per second
|
||||
|
||||
i = min(i,100); //cap it to 100 for 0 def min
|
||||
def1 = (def1*(100-i))/100;
|
||||
def2 = (def2*(100-i))/100;
|
||||
}
|
||||
|
||||
if (tsc->data[SC_GT_REVITALIZE])
|
||||
def2 += tsc->data[SC_GT_REVITALIZE]->val4;
|
||||
|
||||
if (tsc->data[SC_OVERED_BOOST] && target->type == BL_PC)
|
||||
def1 = (def1 * tsc->data[SC_OVERED_BOOST]->val4) / 100;
|
||||
}
|
||||
|
||||
if( battle_config.vit_penalty_type && battle_config.vit_penalty_target&target->type ) {
|
||||
@ -4607,8 +4623,10 @@ static short battle_get_defense(struct block_list *src, struct block_list *targe
|
||||
def2 -= (target_count - (battle_config.vit_penalty_count - 1))*battle_config.vit_penalty_num;
|
||||
}
|
||||
}
|
||||
#ifndef RENEWAL
|
||||
if (skill_id == AM_ACIDTERROR)
|
||||
#ifdef RENEWAL
|
||||
def2 = 0; //Ignore only status defense. [FatalEror]
|
||||
#else
|
||||
def1 = 0; //Ignores only armor defense. [Skotlex]
|
||||
#endif
|
||||
if(def2 < 1)
|
||||
@ -4656,30 +4674,6 @@ static short battle_get_defense(struct block_list *src, struct block_list *targe
|
||||
def1 = 0;
|
||||
}
|
||||
|
||||
if (!flag)
|
||||
return (short)def1;
|
||||
else
|
||||
return vit_def;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate defense damage reduction
|
||||
* @param wd: Weapon data
|
||||
* @param src: Source object
|
||||
* @param target: Target object
|
||||
* @param skill_id: Skill used
|
||||
* @param skill_lv: Skill level used
|
||||
* @return weapon data
|
||||
* Credits:
|
||||
* Original coder Skotlex
|
||||
* Initial refactoring by Baalberith
|
||||
* Refined and optimized by helvetica
|
||||
*/
|
||||
struct Damage battle_calc_defense_reduction(struct Damage wd, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv)
|
||||
{
|
||||
short def1 = battle_get_defense(src, target, skill_id, 0);
|
||||
short vit_def = battle_get_defense(src, target, skill_id, 1);
|
||||
|
||||
#ifdef RENEWAL
|
||||
/**
|
||||
* RE DEF Reduction
|
||||
@ -6162,12 +6156,12 @@ struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list
|
||||
ad.damage -= (int64)ad.damage*i/100;
|
||||
|
||||
if(!flag.imdef){
|
||||
defType mdef = tstatus->mdef; // eMDEF
|
||||
short mdef2 = tstatus->mdef2; // sMDEF
|
||||
|
||||
mdef = status_calc_mdef(target, tsc, mdef, false);
|
||||
mdef2 = status_calc_mdef2(target, tsc, mdef2, false);
|
||||
|
||||
defType mdef = tstatus->mdef;
|
||||
int mdef2= tstatus->mdef2;
|
||||
#ifdef RENEWAL
|
||||
if(tsc && tsc->data[SC_ASSUMPTIO])
|
||||
mdef <<= 1; // only eMDEF is doubled
|
||||
#endif
|
||||
if(sd) {
|
||||
i = sd->ignore_mdef_by_race[tstatus->race] + sd->ignore_mdef_by_race[RC_ALL];
|
||||
i += sd->ignore_mdef_by_class[tstatus->class_] + sd->ignore_mdef_by_class[CLASS_ALL];
|
||||
@ -6176,7 +6170,7 @@ struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list
|
||||
{
|
||||
if (i > 100) i = 100;
|
||||
mdef -= mdef * i/100;
|
||||
mdef2-= mdef2* i/100;
|
||||
//mdef2-= mdef2* i/100;
|
||||
}
|
||||
}
|
||||
#ifdef RENEWAL
|
||||
@ -8396,7 +8390,6 @@ static const struct _battle_data {
|
||||
{ "exp_cost_inspiration", &battle_config.exp_cost_inspiration, 1, 0, 100, },
|
||||
{ "mvp_exp_reward_message", &battle_config.mvp_exp_reward_message, 0, 0, 1, },
|
||||
{ "can_damage_skill", &battle_config.can_damage_skill, 1, 0, BL_ALL, },
|
||||
{ "show_status_katar_crit", &battle_config.show_status_katar_crit, 0, 0, 1, },
|
||||
{ "atcommand_levelup_events", &battle_config.atcommand_levelup_events, 0, 0, 1, },
|
||||
{ "block_account_in_same_party", &battle_config.block_account_in_same_party, 1, 0, 1, },
|
||||
{ "tarotcard_equal_chance", &battle_config.tarotcard_equal_chance, 0, 0, 1, },
|
||||
|
||||
@ -611,7 +611,6 @@ extern struct Battle_Config
|
||||
int exp_cost_inspiration;
|
||||
int mvp_exp_reward_message;
|
||||
int can_damage_skill; //Which BL types can damage traps
|
||||
int show_status_katar_crit;
|
||||
int atcommand_levelup_events;
|
||||
int block_account_in_same_party;
|
||||
int tarotcard_equal_chance; //Official or equal chance for each card
|
||||
|
||||
318
src/map/status.c
318
src/map/status.c
@ -55,6 +55,43 @@ short current_equip_opt_index; /// Contains random option index of an equipped i
|
||||
|
||||
unsigned int SCDisabled[SC_MAX]; ///< List of disabled SC on map zones. [Cydh]
|
||||
|
||||
static unsigned short status_calc_str(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_agi(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_vit(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_int(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_dex(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_luk(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_batk(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_watk(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_matk(struct block_list *,struct status_change *,int);
|
||||
static signed short status_calc_hit(struct block_list *,struct status_change *,int);
|
||||
static signed short status_calc_critical(struct block_list *,struct status_change *,int);
|
||||
static signed short status_calc_flee(struct block_list *,struct status_change *,int);
|
||||
static signed short status_calc_flee2(struct block_list *,struct status_change *,int);
|
||||
static defType status_calc_def(struct block_list *bl, struct status_change *sc, int);
|
||||
static signed short status_calc_def2(struct block_list *,struct status_change *,int);
|
||||
static defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int);
|
||||
static signed short status_calc_mdef2(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_speed(struct block_list *,struct status_change *,int);
|
||||
static short status_calc_aspd_rate(struct block_list *,struct status_change *,int);
|
||||
static unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion);
|
||||
#ifdef RENEWAL_ASPD
|
||||
static short status_calc_aspd(struct block_list *bl, struct status_change *sc, bool fixed);
|
||||
#endif
|
||||
static short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int);
|
||||
static unsigned int status_calc_maxhp(struct block_list *bl, uint64 maxhp);
|
||||
static unsigned int status_calc_maxsp(struct block_list *bl, uint64 maxsp);
|
||||
static unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element);
|
||||
static unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv);
|
||||
static enum e_mode status_calc_mode(struct block_list *bl, struct status_change *sc, enum e_mode mode);
|
||||
#ifdef RENEWAL
|
||||
static unsigned short status_calc_ematk(struct block_list *,struct status_change *,int);
|
||||
#endif
|
||||
static int status_get_hpbonus(struct block_list *bl, enum e_status_bonus type);
|
||||
static int status_get_spbonus(struct block_list *bl, enum e_status_bonus type);
|
||||
static unsigned int status_calc_maxhpsp_pc(struct map_session_data* sd, unsigned int stat, bool isHP);
|
||||
static int status_get_sc_interval(enum sc_type type);
|
||||
|
||||
static bool status_change_isDisabledOnMap_(sc_type type, bool mapIsVS, bool mapIsPVP, bool mapIsGVG, bool mapIsBG, unsigned int mapZone, bool mapIsTE);
|
||||
#define status_change_isDisabledOnMap(type, m) ( status_change_isDisabledOnMap_((type), map_flag_vs2((m)), map[(m)].flag.pvp, map_flag_gvg2_no_te((m)), map[(m)].flag.battleground, map[(m)].zone << 3, map_flag_gvg2_te((m))) )
|
||||
|
||||
@ -369,11 +406,10 @@ void initChangeTables(void)
|
||||
set_sc( LK_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN );
|
||||
set_sc( HP_ASSUMPTIO , SC_ASSUMPTIO ,
|
||||
#ifndef RENEWAL
|
||||
SI_ASSUMPTIO ,
|
||||
SI_ASSUMPTIO , SCB_NONE );
|
||||
#else
|
||||
SI_ASSUMPTIO2 ,
|
||||
SI_ASSUMPTIO2 , SCB_NONE );
|
||||
#endif
|
||||
SCB_NONE );
|
||||
add_sc( HP_BASILICA , SC_BASILICA );
|
||||
set_sc( HW_MAGICPOWER , SC_MAGICPOWER , SI_MAGICPOWER , SCB_MATK );
|
||||
add_sc( PA_SACRIFICE , SC_SACRIFICE );
|
||||
@ -494,13 +530,7 @@ void initChangeTables(void)
|
||||
|
||||
set_sc( CASH_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX );
|
||||
set_sc( CASH_INCAGI , SC_INCREASEAGI , SI_INCREASEAGI , SCB_AGI|SCB_SPEED );
|
||||
set_sc( CASH_ASSUMPTIO , SC_ASSUMPTIO ,
|
||||
#ifndef RENEWAL
|
||||
SI_ASSUMPTIO ,
|
||||
#else
|
||||
SI_ASSUMPTIO2 ,
|
||||
#endif
|
||||
SCB_NONE );
|
||||
set_sc( CASH_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE );
|
||||
|
||||
set_sc( ALL_PARTYFLEE , SC_PARTYFLEE , SI_PARTYFLEE , SCB_NONE );
|
||||
set_sc( ALL_ODINS_POWER , SC_ODINS_POWER , SI_ODINS_POWER , SCB_WATK|SCB_MATK|SCB_MDEF|SCB_DEF );
|
||||
@ -1194,13 +1224,13 @@ void initChangeTables(void)
|
||||
StatusChangeFlagTable[SC_WEDDING] |= SCB_SPEED;
|
||||
StatusChangeFlagTable[SC_ALL_RIDING] |= SCB_SPEED;
|
||||
StatusChangeFlagTable[SC_PUSH_CART] |= SCB_SPEED;
|
||||
StatusChangeFlagTable[SC_MTF_ASPD] |= SCB_ASPD;
|
||||
StatusChangeFlagTable[SC_MTF_ASPD] |= SCB_ASPD|SCB_HIT;
|
||||
StatusChangeFlagTable[SC_MTF_MATK] |= SCB_MATK;
|
||||
StatusChangeFlagTable[SC_MTF_MLEATKED] |= SCB_ALL;
|
||||
StatusChangeFlagTable[SC_QUEST_BUFF1] |= SCB_BATK|SCB_MATK;
|
||||
StatusChangeFlagTable[SC_QUEST_BUFF2] |= SCB_BATK|SCB_MATK;
|
||||
StatusChangeFlagTable[SC_QUEST_BUFF3] |= SCB_BATK|SCB_MATK;
|
||||
StatusChangeFlagTable[SC_MTF_ASPD2] |= SCB_ASPD;
|
||||
StatusChangeFlagTable[SC_MTF_ASPD2] |= SCB_ASPD|SCB_HIT;
|
||||
StatusChangeFlagTable[SC_MTF_MATK2] |= SCB_MATK;
|
||||
StatusChangeFlagTable[SC_2011RWC_SCROLL] |= SCB_BATK|SCB_MATK|SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK;
|
||||
StatusChangeFlagTable[SC_MTF_HITFLEE] |= SCB_HIT|SCB_FLEE;
|
||||
@ -2851,7 +2881,7 @@ void status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt)
|
||||
* @return bonus: total bonus for HP
|
||||
* @author [Cydh]
|
||||
*/
|
||||
int status_get_hpbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
static int status_get_hpbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
int bonus = 0;
|
||||
|
||||
if (type == STATUS_BONUS_FIX) {
|
||||
@ -2983,7 +3013,7 @@ int status_get_hpbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
* @return bonus: total bonus for SP
|
||||
* @author [Cydh]
|
||||
*/
|
||||
int status_get_spbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
static int status_get_spbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
int bonus = 0;
|
||||
|
||||
if (type == STATUS_BONUS_FIX) {
|
||||
@ -3076,7 +3106,7 @@ int status_get_spbonus(struct block_list *bl, enum e_status_bonus type) {
|
||||
* @param isHP true - calculates Max HP, false - calculated Max SP
|
||||
* @return max The max value of HP or SP
|
||||
*/
|
||||
unsigned int status_calc_maxhpsp_pc(struct map_session_data* sd, unsigned int stat, bool isHP) {
|
||||
static unsigned int status_calc_maxhpsp_pc(struct map_session_data* sd, unsigned int stat, bool isHP) {
|
||||
double dmax = 0;
|
||||
uint16 idx, level, job_id;
|
||||
|
||||
@ -4696,33 +4726,33 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
temp += status->batk;
|
||||
status->batk = cap_value(temp, 0, USHRT_MAX);
|
||||
}
|
||||
status->batk = status_calc_batk(bl, sc, status->batk, true);
|
||||
status->batk = status_calc_batk(bl, sc, status->batk);
|
||||
}
|
||||
|
||||
if(flag&SCB_WATK) {
|
||||
#ifndef RENEWAL
|
||||
status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk, true);
|
||||
status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk);
|
||||
if (!sd) // Should not affect weapon refine bonus
|
||||
status->rhw.atk2 = status_calc_watk(bl, sc, b_status->rhw.atk2, true);
|
||||
status->rhw.atk2 = status_calc_watk(bl, sc, b_status->rhw.atk2);
|
||||
|
||||
if (sd && sd->bonus.weapon_atk_rate)
|
||||
status->rhw.atk += status->rhw.atk * sd->bonus.weapon_atk_rate / 100;
|
||||
if(b_status->lhw.atk) {
|
||||
if (sd) {
|
||||
sd->state.lr_flag = 1;
|
||||
status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk, true);
|
||||
status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
|
||||
sd->state.lr_flag = 0;
|
||||
} else {
|
||||
status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk, true);
|
||||
status->lhw.atk2= status_calc_watk(bl, sc, b_status->lhw.atk2, true);
|
||||
status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
|
||||
status->lhw.atk2= status_calc_watk(bl, sc, b_status->lhw.atk2);
|
||||
}
|
||||
}
|
||||
#else
|
||||
if(!b_status->watk) { // We only have left-hand weapon
|
||||
status->watk = 0;
|
||||
status->watk2 = status_calc_watk(bl, sc, b_status->watk2, false);
|
||||
} else
|
||||
status->watk = status_calc_watk(bl, sc, b_status->watk, false);
|
||||
status->watk2 = status_calc_watk(bl, sc, b_status->watk2);
|
||||
}
|
||||
else status->watk = status_calc_watk(bl, sc, b_status->watk);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -4732,13 +4762,13 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
&& status->luk == b_status->luk
|
||||
#endif
|
||||
)
|
||||
status->hit = status_calc_hit(bl, sc, b_status->hit, true);
|
||||
status->hit = status_calc_hit(bl, sc, b_status->hit);
|
||||
else
|
||||
status->hit = status_calc_hit(bl, sc, b_status->hit + (status->dex - b_status->dex)
|
||||
#ifdef RENEWAL
|
||||
+ (status->luk/3 - b_status->luk/3)
|
||||
#endif
|
||||
, true);
|
||||
);
|
||||
}
|
||||
|
||||
if(flag&SCB_FLEE) {
|
||||
@ -4747,17 +4777,17 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
&& status->luk == b_status->luk
|
||||
#endif
|
||||
)
|
||||
status->flee = status_calc_flee(bl, sc, b_status->flee, true);
|
||||
status->flee = status_calc_flee(bl, sc, b_status->flee);
|
||||
else
|
||||
status->flee = status_calc_flee(bl, sc, b_status->flee +(status->agi - b_status->agi)
|
||||
#ifdef RENEWAL
|
||||
+ (status->luk/5 - b_status->luk/5)
|
||||
#endif
|
||||
, true);
|
||||
);
|
||||
}
|
||||
|
||||
if(flag&SCB_DEF) {
|
||||
status->def = status_calc_def(bl, sc, b_status->def, true);
|
||||
status->def = status_calc_def(bl, sc, b_status->def);
|
||||
|
||||
if( bl->type&BL_HOM )
|
||||
status->def += (status->vit/5 - b_status->vit/5);
|
||||
@ -4769,7 +4799,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
&& status->agi == b_status->agi
|
||||
#endif
|
||||
)
|
||||
status->def2 = status_calc_def2(bl, sc, b_status->def2, true);
|
||||
status->def2 = status_calc_def2(bl, sc, b_status->def2);
|
||||
else
|
||||
status->def2 = status_calc_def2(bl, sc, b_status->def2
|
||||
#ifdef RENEWAL
|
||||
@ -4777,11 +4807,11 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
#else
|
||||
+ (status->vit - b_status->vit)
|
||||
#endif
|
||||
, true);
|
||||
);
|
||||
}
|
||||
|
||||
if(flag&SCB_MDEF) {
|
||||
status->mdef = status_calc_mdef(bl, sc, b_status->mdef, true);
|
||||
status->mdef = status_calc_mdef(bl, sc, b_status->mdef);
|
||||
|
||||
if( bl->type&BL_HOM )
|
||||
status->mdef += (status->int_/5 - b_status->int_/5);
|
||||
@ -4793,7 +4823,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
&& status->dex == b_status->dex
|
||||
#endif
|
||||
)
|
||||
status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2, true);
|
||||
status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2);
|
||||
else
|
||||
status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2 +(status->int_ - b_status->int_)
|
||||
#ifdef RENEWAL
|
||||
@ -4801,7 +4831,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
#else
|
||||
+ ((status->vit - b_status->vit)>>1)
|
||||
#endif
|
||||
, true);
|
||||
);
|
||||
}
|
||||
|
||||
if(flag&SCB_SPEED) {
|
||||
@ -4820,20 +4850,20 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
|
||||
if(flag&SCB_CRI && b_status->cri) {
|
||||
if (status->luk == b_status->luk)
|
||||
status->cri = status_calc_critical(bl, sc, b_status->cri, true);
|
||||
status->cri = status_calc_critical(bl, sc, b_status->cri);
|
||||
else
|
||||
status->cri = status_calc_critical(bl, sc, b_status->cri + 3*(status->luk - b_status->luk), true);
|
||||
status->cri = status_calc_critical(bl, sc, b_status->cri + 3*(status->luk - b_status->luk));
|
||||
|
||||
/// After status_calc_critical so the bonus is applied despite if you have or not a sc bugreport:5240
|
||||
if (battle_config.show_status_katar_crit && bl->type == BL_PC && ((TBL_PC*)bl)->status.weapon == W_KATAR)
|
||||
if( bl->type == BL_PC && ((TBL_PC*)bl)->status.weapon == W_KATAR )
|
||||
status->cri <<= 1;
|
||||
}
|
||||
|
||||
if(flag&SCB_FLEE2 && b_status->flee2) {
|
||||
if (status->luk == b_status->luk)
|
||||
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2, true);
|
||||
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2);
|
||||
else
|
||||
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk), true);
|
||||
status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk));
|
||||
}
|
||||
|
||||
if(flag&SCB_ATK_ELE) {
|
||||
@ -4984,8 +5014,8 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
|
||||
}
|
||||
#endif
|
||||
|
||||
status->matk_max = status_calc_matk(bl, sc, status->matk_max, true);
|
||||
status->matk_min = status_calc_matk(bl, sc, status->matk_min, true);
|
||||
status->matk_max = status_calc_matk(bl, sc, status->matk_max);
|
||||
status->matk_min = status_calc_matk(bl, sc, status->matk_min);
|
||||
}
|
||||
|
||||
if(flag&SCB_ASPD) {
|
||||
@ -5273,7 +5303,7 @@ void status_calc_bl_(struct block_list* bl, enum scb_flag flag, enum e_status_ca
|
||||
* @param str: Initial str
|
||||
* @return modified str with cap_value(str,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_str(struct block_list *bl, struct status_change *sc, int str)
|
||||
static unsigned short status_calc_str(struct block_list *bl, struct status_change *sc, int str)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(str,0,USHRT_MAX);
|
||||
@ -5347,7 +5377,7 @@ unsigned short status_calc_str(struct block_list *bl, struct status_change *sc,
|
||||
* @param agi: Initial agi
|
||||
* @return modified agi with cap_value(agi,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_agi(struct block_list *bl, struct status_change *sc, int agi)
|
||||
static unsigned short status_calc_agi(struct block_list *bl, struct status_change *sc, int agi)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(agi,0,USHRT_MAX);
|
||||
@ -5419,7 +5449,7 @@ unsigned short status_calc_agi(struct block_list *bl, struct status_change *sc,
|
||||
* @param vit: Initial vit
|
||||
* @return modified vit with cap_value(vit,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_vit(struct block_list *bl, struct status_change *sc, int vit)
|
||||
static unsigned short status_calc_vit(struct block_list *bl, struct status_change *sc, int vit)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(vit,0,USHRT_MAX);
|
||||
@ -5483,7 +5513,7 @@ unsigned short status_calc_vit(struct block_list *bl, struct status_change *sc,
|
||||
* @param int_: Initial int
|
||||
* @return modified int with cap_value(int_,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_int(struct block_list *bl, struct status_change *sc, int int_)
|
||||
static unsigned short status_calc_int(struct block_list *bl, struct status_change *sc, int int_)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(int_,0,USHRT_MAX);
|
||||
@ -5560,7 +5590,7 @@ unsigned short status_calc_int(struct block_list *bl, struct status_change *sc,
|
||||
* @param dex: Initial dex
|
||||
* @return modified dex with cap_value(dex,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_dex(struct block_list *bl, struct status_change *sc, int dex)
|
||||
static unsigned short status_calc_dex(struct block_list *bl, struct status_change *sc, int dex)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(dex,0,USHRT_MAX);
|
||||
@ -5634,7 +5664,7 @@ unsigned short status_calc_dex(struct block_list *bl, struct status_change *sc,
|
||||
* @param luk: Initial luk
|
||||
* @return modified luk with cap_value(luk,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_luk(struct block_list *bl, struct status_change *sc, int luk)
|
||||
static unsigned short status_calc_luk(struct block_list *bl, struct status_change *sc, int luk)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(luk,0,USHRT_MAX);
|
||||
@ -5694,20 +5724,15 @@ unsigned short status_calc_luk(struct block_list *bl, struct status_change *sc,
|
||||
* @param bl: Object to change batk [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param batk: Initial batk
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified batk with cap_value(batk,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_batk(struct block_list *bl, struct status_change *sc, int batk, bool display)
|
||||
static unsigned short status_calc_batk(struct block_list *bl, struct status_change *sc, int batk)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(batk,0,USHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if(sc->data[SC_ATKPOTION])
|
||||
batk += sc->data[SC_ATKPOTION]->val1;
|
||||
return (unsigned short)cap_value(batk,0,USHRT_MAX);
|
||||
}
|
||||
|
||||
if(sc->data[SC_ATKPOTION])
|
||||
batk += sc->data[SC_ATKPOTION]->val1;
|
||||
if(sc->data[SC_BATKFOOD])
|
||||
batk += sc->data[SC_BATKFOOD]->val1;
|
||||
#ifndef RENEWAL
|
||||
@ -5779,21 +5804,12 @@ unsigned short status_calc_batk(struct block_list *bl, struct status_change *sc,
|
||||
* @param bl: Object to change watk [PC]
|
||||
* @param sc: Object's status change information
|
||||
* @param watk: Initial watk
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified watk with cap_value(watk,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc, int watk, bool display)
|
||||
static unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc, int watk)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (unsigned short)cap_value(watk,0,USHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if(sc->data[SC_WATER_BARRIER])
|
||||
watk -= sc->data[SC_WATER_BARRIER]->val2;
|
||||
if(sc->data[SC_GT_CHANGE])
|
||||
watk += sc->data[SC_GT_CHANGE]->val2;
|
||||
return (unsigned short)cap_value(watk,0,USHRT_MAX);
|
||||
}
|
||||
return cap_value(watk,0,USHRT_MAX);
|
||||
|
||||
#ifndef RENEWAL
|
||||
if(sc->data[SC_IMPOSITIO])
|
||||
@ -5807,6 +5823,8 @@ unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc,
|
||||
watk += sc->data[SC_VOLCANO]->val2;
|
||||
if(sc->data[SC_MERC_ATKUP])
|
||||
watk += sc->data[SC_MERC_ATKUP]->val2;
|
||||
if(sc->data[SC_WATER_BARRIER])
|
||||
watk -= sc->data[SC_WATER_BARRIER]->val2;
|
||||
#ifndef RENEWAL
|
||||
if(sc->data[SC_NIBELUNGEN]) {
|
||||
if (bl->type != BL_PC)
|
||||
@ -5842,6 +5860,8 @@ unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc,
|
||||
watk += (10 + 10 * sc->data[SC_BANDING]->val1) * sc->data[SC_BANDING]->val2;
|
||||
if(sc->data[SC_INSPIRATION])
|
||||
watk += 40 * sc->data[SC_INSPIRATION]->val1 + 3 * sc->data[SC_INSPIRATION]->val2;
|
||||
if(sc->data[SC_GT_CHANGE])
|
||||
watk += sc->data[SC_GT_CHANGE]->val2;
|
||||
if(sc->data[SC__ENERVATION])
|
||||
watk -= watk * sc->data[SC__ENERVATION]->val2 / 100;
|
||||
if(sc->data[SC_STRIKING])
|
||||
@ -5883,10 +5903,10 @@ unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc,
|
||||
* @param matk: Initial matk
|
||||
* @return modified matk with cap_value(matk,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_ematk(struct block_list *bl, struct status_change *sc, int matk)
|
||||
static unsigned short status_calc_ematk(struct block_list *bl, struct status_change *sc, int matk)
|
||||
{
|
||||
if (!sc || !sc->count)
|
||||
return (unsigned short)cap_value(matk,0,USHRT_MAX);
|
||||
return cap_value(matk,0,USHRT_MAX);
|
||||
|
||||
if (sc->data[SC_MATKPOTION])
|
||||
matk += sc->data[SC_MATKPOTION]->val1;
|
||||
@ -5930,20 +5950,12 @@ unsigned short status_calc_ematk(struct block_list *bl, struct status_change *sc
|
||||
* @param bl: Object to change matk [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param matk: Initial matk
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified matk with cap_value(matk,0,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc, int matk, bool display)
|
||||
static unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc, int matk)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (unsigned short)cap_value(matk,0,USHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if(sc->data[SC_MINDBREAKER])
|
||||
matk += matk * sc->data[SC_MINDBREAKER]->val2 / 100;
|
||||
return (unsigned short)cap_value(matk,0,USHRT_MAX);
|
||||
}
|
||||
|
||||
return cap_value(matk,0,USHRT_MAX);
|
||||
#ifndef RENEWAL
|
||||
/// Take note fixed value first before % modifiers [PRE-RENEWAL]
|
||||
if (sc->data[SC_MATKPOTION])
|
||||
@ -5979,6 +5991,8 @@ unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc,
|
||||
matk += sc->data[SC_QUEST_BUFF3]->val1;
|
||||
if (sc->data[SC_MAGICPOWER] && sc->data[SC_MAGICPOWER]->val4)
|
||||
matk += matk * sc->data[SC_MAGICPOWER]->val3/100;
|
||||
if (sc->data[SC_MINDBREAKER])
|
||||
matk += matk * sc->data[SC_MINDBREAKER]->val2/100;
|
||||
if (sc->data[SC_INCMATKRATE])
|
||||
matk += matk * sc->data[SC_INCMATKRATE]->val1/100;
|
||||
if (sc->data[SC_MOONLITSERENADE])
|
||||
@ -5998,23 +6012,15 @@ unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc,
|
||||
* @param bl: Object to change critical [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param critical: Initial critical
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified critical with cap_value(critical,10,USHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_critical(struct block_list *bl, struct status_change *sc, int critical, bool display)
|
||||
static signed short status_calc_critical(struct block_list *bl, struct status_change *sc, int critical)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (short)cap_value(critical,10,SHRT_MAX);
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if (sc->data[SC_INCCRI]) {
|
||||
if (bl->type == BL_PC && ((TBL_PC*)bl)->status.weapon == W_KATAR) // Gives double critical rate when using Katar weapons [Limestone]
|
||||
critical += sc->data[SC_INCCRI]->val2 * 2;
|
||||
else
|
||||
critical += sc->data[SC_INCCRI]->val2;
|
||||
}
|
||||
return (short)cap_value(critical,10,SHRT_MAX);
|
||||
}
|
||||
return cap_value(critical,10,SHRT_MAX);
|
||||
|
||||
if (sc->data[SC_INCCRI])
|
||||
critical += sc->data[SC_INCCRI]->val2;
|
||||
if (sc->data[SC_CRIFOOD])
|
||||
critical += sc->data[SC_CRIFOOD]->val1;
|
||||
if (sc->data[SC_EXPLOSIONSPIRITS])
|
||||
@ -6046,17 +6052,12 @@ signed short status_calc_critical(struct block_list *bl, struct status_change *s
|
||||
* @param bl: Object to change hit [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param hit: Initial hit
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified hit with cap_value(hit,1,USHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_hit(struct block_list *bl, struct status_change *sc, int hit, bool display)
|
||||
static signed short status_calc_hit(struct block_list *bl, struct status_change *sc, int hit)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (short)cap_value(hit,1,SHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
return (short)cap_value(hit,1,SHRT_MAX);
|
||||
}
|
||||
return cap_value(hit,1,SHRT_MAX);
|
||||
|
||||
if(sc->data[SC_INCHIT])
|
||||
hit += sc->data[SC_INCHIT]->val1;
|
||||
@ -6092,6 +6093,8 @@ signed short status_calc_hit(struct block_list *bl, struct status_change *sc, in
|
||||
hit -= hit * 50 / 100;
|
||||
if(sc->data[SC_ILLUSIONDOPING])
|
||||
hit -= sc->data[SC_ILLUSIONDOPING]->val2;
|
||||
if (sc->data[SC_MTF_ASPD])
|
||||
hit += sc->data[SC_MTF_ASPD]->val2;
|
||||
|
||||
return (short)cap_value(hit,1,SHRT_MAX);
|
||||
}
|
||||
@ -6101,10 +6104,9 @@ signed short status_calc_hit(struct block_list *bl, struct status_change *sc, in
|
||||
* @param bl: Object to change flee [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param flee: Initial flee
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified flee with cap_value(flee,1,USHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_flee(struct block_list *bl, struct status_change *sc, int flee, bool display)
|
||||
static signed short status_calc_flee(struct block_list *bl, struct status_change *sc, int flee)
|
||||
{
|
||||
if( bl->type == BL_PC ) {
|
||||
if( map_flag_gvg(bl->m) )
|
||||
@ -6114,12 +6116,7 @@ signed short status_calc_flee(struct block_list *bl, struct status_change *sc, i
|
||||
}
|
||||
|
||||
if(!sc || !sc->count)
|
||||
return (short)cap_value(flee,1,SHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
return (short)cap_value(flee,1,SHRT_MAX);
|
||||
}
|
||||
|
||||
return cap_value(flee,1,SHRT_MAX);
|
||||
if(sc->data[SC_OVERED_BOOST]) //Should be final and unmodifiable by any means
|
||||
return sc->data[SC_OVERED_BOOST]->val2;
|
||||
if(sc->data[SC_TINDER_BREAKER] || sc->data[SC_TINDER_BREAKER2])
|
||||
@ -6211,17 +6208,12 @@ signed short status_calc_flee(struct block_list *bl, struct status_change *sc, i
|
||||
* @param bl: Object to change flee2 [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param flee2: Initial flee2
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified flee2 with cap_value(flee2,10,USHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2, bool display)
|
||||
static signed short status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (short)cap_value(flee2,10,SHRT_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
return (short)cap_value(flee2,10,SHRT_MAX);
|
||||
}
|
||||
return cap_value(flee2,10,SHRT_MAX);
|
||||
|
||||
if(sc->data[SC_INCFLEE2])
|
||||
flee2 += sc->data[SC_INCFLEE2]->val2;
|
||||
@ -6238,30 +6230,13 @@ signed short status_calc_flee2(struct block_list *bl, struct status_change *sc,
|
||||
* @param bl: Object to change def [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param def: Initial def
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified def with cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX)
|
||||
*/
|
||||
defType status_calc_def(struct block_list *bl, struct status_change *sc, int def, bool display)
|
||||
static defType status_calc_def(struct block_list *bl, struct status_change *sc, int def)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
#ifdef RENEWAL
|
||||
if(sc->data[SC_ASSUMPTIO])
|
||||
def <<= 1; // only eDEF is doubled
|
||||
#endif
|
||||
if(sc->data[SC_NEUTRALBARRIER])
|
||||
def += def * sc->data[SC_NEUTRALBARRIER]->val2 / 100;
|
||||
if(sc->data[SC_FORCEOFVANGUARD])
|
||||
def += def * 2 * sc->data[SC_FORCEOFVANGUARD]->val1 / 100;
|
||||
if(sc->data[SC_CAMOUFLAGE])
|
||||
def -= def * 5 * sc->data[SC_CAMOUFLAGE]->val3 / 100;
|
||||
if(sc->data[SC_OVERED_BOOST] && bl->type == BL_PC)
|
||||
def -= def * sc->data[SC_OVERED_BOOST]->val4 / 100;
|
||||
return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);
|
||||
}
|
||||
|
||||
if(sc->data[SC_BERSERK])
|
||||
return 0;
|
||||
if(sc->data[SC_BARRIER])
|
||||
@ -6311,6 +6286,8 @@ defType status_calc_def(struct block_list *bl, struct status_change *sc, int def
|
||||
def -= def * 10 / 100;
|
||||
if( sc->data[SC_ANALYZE] )
|
||||
def -= def * (14 * sc->data[SC_ANALYZE]->val1) / 100;
|
||||
if( sc->data[SC_NEUTRALBARRIER] )
|
||||
def += def * sc->data[SC_NEUTRALBARRIER]->val2 / 100;
|
||||
if( sc->data[SC_SHIELDSPELL_REF] && sc->data[SC_SHIELDSPELL_REF]->val1 == 2 )
|
||||
def += sc->data[SC_SHIELDSPELL_REF]->val2;
|
||||
if( sc->data[SC_PRESTIGE] )
|
||||
@ -6323,6 +6300,8 @@ defType status_calc_def(struct block_list *bl, struct status_change *sc, int def
|
||||
def -= def * (10 + 10 * sc->data[SC_SATURDAYNIGHTFEVER]->val1) / 100;
|
||||
if( sc->data[SC_EARTHDRIVE] )
|
||||
def -= def * 25 / 100;
|
||||
if( sc->data[SC_CAMOUFLAGE] )
|
||||
def -= def * 5 * sc->data[SC_CAMOUFLAGE]->val3 / 100;
|
||||
if( sc->data[SC_SOLID_SKIN_OPTION] )
|
||||
def += def * sc->data[SC_SOLID_SKIN_OPTION]->val2 / 100;
|
||||
if( sc->data[SC_ROCK_CRUSHER] )
|
||||
@ -6331,8 +6310,10 @@ defType status_calc_def(struct block_list *bl, struct status_change *sc, int def
|
||||
def += def * sc->data[SC_POWER_OF_GAIA]->val2 / 100;
|
||||
if(sc->data[SC_ASH])
|
||||
def -= def * sc->data[SC_ASH]->val3/100;
|
||||
if( sc->data[SC_OVERED_BOOST] && bl->type == BL_HOM )
|
||||
def -= def * sc->data[SC_OVERED_BOOST]->val4 / 100;
|
||||
|
||||
return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);
|
||||
return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -6340,30 +6321,16 @@ defType status_calc_def(struct block_list *bl, struct status_change *sc, int def
|
||||
* @param bl: Object to change def2 [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param def2: Initial def2
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified def2 with cap_value(def2,SHRT_MIN,SHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_def2(struct block_list *bl, struct status_change *sc, int def2, bool display)
|
||||
static signed short status_calc_def2(struct block_list *bl, struct status_change *sc, int def2)
|
||||
{
|
||||
if(!sc || !sc->count) {
|
||||
if(!sc || !sc->count)
|
||||
#ifdef RENEWAL
|
||||
return (short)cap_value(def2,SHRT_MIN,SHRT_MAX);
|
||||
#else
|
||||
return (short)cap_value(def2,1,SHRT_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if(sc->data[SC_CAMOUFLAGE])
|
||||
def2 -= def2 * 5 * sc->data[SC_CAMOUFLAGE]->val3 / 100;
|
||||
if(sc->data[SC_GT_REVITALIZE])
|
||||
def2 += sc->data[SC_GT_REVITALIZE]->val4;
|
||||
#ifdef RENEWAL
|
||||
return (short)cap_value(def2,SHRT_MIN,SHRT_MAX);
|
||||
#else
|
||||
return (short)cap_value(def2,1,SHRT_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
if(sc->data[SC_BERSERK])
|
||||
return 0;
|
||||
@ -6411,6 +6378,8 @@ signed short status_calc_def2(struct block_list *bl, struct status_change *sc, i
|
||||
def2 -= def2 * sc->data[SC_PARALYSIS]->val2 / 100;
|
||||
if(sc->data[SC_EQC])
|
||||
def2 -= def2 * sc->data[SC_EQC]->val2 / 100;
|
||||
if( sc->data[SC_CAMOUFLAGE] )
|
||||
def2 -= def2 * 5 * sc->data[SC_CAMOUFLAGE]->val3 / 100;
|
||||
|
||||
#ifdef RENEWAL
|
||||
return (short)cap_value(def2,SHRT_MIN,SHRT_MAX);
|
||||
@ -6424,24 +6393,13 @@ signed short status_calc_def2(struct block_list *bl, struct status_change *sc, i
|
||||
* @param bl: Object to change mdef [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param mdef: Initial mdef
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified mdef with cap_value(mdef,DEFTYPE_MIN,DEFTYPE_MAX)
|
||||
*/
|
||||
defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef, bool display)
|
||||
static defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return (defType)cap_value(mdef,DEFTYPE_MIN,DEFTYPE_MAX);
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
#ifdef RENEWAL
|
||||
if(sc->data[SC_ASSUMPTIO])
|
||||
mdef <<= 1; // only eMDEF is doubled
|
||||
#endif
|
||||
if(sc->data[SC_NEUTRALBARRIER])
|
||||
mdef += mdef * sc->data[SC_NEUTRALBARRIER]->val2 / 100;
|
||||
return (defType)cap_value(mdef,DEFTYPE_MIN,DEFTYPE_MAX);
|
||||
}
|
||||
|
||||
if(sc->data[SC_BERSERK])
|
||||
return 0;
|
||||
if(sc->data[SC_BARRIER])
|
||||
@ -6466,6 +6424,8 @@ defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int md
|
||||
mdef += 25 * mdef / 100;
|
||||
if(sc->data[SC_BURNING])
|
||||
mdef -= 25 * mdef / 100;
|
||||
if( sc->data[SC_NEUTRALBARRIER] )
|
||||
mdef += mdef * sc->data[SC_NEUTRALBARRIER]->val2 / 100;
|
||||
if(sc->data[SC_ANALYZE])
|
||||
mdef -= mdef * ( 14 * sc->data[SC_ANALYZE]->val1 ) / 100;
|
||||
if(sc->data[SC_SYMPHONYOFLOVER])
|
||||
@ -6486,28 +6446,16 @@ defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int md
|
||||
* @param bl: Object to change mdef2 [PC|MOB|HOM|MER|ELEM]
|
||||
* @param sc: Object's status change information
|
||||
* @param mdef2: Initial mdef2
|
||||
* @param display: If the status change is displayed in the status window
|
||||
* @return modified mdef2 with cap_value(mdef2,SHRT_MIN,SHRT_MAX)
|
||||
*/
|
||||
signed short status_calc_mdef2(struct block_list *bl, struct status_change *sc, int mdef2, bool display)
|
||||
static signed short status_calc_mdef2(struct block_list *bl, struct status_change *sc, int mdef2)
|
||||
{
|
||||
if(!sc || !sc->count) {
|
||||
if(!sc || !sc->count)
|
||||
#ifdef RENEWAL
|
||||
return (short)cap_value(mdef2,SHRT_MIN,SHRT_MAX);
|
||||
#else
|
||||
return (short)cap_value(mdef2,1,SHRT_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
if(!display) { // Status Changes that are hidden in the status window.
|
||||
if(sc->data[SC_MINDBREAKER])
|
||||
mdef2 -= mdef2 * sc->data[SC_MINDBREAKER]->val3 / 100;
|
||||
#ifdef RENEWAL
|
||||
return (short)cap_value(mdef2,SHRT_MIN,SHRT_MAX);
|
||||
#else
|
||||
return (short)cap_value(mdef2,1,SHRT_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
if(sc->data[SC_BERSERK])
|
||||
return 0;
|
||||
@ -6516,6 +6464,8 @@ signed short status_calc_mdef2(struct block_list *bl, struct status_change *sc,
|
||||
if(sc->data[SC_MDEFSET])
|
||||
return sc->data[SC_MDEFSET]->val1;
|
||||
|
||||
if(sc->data[SC_MINDBREAKER])
|
||||
mdef2 -= mdef2 * sc->data[SC_MINDBREAKER]->val3/100;
|
||||
if(sc->data[SC_BURNING])
|
||||
mdef2 -= mdef2 * 25 / 100;
|
||||
if(sc->data[SC_ANALYZE])
|
||||
@ -6535,7 +6485,7 @@ signed short status_calc_mdef2(struct block_list *bl, struct status_change *sc,
|
||||
* @param speed: Initial speed
|
||||
* @return modified speed with cap_value(speed,10,USHRT_MAX)
|
||||
*/
|
||||
unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc, int speed)
|
||||
static unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc, int speed)
|
||||
{
|
||||
TBL_PC* sd = BL_CAST(BL_PC, bl);
|
||||
int speed_rate = 100;
|
||||
@ -6720,7 +6670,7 @@ unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc
|
||||
* False - percentage value
|
||||
* @return modified aspd
|
||||
*/
|
||||
short status_calc_aspd(struct block_list *bl, struct status_change *sc, bool fixed)
|
||||
static short status_calc_aspd(struct block_list *bl, struct status_change *sc, bool fixed)
|
||||
{
|
||||
int bonus = 0;
|
||||
|
||||
@ -6843,7 +6793,7 @@ short status_calc_aspd(struct block_list *bl, struct status_change *sc, bool fix
|
||||
* @param aspd: Object's current ASPD
|
||||
* @return modified aspd
|
||||
*/
|
||||
short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd)
|
||||
static short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd)
|
||||
{
|
||||
if (!sc || !sc->count)
|
||||
return cap_value(aspd, 0, 2000);
|
||||
@ -6871,7 +6821,7 @@ short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int
|
||||
* @param aspd_rate: Object's current ASPD
|
||||
* @return modified aspd_rate
|
||||
*/
|
||||
short status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate)
|
||||
static short status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate)
|
||||
{
|
||||
int i;
|
||||
|
||||
@ -7016,7 +6966,7 @@ short status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int
|
||||
* @param dmotion: Object's current damage delay
|
||||
* @return modified delay rate
|
||||
*/
|
||||
unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion)
|
||||
static unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion)
|
||||
{
|
||||
if( !sc || !sc->count || map_flag_gvg(bl->m) || map[bl->m].flag.battleground )
|
||||
return cap_value(dmotion,0,USHRT_MAX);
|
||||
@ -7037,7 +6987,7 @@ unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *
|
||||
* @param maxhp: Object's current max HP
|
||||
* @return modified maxhp
|
||||
*/
|
||||
unsigned int status_calc_maxhp(struct block_list *bl, uint64 maxhp)
|
||||
static unsigned int status_calc_maxhp(struct block_list *bl, uint64 maxhp)
|
||||
{
|
||||
int rate = 100;
|
||||
|
||||
@ -7056,7 +7006,7 @@ unsigned int status_calc_maxhp(struct block_list *bl, uint64 maxhp)
|
||||
* @param maxsp: Object's current max SP
|
||||
* @return modified maxsp
|
||||
*/
|
||||
unsigned int status_calc_maxsp(struct block_list *bl, uint64 maxsp)
|
||||
static unsigned int status_calc_maxsp(struct block_list *bl, uint64 maxsp)
|
||||
{
|
||||
int rate = 100;
|
||||
|
||||
@ -7075,7 +7025,7 @@ unsigned int status_calc_maxsp(struct block_list *bl, uint64 maxsp)
|
||||
* @param element: Object's current element
|
||||
* @return new element
|
||||
*/
|
||||
unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element)
|
||||
static unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(element, 0, UCHAR_MAX);
|
||||
@ -7103,7 +7053,7 @@ unsigned char status_calc_element(struct block_list *bl, struct status_change *s
|
||||
* @param lv: Object's current element level
|
||||
* @return new element level
|
||||
*/
|
||||
unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv)
|
||||
static unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(lv, 1, 4);
|
||||
@ -7173,7 +7123,7 @@ unsigned char status_calc_attack_element(struct block_list *bl, struct status_ch
|
||||
* @param mode: Original mode
|
||||
* @return mode with cap_value(mode, 0, INT_MAX)
|
||||
*/
|
||||
enum e_mode status_calc_mode(struct block_list *bl, struct status_change *sc, enum e_mode mode)
|
||||
static enum e_mode status_calc_mode(struct block_list *bl, struct status_change *sc, enum e_mode mode)
|
||||
{
|
||||
if(!sc || !sc->count)
|
||||
return cap_value(mode, 0, INT_MAX);
|
||||
@ -7757,7 +7707,7 @@ void status_change_init(struct block_list *bl)
|
||||
* through the timer (e.g. those that deal damage in regular intervals)
|
||||
* @param type: Status change (SC_*)
|
||||
*------------------------------------------*/
|
||||
int status_get_sc_interval(enum sc_type type)
|
||||
static int status_get_sc_interval(enum sc_type type)
|
||||
{
|
||||
switch (type) {
|
||||
case SC_POISON:
|
||||
|
||||
@ -2329,42 +2329,6 @@ void status_calc_misc(struct block_list *bl, struct status_data *status, int lev
|
||||
void status_calc_regen(struct block_list *bl, struct status_data *status, struct regen_data *regen);
|
||||
void status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc);
|
||||
|
||||
unsigned short status_calc_str(struct block_list *bl, struct status_change *sc, int str);
|
||||
unsigned short status_calc_agi(struct block_list *bl, struct status_change *sc, int agi);
|
||||
unsigned short status_calc_vit(struct block_list *bl, struct status_change *sc, int vit);
|
||||
unsigned short status_calc_int(struct block_list *bl, struct status_change *sc, int int_);
|
||||
unsigned short status_calc_dex(struct block_list *bl, struct status_change *sc, int dex);
|
||||
unsigned short status_calc_luk(struct block_list *bl, struct status_change *sc, int luk);
|
||||
unsigned short status_calc_batk(struct block_list *bl, struct status_change *sc, int batk, bool display);
|
||||
unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc, int watk, bool display);
|
||||
unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc, int matk, bool display);
|
||||
#ifdef RENEWAL
|
||||
unsigned short status_calc_ematk(struct block_list *bl, struct status_change *sc, int matk);
|
||||
#endif
|
||||
signed short status_calc_hit(struct block_list *bl, struct status_change *sc, int hit, bool display);
|
||||
signed short status_calc_critical(struct block_list *bl, struct status_change *sc, int critical, bool display);
|
||||
signed short status_calc_flee(struct block_list *bl, struct status_change *sc, int flee, bool display);
|
||||
signed short status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2, bool display);
|
||||
defType status_calc_def(struct block_list *bl, struct status_change *sc, int def, bool display);
|
||||
signed short status_calc_def2(struct block_list *, struct status_change *, int def2, bool display);
|
||||
defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef, bool display);
|
||||
signed short status_calc_mdef2(struct block_list *, struct status_change *, int mdef2, bool display);
|
||||
unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc, int speed);
|
||||
#ifdef RENEWAL_ASPD
|
||||
short status_calc_aspd(struct block_list *bl, struct status_change *sc, bool fixed);
|
||||
#endif
|
||||
short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd);
|
||||
short status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate);
|
||||
unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion);
|
||||
unsigned int status_calc_maxhp(struct block_list *bl, uint64 maxhp);
|
||||
unsigned int status_calc_maxsp(struct block_list *bl, uint64 maxsp);
|
||||
unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element);
|
||||
unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv);
|
||||
enum e_mode status_calc_mode(struct block_list *bl, struct status_change *sc, enum e_mode mode);
|
||||
int status_get_hpbonus(struct block_list *bl, enum e_status_bonus type);
|
||||
int status_get_spbonus(struct block_list *bl, enum e_status_bonus type);
|
||||
unsigned int status_calc_maxhpsp_pc(struct map_session_data* sd, unsigned int stat, bool isHP);
|
||||
int status_get_sc_interval(enum sc_type type);
|
||||
void status_calc_slave_mode(struct mob_data *md, struct mob_data *mmd);
|
||||
|
||||
bool status_check_skilluse(struct block_list *src, struct block_list *target, uint16 skill_id, int flag);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user