// Copyright (c) Copyright (c) Hercules Dev Team, licensed under GNU GPL. // Copyright (c) 2014 - 2015 Evol developers #include "common/hercules.h" #include #include #include #include "common/HPMi.h" #include "common/nullpo.h" #include "common/utils.h" #include "common/random.h" #include "map/itemdb.h" #include "map/mob.h" #include "map/pc.h" #include "plugins/HPMHooking.h" #include "emap/data/itemd.h" #include "emap/data/mobd.h" #include "emap/struct/itemdext.h" #include "emap/struct/mobdext.h" // copy from common/utils.c /** * Applies a percentual rate modifier. * * @param value The base value. * @param rate The rate modifier to apply. * @param stdrate The rate modifier's divider (rate == stdrate => 100%). * @return The modified value. */ int64 apply_percentrate64(int64 value, int rate, int stdrate) { Assert_ret(stdrate > 0); Assert_ret(rate >= 0); if (rate == stdrate) return value; if (rate == 0) return 0; if (INT64_MAX / rate < value) { // Give up some precision to prevent overflows return value / stdrate * rate; } return value * rate / stdrate; } bool ebattle_check_arrows_post(bool retVal, struct map_session_data *sd) { if (retVal == true) { if (!sd) return retVal; const int ammoIndex = sd->equip_index[EQI_AMMO]; if (ammoIndex < 0) return true; const int ammoId = sd->inventory_data[ammoIndex]->nameid; if (ammoId <= 0) return true; const int weaponIndex = sd->equip_index[EQI_HAND_L]; if (weaponIndex < 0) return true; struct ItemdExt *data = itemd_get(sd->inventory_data[weaponIndex]); if (!data) return true; const int sz = VECTOR_LENGTH(data->allowedAmmo); if (sz == 0) // allow any ammo if AllowedAmmo list is empty return true; for (int f = 0; f < sz; f ++) { const int id = VECTOR_INDEX(data->allowedAmmo, f); if (ammoId == id) return true; } clif->arrow_fail(sd, 0); return false; } return false; } struct Damage ebattle_calc_weapon_attack_post(struct Damage retVal, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv __attribute__ ((unused)), int wflag __attribute__ ((unused))) { // Rebuild Infinite Defense Rule struct status_data *tstatus = status->get_status_data(target); int infdef = 0; infdef = (tstatus->mode&MD_PLANT && skill_id != RA_CLUSTERBOMB?1:0); #ifdef RENEWAL if (skill_id == HT_FREEZINGTRAP) infdef = 0; #endif if (!infdef && target->type == BL_SKILL) { const struct skill_unit *su = BL_UCCAST(BL_SKILL, target); if (su->group->unit_id == UNT_REVERBERATION) infdef = 1; // Reverberation takes 1 damage } // ML: Crits ignore defense (estimate) // (regardless of source or target) if (!infdef && retVal.type == BDT_CRIT) { // Minimum damage for criticals (per ML rule) if (retVal.damage <= 10) retVal.damage=10; /* This needs fixing int pnerf; pnerf=battle->calc_defense(BF_WEAPON, src, target, skill_id, skill_lv, retVal.damage, 0, 0); retVal.damage+=retVal.damage-pnerf; */ } if (src == NULL) return retVal; struct map_session_data *sd = BL_CAST(BL_PC, src); if (sd == NULL) return retVal; struct mob_data *md = BL_CAST(BL_MOB, target); if (md == NULL) return retVal; struct MobdExt *data = mobd_get_by_mob(md); if (data == NULL) return retVal; int mod = 0; if (skill_id > 0) { const int idx = skill->get_index(skill_id); mod = data->skillAttacks[idx]; } else { mod = data->weaponAttacks[sd->weapontype1]; } retVal.damage = apply_percentrate64(retVal.damage, mod, 10000); retVal.damage2 = apply_percentrate64(retVal.damage2, mod, 10000); return retVal; } struct Damage ebattle_calc_magic_attack_post(struct Damage retVal, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv __attribute__ ((unused)), int mflag __attribute__ ((unused))) { // Rebuild SD and SC data struct map_session_data *sd, *tsd; struct status_change *sc = status->get_sc(src); struct status_change *tsc = status->get_sc(target); struct status_data *sstatus = status->get_status_data(src); struct status_data *tstatus = status->get_status_data(target); sd = BL_CAST(BL_PC, src); tsd = BL_CAST(BL_PC, target); //Skip checking as there are no status changes active. if (sc && !sc->count) sc = NULL; if (tsc && !tsc->count) tsc = NULL; // Magic attacks can be blocked by shields. // This terminates everything if (tstatus->flee2 && rnd()%1000 < tstatus->flee2) { retVal.type = BDT_PDODGE; retVal.dmg_lv=ATK_LUCKY; if (retVal.div_ < 0) retVal.div_*=-1; retVal.damage=0; retVal.damage2=0; return retVal; } // Rebuild Infinite Defense Rule int infdef = 0; infdef = (tstatus->mode&MD_PLANT) ? 1 : 0; if (!infdef && target->type == BL_SKILL) { const struct skill_unit *su = BL_UCCAST(BL_SKILL, target); if (su->group->unit_id == UNT_REVERBERATION) infdef = 1; // Reverberation takes 1 damage } // Not infinite defense, extra calculations if (!infdef) { // Allow magic attacks to crit if ( sstatus->cri ) { int cri = sstatus->cri; // Race critical bonuses cri+= sd->critaddrace[tstatus->race]; // Critical Defense cri -= status->get_lv(target) / 5 + (3 * status_get_luk(target))/2; // Magic deals in average, 3x less criticals cri = cri / 3; // Sleeping target? if( tsc && tsc->data[SC_SLEEP] ) cri <<= 1; // Official critical defense calculation if(tsd && tsd->bonus.critical_def) cri = cri * ( 100 - tsd->bonus.critical_def ) / 100; // And finally, check if a crit! if (rnd()%1000 < cri) { // Damage +40% (official behavior) and CRITDMG bonus // Magic Crits are 50% weaker, because they rarely miss retVal.damage=apply_percentrate64(retVal.damage, (40+sd->bonus.crit_atk_rate)/2+100, 100); retVal.damage2=apply_percentrate64(retVal.damage2, (40+sd->bonus.crit_atk_rate)/2+100, 100); retVal.type = BDT_CRIT; } } // Err, enough maths for today } // Apply 4144 code if relevant if (src == NULL || sd == NULL) return retVal; struct mob_data *md = BL_CAST(BL_MOB, target); if (md == NULL) return retVal; struct MobdExt *data = mobd_get_by_mob(md); if (data == NULL) return retVal; int mod = 0; if (skill_id > 0) { const int idx = skill->get_index(skill_id); mod = data->skillAttacks[idx]; } else { mod = data->weaponAttacks[sd->weapontype1]; } retVal.damage = apply_percentrate64(retVal.damage, mod, 10000); retVal.damage2 = apply_percentrate64(retVal.damage2, mod, 10000); return retVal; } enum damage_lv ebattle_weapon_attack_pre(struct block_list **srcPtr, struct block_list **targetPtr, int64 *tickPtr __attribute__ ((unused)), int *flagPtr __attribute__ ((unused))) { struct block_list *src = *srcPtr; struct block_list *target = *targetPtr; nullpo_retr(ATK_NONE, src); nullpo_retr(ATK_NONE, target); struct map_session_data *sd = BL_CAST(BL_PC, src); if (sd == NULL) return ATK_NONE; const int weaponIndex = sd->equip_index[EQI_HAND_L]; if (weaponIndex < 0) return ATK_NONE; struct ItemdExt *data = itemd_get(sd->inventory_data[weaponIndex]); if (!data) return ATK_NONE; if (distance_bl(src, target) < data->minRange) { // if range between player and target > minRange, then dont attack hookStop(); return ATK_NONE; } return ATK_NONE; }