pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-03-31 14:32:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into lets_move

Browse Source
This commit is contained in:
KimLS 2016-01-18 20:15:36 -08:00
commit 66c952eff0
9 changed files with 1189 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

702
common/item.cpp
View File

@ -2322,6 +2322,708 @@ void ItemInst::ClearTimers() {
m_timers.clear(); m_timers.clear();
} }
int ItemInst::GetItemArmorClass(bool augments) const
{
int ac = 0;
const auto item = GetItem();
if (item) {
ac = item->AC;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
ac += GetAugment(i)->GetItemArmorClass();
}
return ac;
}
int ItemInst::GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments) const
{
const auto item = GetItem();
if (item) {
switch (item->ElemDmgType) {
case RESIST_MAGIC:
magic += item->ElemDmgAmt;
break;
case RESIST_FIRE:
fire += item->ElemDmgAmt;
break;
case RESIST_COLD:
cold += item->ElemDmgAmt;
break;
case RESIST_POISON:
poison += item->ElemDmgAmt;
break;
case RESIST_DISEASE:
disease += item->ElemDmgAmt;
break;
case RESIST_CHROMATIC:
chromatic += item->ElemDmgAmt;
break;
case RESIST_PRISMATIC:
prismatic += item->ElemDmgAmt;
break;
case RESIST_PHYSICAL:
physical += item->ElemDmgAmt;
break;
case RESIST_CORRUPTION:
corruption += item->ElemDmgAmt;
break;
}
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
GetAugment(i)->GetItemElementalDamage(magic, fire, cold, poison, disease, chromatic, prismatic, physical, corruption);
}
return magic + fire + cold + poison + disease + chromatic + prismatic + physical + corruption;
}
int ItemInst::GetItemElementalFlag(bool augments) const
{
int flag = 0;
const auto item = GetItem();
if (item) {
flag = item->ElemDmgType;
if (flag)
return flag;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i) {
if (GetAugment(i))
flag = GetAugment(i)->GetItemElementalFlag();
if (flag)
return flag;
}
}
}
return flag;
}
int ItemInst::GetItemElementalDamage(bool augments) const
{
int damage = 0;
const auto item = GetItem();
if (item) {
damage = item->ElemDmgAmt;
if (damage)
return damage;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i) {
if (GetAugment(i))
damage = GetAugment(i)->GetItemElementalDamage();
if (damage)
return damage;
}
}
}
return damage;
}
int ItemInst::GetItemRecommendedLevel(bool augments) const
{
int level = 0;
const auto item = GetItem();
if (item) {
level = item->RecLevel;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i) {
int temp = 0;
if (GetAugment(i)) {
temp = GetAugment(i)->GetItemRecommendedLevel();
if (temp > level)
level = temp;
}
}
}
}
return level;
}
int ItemInst::GetItemRequiredLevel(bool augments) const
{
int level = 0;
const auto item = GetItem();
if (item) {
level = item->ReqLevel;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i) {
int temp = 0;
if (GetAugment(i)) {
temp = GetAugment(i)->GetItemRequiredLevel();
if (temp > level)
level = temp;
}
}
}
}
return level;
}
int ItemInst::GetItemWeaponDamage(bool augments) const
{
int damage = 0;
const auto item = GetItem();
if (item) {
damage = item->Damage;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
damage += GetAugment(i)->GetItemWeaponDamage();
}
}
return damage;
}
int ItemInst::GetItemBackstabDamage(bool augments) const
{
int damage = 0;
const auto item = GetItem();
if (item) {
damage = item->BackstabDmg;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
damage += GetAugment(i)->GetItemBackstabDamage();
}
}
return damage;
}
int ItemInst::GetItemBaneDamageBody(bool augments) const
{
int body = 0;
const auto item = GetItem();
if (item) {
body = item->BaneDmgBody;
if (body)
return body;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i)) {
body = GetAugment(i)->GetItemBaneDamageBody();
if (body)
return body;
}
}
}
return body;
}
int ItemInst::GetItemBaneDamageRace(bool augments) const
{
int race = 0;
const auto item = GetItem();
if (item) {
race = item->BaneDmgRace;
if (race)
return race;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i)) {
race = GetAugment(i)->GetItemBaneDamageRace();
if (race)
return race;
}
}
}
return race;
}
int ItemInst::GetItemBaneDamageBody(bodyType against, bool augments) const
{
int damage = 0;
const auto item = GetItem();
if (item) {
if (item->BaneDmgBody == against)
damage += item->BaneDmgAmt;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
damage += GetAugment(i)->GetItemBaneDamageBody(against);
}
}
return damage;
}
int ItemInst::GetItemBaneDamageRace(uint16 against, bool augments) const
{
int damage = 0;
const auto item = GetItem();
if (item) {
if (item->BaneDmgRace == against)
damage += item->BaneDmgRaceAmt;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
damage += GetAugment(i)->GetItemBaneDamageRace(against);
}
}
return damage;
}
int ItemInst::GetItemMagical(bool augments) const
{
const auto item = GetItem();
if (item) {
if (item->Magic)
return 1;
if (augments) {
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i) && GetAugment(i)->GetItemMagical())
return 1;
}
}
return 0;
}
int ItemInst::GetItemHP(bool augments) const
{
int hp = 0;
const auto item = GetItem();
if (item) {
hp = item->HP;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
hp += GetAugment(i)->GetItemHP();
}
return hp;
}
int ItemInst::GetItemMana(bool augments) const
{
int mana = 0;
const auto item = GetItem();
if (item) {
mana = item->Mana;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
mana += GetAugment(i)->GetItemMana();
}
return mana;
}
int ItemInst::GetItemEndur(bool augments) const
{
int endur = 0;
const auto item = GetItem();
if (item) {
endur = item->Endur;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
endur += GetAugment(i)->GetItemEndur();
}
return endur;
}
int ItemInst::GetItemAttack(bool augments) const
{
int atk = 0;
const auto item = GetItem();
if (item) {
atk = item->Attack;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
atk += GetAugment(i)->GetItemAttack();
}
return atk;
}
int ItemInst::GetItemStr(bool augments) const
{
int str = 0;
const auto item = GetItem();
if (item) {
str = item->AStr;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
str += GetAugment(i)->GetItemStr();
}
return str;
}
int ItemInst::GetItemSta(bool augments) const
{
int sta = 0;
const auto item = GetItem();
if (item) {
sta = item->ASta;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
sta += GetAugment(i)->GetItemSta();
}
return sta;
}
int ItemInst::GetItemDex(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->ADex;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemDex();
}
return total;
}
int ItemInst::GetItemAgi(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->AAgi;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemAgi();
}
return total;
}
int ItemInst::GetItemInt(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->AInt;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemInt();
}
return total;
}
int ItemInst::GetItemWis(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->AWis;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemWis();
}
return total;
}
int ItemInst::GetItemCha(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->ACha;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemCha();
}
return total;
}
int ItemInst::GetItemMR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->MR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemMR();
}
return total;
}
int ItemInst::GetItemFR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->FR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemFR();
}
return total;
}
int ItemInst::GetItemCR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->CR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemCR();
}
return total;
}
int ItemInst::GetItemPR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->PR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemPR();
}
return total;
}
int ItemInst::GetItemDR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->DR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemDR();
}
return total;
}
int ItemInst::GetItemCorrup(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->SVCorruption;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemCorrup();
}
return total;
}
int ItemInst::GetItemHeroicStr(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicStr;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicStr();
}
return total;
}
int ItemInst::GetItemHeroicSta(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicSta;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicSta();
}
return total;
}
int ItemInst::GetItemHeroicDex(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicDex;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicDex();
}
return total;
}
int ItemInst::GetItemHeroicAgi(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicAgi;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicAgi();
}
return total;
}
int ItemInst::GetItemHeroicInt(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicInt;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicInt();
}
return total;
}
int ItemInst::GetItemHeroicWis(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicWis;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicWis();
}
return total;
}
int ItemInst::GetItemHeroicCha(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicCha;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicCha();
}
return total;
}
int ItemInst::GetItemHeroicMR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicMR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicMR();
}
return total;
}
int ItemInst::GetItemHeroicFR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicFR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicFR();
}
return total;
}
int ItemInst::GetItemHeroicCR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicCR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicCR();
}
return total;
}
int ItemInst::GetItemHeroicPR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicPR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicPR();
}
return total;
}
int ItemInst::GetItemHeroicDR(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicDR;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicDR();
}
return total;
}
int ItemInst::GetItemHeroicCorrup(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->HeroicSVCorrup;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i))
total += GetAugment(i)->GetItemHeroicCorrup();
}
return total;
}
int ItemInst::GetItemHaste(bool augments) const
{
int total = 0;
const auto item = GetItem();
if (item) {
total = item->Haste;
if (augments)
for (int i = AUG_BEGIN; i < EmuConstants::ITEM_COMMON_SIZE; ++i)
if (GetAugment(i)) {
int temp = GetAugment(i)->GetItemHaste();
if (temp > total)
total = temp;
}
}
return total;
}
// //
// class EvolveInfo // class EvolveInfo

53
common/item.h
View File

@ -29,6 +29,7 @@ class EvolveInfo; // Stores information about an evolving item family
#include "../common/eq_constants.h" #include "../common/eq_constants.h"
#include "../common/item_struct.h" #include "../common/item_struct.h"
#include "../common/timer.h" #include "../common/timer.h"
#include "../common/bodytypes.h"
#include <list> #include <list>
#include <map> #include <map>
@ -418,6 +419,58 @@ public:
void StopTimer(std::string name); void StopTimer(std::string name);
void ClearTimers(); void ClearTimers();
// Get a total of a stat, including augs
// These functions should be used in place of other code manually totaling
// to centralize where it is done to make future changes easier (ex. whenever powersources come around)
// and to minimize errors. CalcItemBonuses however doesn't use these in interest of performance
// by default these do not recurse into augs
int GetItemArmorClass(bool augments = false) const;
int GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments = false) const;
// These two differ in the fact that they're quick checks (they are checked BEFORE the one above
int GetItemElementalFlag(bool augments = false) const;
int GetItemElementalDamage(bool augments = false) const;
int GetItemRecommendedLevel(bool augments = false) const;
int GetItemRequiredLevel(bool augments = false) const;
int GetItemWeaponDamage(bool augments = false) const;
int GetItemBackstabDamage(bool augments = false) const;
// these two are just quick checks
int GetItemBaneDamageBody(bool augments = false) const;
int GetItemBaneDamageRace(bool augments = false) const;
int GetItemBaneDamageBody(bodyType against, bool augments = false) const;
int GetItemBaneDamageRace(uint16 against, bool augments = false) const;
int GetItemMagical(bool augments = false) const;
int GetItemHP(bool augments = false) const;
int GetItemMana(bool augments = false) const;
int GetItemEndur(bool augments = false) const;
int GetItemAttack(bool augments = false) const;
int GetItemStr(bool augments = false) const;
int GetItemSta(bool augments = false) const;
int GetItemDex(bool augments = false) const;
int GetItemAgi(bool augments = false) const;
int GetItemInt(bool augments = false) const;
int GetItemWis(bool augments = false) const;
int GetItemCha(bool augments = false) const;
int GetItemMR(bool augments = false) const;
int GetItemFR(bool augments = false) const;
int GetItemCR(bool augments = false) const;
int GetItemPR(bool augments = false) const;
int GetItemDR(bool augments = false) const;
int GetItemCorrup(bool augments = false) const;
int GetItemHeroicStr(bool augments = false) const;
int GetItemHeroicSta(bool augments = false) const;
int GetItemHeroicDex(bool augments = false) const;
int GetItemHeroicAgi(bool augments = false) const;
int GetItemHeroicInt(bool augments = false) const;
int GetItemHeroicWis(bool augments = false) const;
int GetItemHeroicCha(bool augments = false) const;
int GetItemHeroicMR(bool augments = false) const;
int GetItemHeroicFR(bool augments = false) const;
int GetItemHeroicCR(bool augments = false) const;
int GetItemHeroicPR(bool augments = false) const;
int GetItemHeroicDR(bool augments = false) const;
int GetItemHeroicCorrup(bool augments = false) const;
int GetItemHaste(bool augments = false) const;
protected: protected:
////////////////////////// //////////////////////////
// Protected Members // Protected Members

253
zone/attack.cpp
View File

@ -928,231 +928,108 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
int banedmg = 0; int banedmg = 0;
int x = 0; int x = 0;
if(!against || against->GetInvul() || against->GetSpecialAbility(IMMUNE_MELEE)){ if (!against || against->GetInvul() || against->GetSpecialAbility(IMMUNE_MELEE))
return 0; return 0;
}
//check for items being illegally attained // check for items being illegally attained
if(weapon_item){ if (weapon_item) {
const Item_Struct *mWeaponItem = weapon_item->GetItem(); if (!weapon_item->GetItem())
if(mWeaponItem){ return 0;
if(mWeaponItem->ReqLevel > GetLevel()){
return 0; if (weapon_item->GetItemRequiredLevel(true) > GetLevel())
} return 0;
if(!weapon_item->IsEquipable(GetBaseRace(), GetClass())){ if (!weapon_item->IsEquipable(GetBaseRace(), GetClass()))
return 0;
}
}
else{
return 0; return 0;
}
} }
if(against->GetSpecialAbility(IMMUNE_MELEE_NONMAGICAL)){ if (against->GetSpecialAbility(IMMUNE_MELEE_NONMAGICAL)) {
if(weapon_item){ if (weapon_item) {
// check to see if the weapon is magic // check to see if the weapon is magic
bool MagicWeapon = false; bool MagicWeapon = weapon_item->GetItemMagical(true) || spellbonuses.MagicWeapon || itembonuses.MagicWeapon;
if(weapon_item->GetItem() && weapon_item->GetItem()->Magic) if (MagicWeapon) {
MagicWeapon = true; auto rec_level = weapon_item->GetItemRecommendedLevel(true);
else if (IsClient() && GetLevel() < rec_level)
if(spellbonuses.MagicWeapon || itembonuses.MagicWeapon) dmg = CastToClient()->CalcRecommendedLevelBonus(
MagicWeapon = true; GetLevel(), rec_level, weapon_item->GetItemWeaponDamage(true));
else else
// An augment on the weapon that is marked magic makes dmg = weapon_item->GetItemWeaponDamage(true);
// the item magical.
for(x = 0; MagicWeapon == false && x < EmuConstants::ITEM_COMMON_SIZE; x++)
{
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem())
{
if (weapon_item->GetAugment(x)->GetItem()->Magic)
MagicWeapon = true;
}
}
if(MagicWeapon) {
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){
dmg = CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->Damage);
}
else{
dmg = weapon_item->GetItem()->Damage;
}
for(int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; x++){
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem()){
dmg += weapon_item->GetAugment(x)->GetItem()->Damage;
if (hate) *hate += weapon_item->GetAugment(x)->GetItem()->Damage + weapon_item->GetAugment(x)->GetItem()->ElemDmgAmt;
}
}
dmg = dmg <= 0 ? 1 : dmg; dmg = dmg <= 0 ? 1 : dmg;
} } else {
else
return 0; return 0;
} }
else{ } else {
bool MagicGloves=false; bool MagicGloves = false;
if (IsClient()) { if (IsClient()) {
ItemInst *gloves=CastToClient()->GetInv().GetItem(MainHands); const ItemInst *gloves = CastToClient()->GetInv().GetItem(MainHands);
if (gloves != nullptr) { if (gloves)
MagicGloves = gloves->GetItem()->Magic; MagicGloves = gloves->GetItemMagical(true);
}
} }
if((GetClass() == MONK || GetClass() == BEASTLORD)) { if (GetClass() == MONK || GetClass() == BEASTLORD) {
if(MagicGloves || GetLevel() >= 30){ if (MagicGloves || GetLevel() >= 30) {
dmg = GetHandToHandDamage(); dmg = GetHandToHandDamage();
if (hate) *hate += dmg; if (hate)
*hate += dmg;
} }
} } else if (GetOwner() &&
else if(GetOwner() && GetLevel() >= RuleI(Combat, PetAttackMagicLevel)){ //pets wouldn't actually use this but... GetLevel() >=
dmg = 1; //it gives us an idea if we can hit RuleI(Combat, PetAttackMagicLevel)) { // pets wouldn't actually use this but...
} dmg = 1; // it gives us an idea if we can hit
else if(MagicGloves || GetSpecialAbility(SPECATK_MAGICAL)){ } else if (MagicGloves || GetSpecialAbility(SPECATK_MAGICAL)) {
dmg = 1; dmg = 1;
} } else
else
return 0; return 0;
} }
} } else {
else{ if (weapon_item) {
if(weapon_item){ if (weapon_item->GetItem()) {
if(weapon_item->GetItem()){ auto rec_level = weapon_item->GetItemRecommendedLevel(true);
if (IsClient() && GetLevel() < rec_level) {
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){ dmg = CastToClient()->CalcRecommendedLevelBonus(
dmg = CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->Damage); GetLevel(), rec_level, weapon_item->GetItemWeaponDamage(true));
} } else {
else{ dmg = weapon_item->GetItemWeaponDamage(true);
dmg = weapon_item->GetItem()->Damage;
} }
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; x++){
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem()){
dmg += weapon_item->GetAugment(x)->GetItem()->Damage;
if (hate) *hate += weapon_item->GetAugment(x)->GetItem()->Damage + weapon_item->GetAugment(x)->GetItem()->ElemDmgAmt;
}
}
dmg = dmg <= 0 ? 1 : dmg; dmg = dmg <= 0 ? 1 : dmg;
} }
} } else {
else{
dmg = GetHandToHandDamage(); dmg = GetHandToHandDamage();
if (hate) *hate += dmg; if (hate)
*hate += dmg;
} }
} }
int eledmg = 0; int eledmg = 0;
if(!against->GetSpecialAbility(IMMUNE_MAGIC)){ if (!against->GetSpecialAbility(IMMUNE_MAGIC)) {
if(weapon_item && weapon_item->GetItem() && weapon_item->GetItem()->ElemDmgAmt){ if (weapon_item && weapon_item->GetItem() && weapon_item->GetItemElementalFlag(true))
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){ // the client actually has the way this is done, it does not appear to check req!
eledmg = CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->ElemDmgAmt); eledmg = against->ResistElementalWeaponDmg(weapon_item);
}
else{
eledmg = weapon_item->GetItem()->ElemDmgAmt;
}
if(eledmg)
{
eledmg = (eledmg * against->ResistSpell(weapon_item->GetItem()->ElemDmgType, 0, this) / 100);
}
}
if(weapon_item){
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; x++){
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem()){
if(weapon_item->GetAugment(x)->GetItem()->ElemDmgAmt)
eledmg += (weapon_item->GetAugment(x)->GetItem()->ElemDmgAmt * against->ResistSpell(weapon_item->GetAugment(x)->GetItem()->ElemDmgType, 0, this) / 100);
}
}
}
} }
if(against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)){ if (weapon_item && weapon_item->GetItem() &&
if(weapon_item && weapon_item->GetItem()){ (weapon_item->GetItemBaneDamageBody(true) || weapon_item->GetItemBaneDamageRace(true)))
if(weapon_item->GetItem()->BaneDmgBody == against->GetBodyType()){ banedmg = against->CheckBaneDamage(weapon_item);
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){
banedmg += CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->BaneDmgAmt);
}
else{
banedmg += weapon_item->GetItem()->BaneDmgAmt;
}
}
if(weapon_item->GetItem()->BaneDmgRace == against->GetRace()){ if (against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)) {
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){ if (!eledmg && !banedmg) {
banedmg += CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->BaneDmgRaceAmt); if (!GetSpecialAbility(SPECATK_BANE))
}
else{
banedmg += weapon_item->GetItem()->BaneDmgRaceAmt;
}
}
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; x++){
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem()){
if(weapon_item->GetAugment(x)->GetItem()->BaneDmgBody == against->GetBodyType()){
banedmg += weapon_item->GetAugment(x)->GetItem()->BaneDmgAmt;
}
if(weapon_item->GetAugment(x)->GetItem()->BaneDmgRace == against->GetRace()){
banedmg += weapon_item->GetAugment(x)->GetItem()->BaneDmgRaceAmt;
}
}
}
}
if(!eledmg && !banedmg)
{
if(!GetSpecialAbility(SPECATK_BANE))
return 0; return 0;
else else
return 1; return 1;
} } else {
else {
dmg += (banedmg + eledmg); dmg += (banedmg + eledmg);
if (hate) *hate += banedmg; if (hate)
} *hate += banedmg;
}
else{
if(weapon_item && weapon_item->GetItem()){
if(weapon_item->GetItem()->BaneDmgBody == against->GetBodyType()){
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){
banedmg += CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->BaneDmgAmt);
}
else{
banedmg += weapon_item->GetItem()->BaneDmgAmt;
}
}
if(weapon_item->GetItem()->BaneDmgRace == against->GetRace()){
if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){
banedmg += CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->BaneDmgRaceAmt);
}
else{
banedmg += weapon_item->GetItem()->BaneDmgRaceAmt;
}
}
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; x++){
if(weapon_item->GetAugment(x) && weapon_item->GetAugment(x)->GetItem()){
if(weapon_item->GetAugment(x)->GetItem()->BaneDmgBody == against->GetBodyType()){
banedmg += weapon_item->GetAugment(x)->GetItem()->BaneDmgAmt;
}
if(weapon_item->GetAugment(x)->GetItem()->BaneDmgRace == against->GetRace()){
banedmg += weapon_item->GetAugment(x)->GetItem()->BaneDmgRaceAmt;
}
}
}
} }
} else {
dmg += (banedmg + eledmg); dmg += (banedmg + eledmg);
if (hate) *hate += banedmg; if (hate)
*hate += banedmg;
} }
if(dmg <= 0){ return std::max(0, dmg);
return 0;
}
else
return dmg;
} }
//note: throughout this method, setting `damage` to a negative is a way to //note: throughout this method, setting `damage` to a negative is a way to

320
zone/bonuses.cpp
View File

@ -207,32 +207,31 @@ void Client::ProcessItemCaps()
itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap()); itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap());
} }
void Client::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute) { void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override)
if(!inst || !inst->IsType(ItemClassCommon)) {
{ if (!inst || !inst->IsType(ItemClassCommon)) {
return; return;
} }
if(inst->GetAugmentType()==0 && isAug == true) if (inst->GetAugmentType() == 0 && isAug == true) {
{
return; return;
} }
const Item_Struct *item = inst->GetItem(); const Item_Struct *item = inst->GetItem();
if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass())) if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
{ if (item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink)
if(item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink)
return; return;
} }
if(GetLevel() < item->ReqLevel) if (GetLevel() < inst->GetItemRequiredLevel(true)) {
{
return; return;
} }
if(GetLevel() >= item->RecLevel) // So there isn't a very nice way to get the real rec level from the aug's inst, so we just pass it in, only
{ // used for augs
auto rec_level = isAug ? rec_override : inst->GetItemRecommendedLevel(true);
if (GetLevel() >= rec_level) {
newbon->AC += item->AC; newbon->AC += item->AC;
newbon->HP += item->HP; newbon->HP += item->HP;
newbon->Mana += item->Mana; newbon->Mana += item->Mana;
@ -281,280 +280,257 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAu
newbon->HeroicDR += item->HeroicDR; newbon->HeroicDR += item->HeroicDR;
newbon->HeroicCorrup += item->HeroicSVCorrup; newbon->HeroicCorrup += item->HeroicSVCorrup;
} } else {
else
{
int lvl = GetLevel(); int lvl = GetLevel();
int reclvl = item->RecLevel;
newbon->AC += CalcRecommendedLevelBonus( lvl, reclvl, item->AC ); newbon->AC += CalcRecommendedLevelBonus(lvl, rec_level, item->AC);
newbon->HP += CalcRecommendedLevelBonus( lvl, reclvl, item->HP ); newbon->HP += CalcRecommendedLevelBonus(lvl, rec_level, item->HP);
newbon->Mana += CalcRecommendedLevelBonus( lvl, reclvl, item->Mana ); newbon->Mana += CalcRecommendedLevelBonus(lvl, rec_level, item->Mana);
newbon->Endurance += CalcRecommendedLevelBonus( lvl, reclvl, item->Endur ); newbon->Endurance += CalcRecommendedLevelBonus(lvl, rec_level, item->Endur);
newbon->ATK += CalcRecommendedLevelBonus( lvl, reclvl, item->Attack ); newbon->ATK += CalcRecommendedLevelBonus(lvl, rec_level, item->Attack);
newbon->STR += CalcRecommendedLevelBonus( lvl, reclvl, (item->AStr + item->HeroicStr) ); newbon->STR += CalcRecommendedLevelBonus(lvl, rec_level, (item->AStr + item->HeroicStr));
newbon->STA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ASta + item->HeroicSta) ); newbon->STA += CalcRecommendedLevelBonus(lvl, rec_level, (item->ASta + item->HeroicSta));
newbon->DEX += CalcRecommendedLevelBonus( lvl, reclvl, (item->ADex + item->HeroicDex) ); newbon->DEX += CalcRecommendedLevelBonus(lvl, rec_level, (item->ADex + item->HeroicDex));
newbon->AGI += CalcRecommendedLevelBonus( lvl, reclvl, (item->AAgi + item->HeroicAgi) ); newbon->AGI += CalcRecommendedLevelBonus(lvl, rec_level, (item->AAgi + item->HeroicAgi));
newbon->INT += CalcRecommendedLevelBonus( lvl, reclvl, (item->AInt + item->HeroicInt) ); newbon->INT += CalcRecommendedLevelBonus(lvl, rec_level, (item->AInt + item->HeroicInt));
newbon->WIS += CalcRecommendedLevelBonus( lvl, reclvl, (item->AWis + item->HeroicWis) ); newbon->WIS += CalcRecommendedLevelBonus(lvl, rec_level, (item->AWis + item->HeroicWis));
newbon->CHA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ACha + item->HeroicCha) ); newbon->CHA += CalcRecommendedLevelBonus(lvl, rec_level, (item->ACha + item->HeroicCha));
newbon->MR += CalcRecommendedLevelBonus( lvl, reclvl, (item->MR + item->HeroicMR) ); newbon->MR += CalcRecommendedLevelBonus(lvl, rec_level, (item->MR + item->HeroicMR));
newbon->FR += CalcRecommendedLevelBonus( lvl, reclvl, (item->FR + item->HeroicFR) ); newbon->FR += CalcRecommendedLevelBonus(lvl, rec_level, (item->FR + item->HeroicFR));
newbon->CR += CalcRecommendedLevelBonus( lvl, reclvl, (item->CR + item->HeroicCR) ); newbon->CR += CalcRecommendedLevelBonus(lvl, rec_level, (item->CR + item->HeroicCR));
newbon->PR += CalcRecommendedLevelBonus( lvl, reclvl, (item->PR + item->HeroicPR) ); newbon->PR += CalcRecommendedLevelBonus(lvl, rec_level, (item->PR + item->HeroicPR));
newbon->DR += CalcRecommendedLevelBonus( lvl, reclvl, (item->DR + item->HeroicDR) ); newbon->DR += CalcRecommendedLevelBonus(lvl, rec_level, (item->DR + item->HeroicDR));
newbon->Corrup += CalcRecommendedLevelBonus( lvl, reclvl, (item->SVCorruption + item->HeroicSVCorrup) ); newbon->Corrup +=
CalcRecommendedLevelBonus(lvl, rec_level, (item->SVCorruption + item->HeroicSVCorrup));
newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr ); newbon->STRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicStr);
newbon->STACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta ); newbon->STACapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSta);
newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex ); newbon->DEXCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDex);
newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi ); newbon->AGICapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicAgi);
newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt ); newbon->INTCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicInt);
newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis ); newbon->WISCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicWis);
newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha ); newbon->CHACapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCha);
newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR ); newbon->MRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicMR);
newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR ); newbon->CRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicFR);
newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR ); newbon->FRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCR);
newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR ); newbon->PRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicPR);
newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR ); newbon->DRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDR);
newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup ); newbon->CorrupCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSVCorrup);
newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr ); newbon->HeroicSTR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicStr);
newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta ); newbon->HeroicSTA += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSta);
newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex ); newbon->HeroicDEX += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDex);
newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi ); newbon->HeroicAGI += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicAgi);
newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt ); newbon->HeroicINT += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicInt);
newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis ); newbon->HeroicWIS += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicWis);
newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha ); newbon->HeroicCHA += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCha);
newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR ); newbon->HeroicMR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicMR);
newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR ); newbon->HeroicFR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicFR);
newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR ); newbon->HeroicCR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCR);
newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR ); newbon->HeroicPR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicPR);
newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR ); newbon->HeroicDR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDR);
newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup ); newbon->HeroicCorrup += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSVCorrup);
} }
//FatherNitwit: New style haste, shields, and regens // FatherNitwit: New style haste, shields, and regens
if(newbon->haste < (int32)item->Haste) { if (newbon->haste < (int32)item->Haste) {
newbon->haste = item->Haste; newbon->haste = item->Haste;
} }
if(item->Regen > 0) if (item->Regen > 0)
newbon->HPRegen += item->Regen; newbon->HPRegen += item->Regen;
if(item->ManaRegen > 0) if (item->ManaRegen > 0)
newbon->ManaRegen += item->ManaRegen; newbon->ManaRegen += item->ManaRegen;
if(item->EnduranceRegen > 0) if (item->EnduranceRegen > 0)
newbon->EnduranceRegen += item->EnduranceRegen; newbon->EnduranceRegen += item->EnduranceRegen;
if(item->DamageShield > 0) { if (item->DamageShield > 0) {
if((newbon->DamageShield + item->DamageShield) > RuleI(Character, ItemDamageShieldCap)) if ((newbon->DamageShield + item->DamageShield) > RuleI(Character, ItemDamageShieldCap))
newbon->DamageShield = RuleI(Character, ItemDamageShieldCap); newbon->DamageShield = RuleI(Character, ItemDamageShieldCap);
else else
newbon->DamageShield += item->DamageShield; newbon->DamageShield += item->DamageShield;
} }
if(item->SpellShield > 0) { if (item->SpellShield > 0) {
if((newbon->SpellShield + item->SpellShield) > RuleI(Character, ItemSpellShieldingCap)) if ((newbon->SpellShield + item->SpellShield) > RuleI(Character, ItemSpellShieldingCap))
newbon->SpellShield = RuleI(Character, ItemSpellShieldingCap); newbon->SpellShield = RuleI(Character, ItemSpellShieldingCap);
else else
newbon->SpellShield += item->SpellShield; newbon->SpellShield += item->SpellShield;
} }
if(item->Shielding > 0) { if (item->Shielding > 0) {
if((newbon->MeleeMitigation + item->Shielding) > RuleI(Character, ItemShieldingCap)) if ((newbon->MeleeMitigation + item->Shielding) > RuleI(Character, ItemShieldingCap))
newbon->MeleeMitigation = RuleI(Character, ItemShieldingCap); newbon->MeleeMitigation = RuleI(Character, ItemShieldingCap);
else else
newbon->MeleeMitigation += item->Shielding; newbon->MeleeMitigation += item->Shielding;
} }
if(item->StunResist > 0) { if (item->StunResist > 0) {
if((newbon->StunResist + item->StunResist) > RuleI(Character, ItemStunResistCap)) if ((newbon->StunResist + item->StunResist) > RuleI(Character, ItemStunResistCap))
newbon->StunResist = RuleI(Character, ItemStunResistCap); newbon->StunResist = RuleI(Character, ItemStunResistCap);
else else
newbon->StunResist += item->StunResist; newbon->StunResist += item->StunResist;
} }
if(item->StrikeThrough > 0) { if (item->StrikeThrough > 0) {
if((newbon->StrikeThrough + item->StrikeThrough) > RuleI(Character, ItemStrikethroughCap)) if ((newbon->StrikeThrough + item->StrikeThrough) > RuleI(Character, ItemStrikethroughCap))
newbon->StrikeThrough = RuleI(Character, ItemStrikethroughCap); newbon->StrikeThrough = RuleI(Character, ItemStrikethroughCap);
else else
newbon->StrikeThrough += item->StrikeThrough; newbon->StrikeThrough += item->StrikeThrough;
} }
if(item->Avoidance > 0) { if (item->Avoidance > 0) {
if((newbon->AvoidMeleeChance + item->Avoidance) > RuleI(Character, ItemAvoidanceCap)) if ((newbon->AvoidMeleeChance + item->Avoidance) > RuleI(Character, ItemAvoidanceCap))
newbon->AvoidMeleeChance = RuleI(Character, ItemAvoidanceCap); newbon->AvoidMeleeChance = RuleI(Character, ItemAvoidanceCap);
else else
newbon->AvoidMeleeChance += item->Avoidance; newbon->AvoidMeleeChance += item->Avoidance;
} }
if(item->Accuracy > 0) { if (item->Accuracy > 0) {
if((newbon->HitChance + item->Accuracy) > RuleI(Character, ItemAccuracyCap)) if ((newbon->HitChance + item->Accuracy) > RuleI(Character, ItemAccuracyCap))
newbon->HitChance = RuleI(Character, ItemAccuracyCap); newbon->HitChance = RuleI(Character, ItemAccuracyCap);
else else
newbon->HitChance += item->Accuracy; newbon->HitChance += item->Accuracy;
} }
if(item->CombatEffects > 0) { if (item->CombatEffects > 0) {
if((newbon->ProcChance + item->CombatEffects) > RuleI(Character, ItemCombatEffectsCap)) if ((newbon->ProcChance + item->CombatEffects) > RuleI(Character, ItemCombatEffectsCap))
newbon->ProcChance = RuleI(Character, ItemCombatEffectsCap); newbon->ProcChance = RuleI(Character, ItemCombatEffectsCap);
else else
newbon->ProcChance += item->CombatEffects; newbon->ProcChance += item->CombatEffects;
} }
if(item->DotShielding > 0) { if (item->DotShielding > 0) {
if((newbon->DoTShielding + item->DotShielding) > RuleI(Character, ItemDoTShieldingCap)) if ((newbon->DoTShielding + item->DotShielding) > RuleI(Character, ItemDoTShieldingCap))
newbon->DoTShielding = RuleI(Character, ItemDoTShieldingCap); newbon->DoTShielding = RuleI(Character, ItemDoTShieldingCap);
else else
newbon->DoTShielding += item->DotShielding; newbon->DoTShielding += item->DotShielding;
} }
if(item->HealAmt > 0) { if (item->HealAmt > 0) {
if((newbon->HealAmt + item->HealAmt) > RuleI(Character, ItemHealAmtCap)) if ((newbon->HealAmt + item->HealAmt) > RuleI(Character, ItemHealAmtCap))
newbon->HealAmt = RuleI(Character, ItemHealAmtCap); newbon->HealAmt = RuleI(Character, ItemHealAmtCap);
else else
newbon->HealAmt += item->HealAmt; newbon->HealAmt += item->HealAmt;
} }
if(item->SpellDmg > 0) { if (item->SpellDmg > 0) {
if((newbon->SpellDmg + item->SpellDmg) > RuleI(Character, ItemSpellDmgCap)) if ((newbon->SpellDmg + item->SpellDmg) > RuleI(Character, ItemSpellDmgCap))
newbon->SpellDmg = RuleI(Character, ItemSpellDmgCap); newbon->SpellDmg = RuleI(Character, ItemSpellDmgCap);
else else
newbon->SpellDmg += item->SpellDmg; newbon->SpellDmg += item->SpellDmg;
} }
if(item->Clairvoyance > 0) { if (item->Clairvoyance > 0) {
if((newbon->Clairvoyance + item->Clairvoyance) > RuleI(Character, ItemClairvoyanceCap)) if ((newbon->Clairvoyance + item->Clairvoyance) > RuleI(Character, ItemClairvoyanceCap))
newbon->Clairvoyance = RuleI(Character, ItemClairvoyanceCap); newbon->Clairvoyance = RuleI(Character, ItemClairvoyanceCap);
else else
newbon->Clairvoyance += item->Clairvoyance; newbon->Clairvoyance += item->Clairvoyance;
} }
if(item->DSMitigation > 0) { if (item->DSMitigation > 0) {
if((newbon->DSMitigation + item->DSMitigation) > RuleI(Character, ItemDSMitigationCap)) if ((newbon->DSMitigation + item->DSMitigation) > RuleI(Character, ItemDSMitigationCap))
newbon->DSMitigation = RuleI(Character, ItemDSMitigationCap); newbon->DSMitigation = RuleI(Character, ItemDSMitigationCap);
else else
newbon->DSMitigation += item->DSMitigation; newbon->DSMitigation += item->DSMitigation;
} }
if (item->Worn.Effect > 0 && item->Worn.Type == ET_WornEffect) {// latent effects if (item->Worn.Effect > 0 && item->Worn.Type == ET_WornEffect) { // latent effects
ApplySpellsBonuses(item->Worn.Effect, item->Worn.Level, newbon, 0, item->Worn.Type); ApplySpellsBonuses(item->Worn.Effect, item->Worn.Level, newbon, 0, item->Worn.Type);
} }
if (item->Focus.Effect>0 && (item->Focus.Type == ET_Focus)) { // focus effects if (item->Focus.Effect > 0 && (item->Focus.Type == ET_Focus)) { // focus effects
ApplySpellsBonuses(item->Focus.Effect, item->Focus.Level, newbon, 0); ApplySpellsBonuses(item->Focus.Effect, item->Focus.Level, newbon, 0);
} }
switch(item->BardType) switch (item->BardType) {
{
case 51: /* All (e.g. Singing Short Sword) */ case 51: /* All (e.g. Singing Short Sword) */
{ {
if(item->BardValue > newbon->singingMod) if (item->BardValue > newbon->singingMod)
newbon->singingMod = item->BardValue; newbon->singingMod = item->BardValue;
if(item->BardValue > newbon->brassMod) if (item->BardValue > newbon->brassMod)
newbon->brassMod = item->BardValue; newbon->brassMod = item->BardValue;
if(item->BardValue > newbon->stringedMod) if (item->BardValue > newbon->stringedMod)
newbon->stringedMod = item->BardValue; newbon->stringedMod = item->BardValue;
if(item->BardValue > newbon->percussionMod) if (item->BardValue > newbon->percussionMod)
newbon->percussionMod = item->BardValue; newbon->percussionMod = item->BardValue;
if(item->BardValue > newbon->windMod) if (item->BardValue > newbon->windMod)
newbon->windMod = item->BardValue; newbon->windMod = item->BardValue;
break; break;
} }
case 50: /* Singing */ case 50: /* Singing */
{ {
if(item->BardValue > newbon->singingMod) if (item->BardValue > newbon->singingMod)
newbon->singingMod = item->BardValue; newbon->singingMod = item->BardValue;
break; break;
} }
case 23: /* Wind */ case 23: /* Wind */
{ {
if(item->BardValue > newbon->windMod) if (item->BardValue > newbon->windMod)
newbon->windMod = item->BardValue; newbon->windMod = item->BardValue;
break; break;
} }
case 24: /* stringed */ case 24: /* stringed */
{ {
if(item->BardValue > newbon->stringedMod) if (item->BardValue > newbon->stringedMod)
newbon->stringedMod = item->BardValue; newbon->stringedMod = item->BardValue;
break; break;
} }
case 25: /* brass */ case 25: /* brass */
{ {
if(item->BardValue > newbon->brassMod) if (item->BardValue > newbon->brassMod)
newbon->brassMod = item->BardValue; newbon->brassMod = item->BardValue;
break; break;
} }
case 26: /* Percussion */ case 26: /* Percussion */
{ {
if(item->BardValue > newbon->percussionMod) if (item->BardValue > newbon->percussionMod)
newbon->percussionMod = item->BardValue; newbon->percussionMod = item->BardValue;
break; break;
} }
} }
if (item->SkillModValue != 0 && item->SkillModType <= HIGHEST_SKILL){ if (item->SkillModValue != 0 && item->SkillModType <= HIGHEST_SKILL) {
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) || if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue)) (item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue)) {
{
newbon->skillmod[item->SkillModType] = item->SkillModValue; newbon->skillmod[item->SkillModType] = item->SkillModValue;
newbon->skillmodmax[item->SkillModType] = item->SkillModMax; newbon->skillmodmax[item->SkillModType] = item->SkillModMax;
} }
} }
// Add Item Faction Mods // Add Item Faction Mods
if (item->FactionMod1) if (item->FactionMod1) {
{ if (item->FactionAmt1 > 0 && item->FactionAmt1 > GetItemFactionBonus(item->FactionMod1)) {
if (item->FactionAmt1 > 0 && item->FactionAmt1 > GetItemFactionBonus(item->FactionMod1))
{
AddItemFactionBonus(item->FactionMod1, item->FactionAmt1); AddItemFactionBonus(item->FactionMod1, item->FactionAmt1);
} } else if (item->FactionAmt1 < 0 && item->FactionAmt1 < GetItemFactionBonus(item->FactionMod1)) {
else if (item->FactionAmt1 < 0 && item->FactionAmt1 < GetItemFactionBonus(item->FactionMod1))
{
AddItemFactionBonus(item->FactionMod1, item->FactionAmt1); AddItemFactionBonus(item->FactionMod1, item->FactionAmt1);
} }
} }
if (item->FactionMod2) if (item->FactionMod2) {
{ if (item->FactionAmt2 > 0 && item->FactionAmt2 > GetItemFactionBonus(item->FactionMod2)) {
if (item->FactionAmt2 > 0 && item->FactionAmt2 > GetItemFactionBonus(item->FactionMod2))
{
AddItemFactionBonus(item->FactionMod2, item->FactionAmt2); AddItemFactionBonus(item->FactionMod2, item->FactionAmt2);
} } else if (item->FactionAmt2 < 0 && item->FactionAmt2 < GetItemFactionBonus(item->FactionMod2)) {
else if (item->FactionAmt2 < 0 && item->FactionAmt2 < GetItemFactionBonus(item->FactionMod2))
{
AddItemFactionBonus(item->FactionMod2, item->FactionAmt2); AddItemFactionBonus(item->FactionMod2, item->FactionAmt2);
} }
} }
if (item->FactionMod3) if (item->FactionMod3) {
{ if (item->FactionAmt3 > 0 && item->FactionAmt3 > GetItemFactionBonus(item->FactionMod3)) {
if (item->FactionAmt3 > 0 && item->FactionAmt3 > GetItemFactionBonus(item->FactionMod3))
{
AddItemFactionBonus(item->FactionMod3, item->FactionAmt3); AddItemFactionBonus(item->FactionMod3, item->FactionAmt3);
} } else if (item->FactionAmt3 < 0 && item->FactionAmt3 < GetItemFactionBonus(item->FactionMod3)) {
else if (item->FactionAmt3 < 0 && item->FactionAmt3 < GetItemFactionBonus(item->FactionMod3))
{
AddItemFactionBonus(item->FactionMod3, item->FactionAmt3); AddItemFactionBonus(item->FactionMod3, item->FactionAmt3);
} }
} }
if (item->FactionMod4) if (item->FactionMod4) {
{ if (item->FactionAmt4 > 0 && item->FactionAmt4 > GetItemFactionBonus(item->FactionMod4)) {
if (item->FactionAmt4 > 0 && item->FactionAmt4 > GetItemFactionBonus(item->FactionMod4))
{
AddItemFactionBonus(item->FactionMod4, item->FactionAmt4); AddItemFactionBonus(item->FactionMod4, item->FactionAmt4);
} } else if (item->FactionAmt4 < 0 && item->FactionAmt4 < GetItemFactionBonus(item->FactionMod4)) {
else if (item->FactionAmt4 < 0 && item->FactionAmt4 < GetItemFactionBonus(item->FactionMod4))
{
AddItemFactionBonus(item->FactionMod4, item->FactionAmt4); AddItemFactionBonus(item->FactionMod4, item->FactionAmt4);
} }
} }
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= HIGHEST_SKILL) { if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= HIGHEST_SKILL) {
if((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) > RuleI(Character, ItemExtraDmgCap)) if ((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) >
RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap); newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
else else
newbon->SkillDamageAmount[item->ExtraDmgSkill] += item->ExtraDmgAmt; newbon->SkillDamageAmount[item->ExtraDmgSkill] += item->ExtraDmgAmt;
} }
if (!isAug) if (!isAug) {
{ for (int i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++)
int i; AddItemBonuses(inst->GetAugment(i), newbon, true, false, rec_level);
for (i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++) {
AddItemBonuses(inst->GetAugment(i),newbon,true);
}
} }
} }
void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug) { void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug) {

102
zone/bot.cpp
View File

@ -8829,7 +8829,7 @@ void Bot::CalcItemBonuses(StatBonuses* newbon)
newbon->EnduranceRegen = CalcEnduranceRegenCap(); newbon->EnduranceRegen = CalcEnduranceRegenCap();
} }
void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute) { void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute, int rec_override) {
if(!inst || !inst->IsType(ItemClassCommon)) if(!inst || !inst->IsType(ItemClassCommon))
{ {
return; return;
@ -8848,12 +8848,13 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
return; return;
} }
if(GetLevel() < item->ReqLevel) if(GetLevel() < inst->GetItemRequiredLevel(true))
{ {
return; return;
} }
if(GetLevel() >= item->RecLevel) auto rec_level = isAug ? rec_override : inst->GetItemRecommendedLevel(true);
if(GetLevel() >= rec_level)
{ {
newbon->AC += item->AC; newbon->AC += item->AC;
newbon->HP += item->HP; newbon->HP += item->HP;
@ -8907,55 +8908,54 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
else else
{ {
int lvl = GetLevel(); int lvl = GetLevel();
int reclvl = item->RecLevel;
newbon->AC += CalcRecommendedLevelBonus( lvl, reclvl, item->AC ); newbon->AC += CalcRecommendedLevelBonus( lvl, rec_level, item->AC );
newbon->HP += CalcRecommendedLevelBonus( lvl, reclvl, item->HP ); newbon->HP += CalcRecommendedLevelBonus( lvl, rec_level, item->HP );
newbon->Mana += CalcRecommendedLevelBonus( lvl, reclvl, item->Mana ); newbon->Mana += CalcRecommendedLevelBonus( lvl, rec_level, item->Mana );
newbon->Endurance += CalcRecommendedLevelBonus( lvl, reclvl, item->Endur ); newbon->Endurance += CalcRecommendedLevelBonus( lvl, rec_level, item->Endur );
newbon->ATK += CalcRecommendedLevelBonus( lvl, reclvl, item->Attack ); newbon->ATK += CalcRecommendedLevelBonus( lvl, rec_level, item->Attack );
newbon->STR += CalcRecommendedLevelBonus( lvl, reclvl, (item->AStr + item->HeroicStr) ); newbon->STR += CalcRecommendedLevelBonus( lvl, rec_level, (item->AStr + item->HeroicStr) );
newbon->STA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ASta + item->HeroicSta) ); newbon->STA += CalcRecommendedLevelBonus( lvl, rec_level, (item->ASta + item->HeroicSta) );
newbon->DEX += CalcRecommendedLevelBonus( lvl, reclvl, (item->ADex + item->HeroicDex) ); newbon->DEX += CalcRecommendedLevelBonus( lvl, rec_level, (item->ADex + item->HeroicDex) );
newbon->AGI += CalcRecommendedLevelBonus( lvl, reclvl, (item->AAgi + item->HeroicAgi) ); newbon->AGI += CalcRecommendedLevelBonus( lvl, rec_level, (item->AAgi + item->HeroicAgi) );
newbon->INT += CalcRecommendedLevelBonus( lvl, reclvl, (item->AInt + item->HeroicInt) ); newbon->INT += CalcRecommendedLevelBonus( lvl, rec_level, (item->AInt + item->HeroicInt) );
newbon->WIS += CalcRecommendedLevelBonus( lvl, reclvl, (item->AWis + item->HeroicWis) ); newbon->WIS += CalcRecommendedLevelBonus( lvl, rec_level, (item->AWis + item->HeroicWis) );
newbon->CHA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ACha + item->HeroicCha) ); newbon->CHA += CalcRecommendedLevelBonus( lvl, rec_level, (item->ACha + item->HeroicCha) );
newbon->MR += CalcRecommendedLevelBonus( lvl, reclvl, (item->MR + item->HeroicMR) ); newbon->MR += CalcRecommendedLevelBonus( lvl, rec_level, (item->MR + item->HeroicMR) );
newbon->FR += CalcRecommendedLevelBonus( lvl, reclvl, (item->FR + item->HeroicFR) ); newbon->FR += CalcRecommendedLevelBonus( lvl, rec_level, (item->FR + item->HeroicFR) );
newbon->CR += CalcRecommendedLevelBonus( lvl, reclvl, (item->CR + item->HeroicCR) ); newbon->CR += CalcRecommendedLevelBonus( lvl, rec_level, (item->CR + item->HeroicCR) );
newbon->PR += CalcRecommendedLevelBonus( lvl, reclvl, (item->PR + item->HeroicPR) ); newbon->PR += CalcRecommendedLevelBonus( lvl, rec_level, (item->PR + item->HeroicPR) );
newbon->DR += CalcRecommendedLevelBonus( lvl, reclvl, (item->DR + item->HeroicDR) ); newbon->DR += CalcRecommendedLevelBonus( lvl, rec_level, (item->DR + item->HeroicDR) );
newbon->Corrup += CalcRecommendedLevelBonus( lvl, reclvl, (item->SVCorruption + item->HeroicSVCorrup) ); newbon->Corrup += CalcRecommendedLevelBonus( lvl, rec_level, (item->SVCorruption + item->HeroicSVCorrup) );
newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr ); newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicStr );
newbon->STACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta ); newbon->STACapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSta );
newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex ); newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDex );
newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi ); newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicAgi );
newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt ); newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicInt );
newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis ); newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicWis );
newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha ); newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCha );
newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR ); newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicMR );
newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR ); newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicFR );
newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR ); newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCR );
newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR ); newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicPR );
newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR ); newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDR );
newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup ); newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSVCorrup );
newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr ); newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicStr );
newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta ); newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSta );
newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex ); newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDex );
newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi ); newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicAgi );
newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt ); newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicInt );
newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis ); newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicWis );
newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha ); newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCha );
newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR ); newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicMR );
newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR ); newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicFR );
newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR ); newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCR );
newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR ); newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicPR );
newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR ); newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDR );
newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup ); newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSVCorrup );
} }
//FatherNitwit: New style haste, shields, and regens //FatherNitwit: New style haste, shields, and regens
@ -9124,10 +9124,8 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
if (!isAug) if (!isAug)
{ {
int i; for (int i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++)
for (i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++) { AddItemBonuses(inst->GetAugment(i),newbon,true, false, rec_level);
AddItemBonuses(inst->GetAugment(i),newbon,true);
}
} }
} }

2
zone/bot.h
View File

@ -193,7 +193,7 @@ public:
virtual int32 CheckAggroAmount(uint16 spellid); virtual int32 CheckAggroAmount(uint16 spellid);
virtual void CalcBonuses(); virtual void CalcBonuses();
void CalcItemBonuses(StatBonuses* newbon); void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false); void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat); int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr); virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther); virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther);

2
zone/client.h
View File

@ -1275,7 +1275,7 @@ public:
protected: protected:
friend class Mob; friend class Mob;
void CalcItemBonuses(StatBonuses* newbon); void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false); void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
void AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false); void AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat); int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
void CalcEdibleBonuses(StatBonuses* newbon); void CalcEdibleBonuses(StatBonuses* newbon);

168
zone/mob.cpp
View File

@ -5681,4 +5681,170 @@ int32 Mob::GetMeleeMitigation() {
mitigation += itembonuses.MeleeMitigationEffect; mitigation += itembonuses.MeleeMitigationEffect;
mitigation += aabonuses.MeleeMitigationEffect; mitigation += aabonuses.MeleeMitigationEffect;
return mitigation; return mitigation;
} }
/* this is the mob being attacked.
* Pass in the weapon's ItemInst
*/
int Mob::ResistElementalWeaponDmg(const ItemInst *item)
{
if (!item)
return 0;
int magic = 0, fire = 0, cold = 0, poison = 0, disease = 0, chromatic = 0, prismatic = 0, physical = 0,
corruption = 0;
int resist = 0;
int roll = 0;
/* this is how the client does the resist rolls for these.
* Given the difficulty of parsing out these resists, I'll trust the client
*/
if (item->GetItemElementalDamage(magic, fire, cold, poison, disease, chromatic, prismatic, physical, corruption, true)) {
if (magic) {
resist = GetMR();
if (resist >= 201) {
magic = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
magic = 0;
else if (roll < 100)
magic = magic * roll / 100;
}
}
if (fire) {
resist = GetFR();
if (resist >= 201) {
fire = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
fire = 0;
else if (roll < 100)
fire = fire * roll / 100;
}
}
if (cold) {
resist = GetCR();
if (resist >= 201) {
cold = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
cold = 0;
else if (roll < 100)
cold = cold * roll / 100;
}
}
if (poison) {
resist = GetPR();
if (resist >= 201) {
poison = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
poison = 0;
else if (roll < 100)
poison = poison * roll / 100;
}
}
if (disease) {
resist = GetDR();
if (resist >= 201) {
disease = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
disease = 0;
else if (roll < 100)
disease = disease * roll / 100;
}
}
if (corruption) {
resist = GetCorrup();
if (resist >= 201) {
corruption = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
corruption = 0;
else if (roll < 100)
corruption = corruption * roll / 100;
}
}
if (chromatic) {
resist = GetFR();
int temp = GetCR();
if (temp < resist)
resist = temp;
temp = GetMR();
if (temp < resist)
resist = temp;
temp = GetDR();
if (temp < resist)
resist = temp;
temp = GetPR();
if (temp < resist)
resist = temp;
if (resist >= 201) {
chromatic = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
chromatic = 0;
else if (roll < 100)
chromatic = chromatic * roll / 100;
}
}
if (prismatic) {
resist = (GetFR() + GetCR() + GetMR() + GetDR() + GetPR()) / 5;
if (resist >= 201) {
prismatic = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
prismatic = 0;
else if (roll < 100)
prismatic = prismatic * roll / 100;
}
}
if (physical) {
resist = GetPhR();
if (resist >= 201) {
physical = 0;
} else {
roll = zone->random.Int(0, 200) - resist;
if (roll < 1)
physical = 0;
else if (roll < 100)
physical = physical * roll / 100;
}
}
}
return magic + fire + cold + poison + disease + chromatic + prismatic + physical + corruption;
}
/* this is the mob being attacked.
* Pass in the weapon's ItemInst
*/
int Mob::CheckBaneDamage(const ItemInst *item)
{
if (!item)
return 0;
int damage = item->GetItemBaneDamageBody(GetBodyType(), true);
damage += item->GetItemBaneDamageRace(GetRace(), true);
return damage;
}

2
zone/mob.h
View File

@ -233,6 +233,8 @@ public:
int resist_override = 0, bool CharismaCheck = false, bool CharmTick = false, bool IsRoot = false, int resist_override = 0, bool CharismaCheck = false, bool CharmTick = false, bool IsRoot = false,
int level_override = -1); int level_override = -1);
int ResistPhysical(int level_diff, uint8 caster_level); int ResistPhysical(int level_diff, uint8 caster_level);
int ResistElementalWeaponDmg(const ItemInst *item);
int CheckBaneDamage(const ItemInst *item);
uint16 GetSpecializeSkillValue(uint16 spell_id) const; uint16 GetSpecializeSkillValue(uint16 spell_id) const;
void SendSpellBarDisable(); void SendSpellBarDisable();
void SendSpellBarEnable(uint16 spellid); void SendSpellBarEnable(uint16 spellid);