diff --git a/common/item.cpp b/common/item.cpp
index 7ce8e730d..26ec154c3 100644
--- a/common/item.cpp
+++ b/common/item.cpp
@@ -2322,6 +2322,708 @@ void ItemInst::ClearTimers() {
 	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
diff --git a/common/item.h b/common/item.h
index a5dd01f95..b6babde9f 100644
--- a/common/item.h
+++ b/common/item.h
@@ -29,6 +29,7 @@ class EvolveInfo;			// Stores information about an evolving item family
 #include "../common/eq_constants.h"
 #include "../common/item_struct.h"
 #include "../common/timer.h"
+#include "../common/bodytypes.h"
 
 #include <list>
 #include <map>
@@ -418,6 +419,58 @@ public:
 	void StopTimer(std::string name);
 	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 Members
diff --git a/zone/attack.cpp b/zone/attack.cpp
index 532a53686..85ee29e9d 100644
--- a/zone/attack.cpp
+++ b/zone/attack.cpp
@@ -928,231 +928,108 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
 	int banedmg = 0;
 	int x = 0;
 
-	if(!against || against->GetInvul() || against->GetSpecialAbility(IMMUNE_MELEE)){
+	if (!against || against->GetInvul() || against->GetSpecialAbility(IMMUNE_MELEE))
 		return 0;
-	}
 
-	//check for items being illegally attained
-	if(weapon_item){
-		const Item_Struct *mWeaponItem = weapon_item->GetItem();
-		if(mWeaponItem){
-			if(mWeaponItem->ReqLevel > GetLevel()){
-				return 0;
-			}
-
-			if(!weapon_item->IsEquipable(GetBaseRace(), GetClass())){
-				return 0;
-			}
-		}
-		else{
+	// check for items being illegally attained
+	if (weapon_item) {
+		if (!weapon_item->GetItem())
+			return 0;
+
+		if (weapon_item->GetItemRequiredLevel(true) > GetLevel())
+			return 0;
+
+		if (!weapon_item->IsEquipable(GetBaseRace(), GetClass()))
 			return 0;
-		}
 	}
 
-	if(against->GetSpecialAbility(IMMUNE_MELEE_NONMAGICAL)){
-		if(weapon_item){
+	if (against->GetSpecialAbility(IMMUNE_MELEE_NONMAGICAL)) {
+		if (weapon_item) {
 			// check to see if the weapon is magic
-			bool MagicWeapon = false;
-			if(weapon_item->GetItem() && weapon_item->GetItem()->Magic)
-				MagicWeapon = true;
-			else
-				if(spellbonuses.MagicWeapon || itembonuses.MagicWeapon)
-					MagicWeapon = true;
+			bool MagicWeapon = weapon_item->GetItemMagical(true) || spellbonuses.MagicWeapon || itembonuses.MagicWeapon;
+			if (MagicWeapon) {
+				auto rec_level = weapon_item->GetItemRecommendedLevel(true);
+				if (IsClient() && GetLevel() < rec_level)
+					dmg = CastToClient()->CalcRecommendedLevelBonus(
+					    GetLevel(), rec_level, weapon_item->GetItemWeaponDamage(true));
 				else
-					// An augment on the weapon that is marked magic makes
-					// 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 = weapon_item->GetItemWeaponDamage(true);
 				dmg = dmg <= 0 ? 1 : dmg;
-			}
-			else
+			} else {
 				return 0;
-		}
-		else{
-			bool MagicGloves=false;
+			}
+		} else {
+			bool MagicGloves = false;
 			if (IsClient()) {
-				ItemInst *gloves=CastToClient()->GetInv().GetItem(MainHands);
-				if (gloves != nullptr) {
-					MagicGloves = gloves->GetItem()->Magic;
-				}
+				const ItemInst *gloves = CastToClient()->GetInv().GetItem(MainHands);
+				if (gloves)
+					MagicGloves = gloves->GetItemMagical(true);
 			}
 
-			if((GetClass() == MONK || GetClass() == BEASTLORD)) {
-				if(MagicGloves || GetLevel() >= 30){
+			if (GetClass() == MONK || GetClass() == BEASTLORD) {
+				if (MagicGloves || GetLevel() >= 30) {
 					dmg = GetHandToHandDamage();
-					if (hate) *hate += dmg;
+					if (hate)
+						*hate += dmg;
 				}
-			}
-			else if(GetOwner() && GetLevel() >= 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 (GetOwner() &&
+				   GetLevel() >=
+				       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)) {
 				dmg = 1;
-			}
-			else
+			} else
 				return 0;
 		}
-	}
-	else{
-		if(weapon_item){
-			if(weapon_item->GetItem()){
-
-				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;
+	} else {
+		if (weapon_item) {
+			if (weapon_item->GetItem()) {
+				auto rec_level = weapon_item->GetItemRecommendedLevel(true);
+				if (IsClient() && GetLevel() < rec_level) {
+					dmg = CastToClient()->CalcRecommendedLevelBonus(
+					    GetLevel(), rec_level, weapon_item->GetItemWeaponDamage(true));
+				} else {
+					dmg = weapon_item->GetItemWeaponDamage(true);
 				}
 
-				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;
 			}
-		}
-		else{
+		} else {
 			dmg = GetHandToHandDamage();
-			if (hate) *hate += dmg;
+			if (hate)
+				*hate += dmg;
 		}
 	}
 
 	int eledmg = 0;
-	if(!against->GetSpecialAbility(IMMUNE_MAGIC)){
-		if(weapon_item && weapon_item->GetItem() && weapon_item->GetItem()->ElemDmgAmt){
-			if(IsClient() && GetLevel() < weapon_item->GetItem()->RecLevel){
-				eledmg = CastToClient()->CalcRecommendedLevelBonus(GetLevel(), weapon_item->GetItem()->RecLevel, weapon_item->GetItem()->ElemDmgAmt);
-			}
-			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_MAGIC)) {
+		if (weapon_item && weapon_item->GetItem() && weapon_item->GetItemElementalFlag(true))
+			// the client actually has the way this is done, it does not appear to check req!
+			eledmg = against->ResistElementalWeaponDmg(weapon_item);
 	}
 
-	if(against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)){
-		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 && weapon_item->GetItem() &&
+			(weapon_item->GetItemBaneDamageBody(true) || weapon_item->GetItemBaneDamageRace(true)))
+		banedmg = against->CheckBaneDamage(weapon_item);
 
-			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;
-					}
-				}
-			}
-		}
-
-		if(!eledmg && !banedmg)
-		{
-			if(!GetSpecialAbility(SPECATK_BANE))
+	if (against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)) {
+		if (!eledmg && !banedmg) {
+			if (!GetSpecialAbility(SPECATK_BANE))
 				return 0;
 			else
 				return 1;
-		}
-		else {
+		} else {
 			dmg += (banedmg + eledmg);
-			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;
-					}
-				}
-			}
+			if (hate)
+				*hate += banedmg;
 		}
+	} else {
 		dmg += (banedmg + eledmg);
-		if (hate) *hate += banedmg;
+		if (hate)
+			*hate += banedmg;
 	}
 
-	if(dmg <= 0){
-		return 0;
-	}
-	else
-		return dmg;
+	return std::max(0, dmg);
 }
 
 //note: throughout this method, setting `damage` to a negative is a way to
diff --git a/zone/bonuses.cpp b/zone/bonuses.cpp
index 9e2461bd6..e709bdef4 100644
--- a/zone/bonuses.cpp
+++ b/zone/bonuses.cpp
@@ -207,32 +207,31 @@ void Client::ProcessItemCaps()
 	itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap());
 }
 
-void Client::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute) {
-	if(!inst || !inst->IsType(ItemClassCommon))
-	{
+void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override)
+{
+	if (!inst || !inst->IsType(ItemClassCommon)) {
 		return;
 	}
 
-	if(inst->GetAugmentType()==0 && isAug == true)
-	{
+	if (inst->GetAugmentType() == 0 && isAug == true) {
 		return;
 	}
 
 	const Item_Struct *item = inst->GetItem();
 
-	if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass()))
-	{
-		if(item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink)
+	if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
+		if (item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink)
 			return;
 	}
 
-	if(GetLevel() < item->ReqLevel)
-	{
+	if (GetLevel() < inst->GetItemRequiredLevel(true)) {
 		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->HP += item->HP;
 		newbon->Mana += item->Mana;
@@ -281,280 +280,257 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAu
 		newbon->HeroicDR += item->HeroicDR;
 		newbon->HeroicCorrup += item->HeroicSVCorrup;
 
-	}
-	else
-	{
+	} else {
 		int lvl = GetLevel();
-		int reclvl = item->RecLevel;
 
-		newbon->AC += CalcRecommendedLevelBonus( lvl, reclvl, item->AC );
-		newbon->HP += CalcRecommendedLevelBonus( lvl, reclvl, item->HP );
-		newbon->Mana += CalcRecommendedLevelBonus( lvl, reclvl, item->Mana );
-		newbon->Endurance += CalcRecommendedLevelBonus( lvl, reclvl, item->Endur );
-		newbon->ATK += CalcRecommendedLevelBonus( lvl, reclvl, item->Attack );
-		newbon->STR += CalcRecommendedLevelBonus( lvl, reclvl, (item->AStr + item->HeroicStr) );
-		newbon->STA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ASta + item->HeroicSta) );
-		newbon->DEX += CalcRecommendedLevelBonus( lvl, reclvl, (item->ADex + item->HeroicDex) );
-		newbon->AGI += CalcRecommendedLevelBonus( lvl, reclvl, (item->AAgi + item->HeroicAgi) );
-		newbon->INT += CalcRecommendedLevelBonus( lvl, reclvl, (item->AInt + item->HeroicInt) );
-		newbon->WIS += CalcRecommendedLevelBonus( lvl, reclvl, (item->AWis + item->HeroicWis) );
-		newbon->CHA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ACha + item->HeroicCha) );
+		newbon->AC += CalcRecommendedLevelBonus(lvl, rec_level, item->AC);
+		newbon->HP += CalcRecommendedLevelBonus(lvl, rec_level, item->HP);
+		newbon->Mana += CalcRecommendedLevelBonus(lvl, rec_level, item->Mana);
+		newbon->Endurance += CalcRecommendedLevelBonus(lvl, rec_level, item->Endur);
+		newbon->ATK += CalcRecommendedLevelBonus(lvl, rec_level, item->Attack);
+		newbon->STR += CalcRecommendedLevelBonus(lvl, rec_level, (item->AStr + item->HeroicStr));
+		newbon->STA += CalcRecommendedLevelBonus(lvl, rec_level, (item->ASta + item->HeroicSta));
+		newbon->DEX += CalcRecommendedLevelBonus(lvl, rec_level, (item->ADex + item->HeroicDex));
+		newbon->AGI += CalcRecommendedLevelBonus(lvl, rec_level, (item->AAgi + item->HeroicAgi));
+		newbon->INT += CalcRecommendedLevelBonus(lvl, rec_level, (item->AInt + item->HeroicInt));
+		newbon->WIS += CalcRecommendedLevelBonus(lvl, rec_level, (item->AWis + item->HeroicWis));
+		newbon->CHA += CalcRecommendedLevelBonus(lvl, rec_level, (item->ACha + item->HeroicCha));
 
-		newbon->MR += CalcRecommendedLevelBonus( lvl, reclvl, (item->MR + item->HeroicMR) );
-		newbon->FR += CalcRecommendedLevelBonus( lvl, reclvl, (item->FR + item->HeroicFR) );
-		newbon->CR += CalcRecommendedLevelBonus( lvl, reclvl, (item->CR + item->HeroicCR) );
-		newbon->PR += CalcRecommendedLevelBonus( lvl, reclvl, (item->PR + item->HeroicPR) );
-		newbon->DR += CalcRecommendedLevelBonus( lvl, reclvl, (item->DR + item->HeroicDR) );
-		newbon->Corrup += CalcRecommendedLevelBonus( lvl, reclvl, (item->SVCorruption + item->HeroicSVCorrup) );
+		newbon->MR += CalcRecommendedLevelBonus(lvl, rec_level, (item->MR + item->HeroicMR));
+		newbon->FR += CalcRecommendedLevelBonus(lvl, rec_level, (item->FR + item->HeroicFR));
+		newbon->CR += CalcRecommendedLevelBonus(lvl, rec_level, (item->CR + item->HeroicCR));
+		newbon->PR += CalcRecommendedLevelBonus(lvl, rec_level, (item->PR + item->HeroicPR));
+		newbon->DR += CalcRecommendedLevelBonus(lvl, rec_level, (item->DR + item->HeroicDR));
+		newbon->Corrup +=
+		    CalcRecommendedLevelBonus(lvl, rec_level, (item->SVCorruption + item->HeroicSVCorrup));
 
-		newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr );
-		newbon->STACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta );
-		newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex );
-		newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi );
-		newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt );
-		newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis );
-		newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha );
-		newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR );
-		newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR );
-		newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR );
-		newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR );
-		newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR );
-		newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup );
+		newbon->STRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicStr);
+		newbon->STACapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSta);
+		newbon->DEXCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDex);
+		newbon->AGICapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicAgi);
+		newbon->INTCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicInt);
+		newbon->WISCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicWis);
+		newbon->CHACapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCha);
+		newbon->MRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicMR);
+		newbon->CRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicFR);
+		newbon->FRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCR);
+		newbon->PRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicPR);
+		newbon->DRCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDR);
+		newbon->CorrupCapMod += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSVCorrup);
 
-		newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr );
-		newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta );
-		newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex );
-		newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi );
-		newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt );
-		newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis );
-		newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha );
-		newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR );
-		newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR );
-		newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR );
-		newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR );
-		newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR );
-		newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup );
+		newbon->HeroicSTR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicStr);
+		newbon->HeroicSTA += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSta);
+		newbon->HeroicDEX += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDex);
+		newbon->HeroicAGI += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicAgi);
+		newbon->HeroicINT += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicInt);
+		newbon->HeroicWIS += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicWis);
+		newbon->HeroicCHA += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCha);
+		newbon->HeroicMR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicMR);
+		newbon->HeroicFR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicFR);
+		newbon->HeroicCR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicCR);
+		newbon->HeroicPR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicPR);
+		newbon->HeroicDR += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicDR);
+		newbon->HeroicCorrup += CalcRecommendedLevelBonus(lvl, rec_level, item->HeroicSVCorrup);
 	}
 
-	//FatherNitwit: New style haste, shields, and regens
-	if(newbon->haste < (int32)item->Haste) {
+	// FatherNitwit: New style haste, shields, and regens
+	if (newbon->haste < (int32)item->Haste) {
 		newbon->haste = item->Haste;
 	}
-	if(item->Regen > 0)
+	if (item->Regen > 0)
 		newbon->HPRegen += item->Regen;
 
-	if(item->ManaRegen > 0)
+	if (item->ManaRegen > 0)
 		newbon->ManaRegen += item->ManaRegen;
 
-	if(item->EnduranceRegen > 0)
+	if (item->EnduranceRegen > 0)
 		newbon->EnduranceRegen += item->EnduranceRegen;
 
-	if(item->DamageShield > 0) {
-		if((newbon->DamageShield + item->DamageShield) > RuleI(Character, ItemDamageShieldCap))
+	if (item->DamageShield > 0) {
+		if ((newbon->DamageShield + item->DamageShield) > RuleI(Character, ItemDamageShieldCap))
 			newbon->DamageShield = RuleI(Character, ItemDamageShieldCap);
 		else
 			newbon->DamageShield += item->DamageShield;
 	}
-	if(item->SpellShield > 0) {
-		if((newbon->SpellShield + item->SpellShield) > RuleI(Character, ItemSpellShieldingCap))
+	if (item->SpellShield > 0) {
+		if ((newbon->SpellShield + item->SpellShield) > RuleI(Character, ItemSpellShieldingCap))
 			newbon->SpellShield = RuleI(Character, ItemSpellShieldingCap);
 		else
 			newbon->SpellShield += item->SpellShield;
 	}
-	if(item->Shielding > 0) {
-		if((newbon->MeleeMitigation + item->Shielding) > RuleI(Character, ItemShieldingCap))
+	if (item->Shielding > 0) {
+		if ((newbon->MeleeMitigation + item->Shielding) > RuleI(Character, ItemShieldingCap))
 			newbon->MeleeMitigation = RuleI(Character, ItemShieldingCap);
 		else
 			newbon->MeleeMitigation += item->Shielding;
 	}
-	if(item->StunResist > 0) {
-		if((newbon->StunResist + item->StunResist) > RuleI(Character, ItemStunResistCap))
+	if (item->StunResist > 0) {
+		if ((newbon->StunResist + item->StunResist) > RuleI(Character, ItemStunResistCap))
 			newbon->StunResist = RuleI(Character, ItemStunResistCap);
 		else
 			newbon->StunResist += item->StunResist;
 	}
-	if(item->StrikeThrough > 0) {
-		if((newbon->StrikeThrough + item->StrikeThrough) > RuleI(Character, ItemStrikethroughCap))
+	if (item->StrikeThrough > 0) {
+		if ((newbon->StrikeThrough + item->StrikeThrough) > RuleI(Character, ItemStrikethroughCap))
 			newbon->StrikeThrough = RuleI(Character, ItemStrikethroughCap);
 		else
 			newbon->StrikeThrough += item->StrikeThrough;
 	}
-	if(item->Avoidance > 0) {
-		if((newbon->AvoidMeleeChance + item->Avoidance) > RuleI(Character, ItemAvoidanceCap))
+	if (item->Avoidance > 0) {
+		if ((newbon->AvoidMeleeChance + item->Avoidance) > RuleI(Character, ItemAvoidanceCap))
 			newbon->AvoidMeleeChance = RuleI(Character, ItemAvoidanceCap);
 		else
 			newbon->AvoidMeleeChance += item->Avoidance;
 	}
-	if(item->Accuracy > 0) {
-		if((newbon->HitChance + item->Accuracy) > RuleI(Character, ItemAccuracyCap))
+	if (item->Accuracy > 0) {
+		if ((newbon->HitChance + item->Accuracy) > RuleI(Character, ItemAccuracyCap))
 			newbon->HitChance = RuleI(Character, ItemAccuracyCap);
 		else
 			newbon->HitChance += item->Accuracy;
 	}
-	if(item->CombatEffects > 0) {
-		if((newbon->ProcChance + item->CombatEffects) > RuleI(Character, ItemCombatEffectsCap))
+	if (item->CombatEffects > 0) {
+		if ((newbon->ProcChance + item->CombatEffects) > RuleI(Character, ItemCombatEffectsCap))
 			newbon->ProcChance = RuleI(Character, ItemCombatEffectsCap);
 		else
 			newbon->ProcChance += item->CombatEffects;
 	}
-	if(item->DotShielding > 0) {
-		if((newbon->DoTShielding + item->DotShielding) > RuleI(Character, ItemDoTShieldingCap))
+	if (item->DotShielding > 0) {
+		if ((newbon->DoTShielding + item->DotShielding) > RuleI(Character, ItemDoTShieldingCap))
 			newbon->DoTShielding = RuleI(Character, ItemDoTShieldingCap);
 		else
 			newbon->DoTShielding += item->DotShielding;
 	}
 
-	if(item->HealAmt > 0) {
-		if((newbon->HealAmt + item->HealAmt) > RuleI(Character, ItemHealAmtCap))
+	if (item->HealAmt > 0) {
+		if ((newbon->HealAmt + item->HealAmt) > RuleI(Character, ItemHealAmtCap))
 			newbon->HealAmt = RuleI(Character, ItemHealAmtCap);
 		else
 			newbon->HealAmt += item->HealAmt;
 	}
-	if(item->SpellDmg > 0) {
-		if((newbon->SpellDmg + item->SpellDmg) > RuleI(Character, ItemSpellDmgCap))
+	if (item->SpellDmg > 0) {
+		if ((newbon->SpellDmg + item->SpellDmg) > RuleI(Character, ItemSpellDmgCap))
 			newbon->SpellDmg = RuleI(Character, ItemSpellDmgCap);
 		else
 			newbon->SpellDmg += item->SpellDmg;
 	}
-	if(item->Clairvoyance > 0) {
-		if((newbon->Clairvoyance + item->Clairvoyance) > RuleI(Character, ItemClairvoyanceCap))
+	if (item->Clairvoyance > 0) {
+		if ((newbon->Clairvoyance + item->Clairvoyance) > RuleI(Character, ItemClairvoyanceCap))
 			newbon->Clairvoyance = RuleI(Character, ItemClairvoyanceCap);
 		else
 			newbon->Clairvoyance += item->Clairvoyance;
 	}
 
-	if(item->DSMitigation > 0) {
-		if((newbon->DSMitigation + item->DSMitigation) > RuleI(Character, ItemDSMitigationCap))
+	if (item->DSMitigation > 0) {
+		if ((newbon->DSMitigation + item->DSMitigation) > RuleI(Character, ItemDSMitigationCap))
 			newbon->DSMitigation = RuleI(Character, ItemDSMitigationCap);
 		else
 			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);
 	}
 
-	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);
 	}
 
-	switch(item->BardType)
-	{
+	switch (item->BardType) {
 	case 51: /* All (e.g. Singing Short Sword) */
-		{
-			if(item->BardValue > newbon->singingMod)
-				newbon->singingMod = item->BardValue;
-			if(item->BardValue > newbon->brassMod)
-				newbon->brassMod = item->BardValue;
-			if(item->BardValue > newbon->stringedMod)
-				newbon->stringedMod = item->BardValue;
-			if(item->BardValue > newbon->percussionMod)
-				newbon->percussionMod = item->BardValue;
-			if(item->BardValue > newbon->windMod)
-				newbon->windMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->singingMod)
+			newbon->singingMod = item->BardValue;
+		if (item->BardValue > newbon->brassMod)
+			newbon->brassMod = item->BardValue;
+		if (item->BardValue > newbon->stringedMod)
+			newbon->stringedMod = item->BardValue;
+		if (item->BardValue > newbon->percussionMod)
+			newbon->percussionMod = item->BardValue;
+		if (item->BardValue > newbon->windMod)
+			newbon->windMod = item->BardValue;
+		break;
+	}
 	case 50: /* Singing */
-		{
-			if(item->BardValue > newbon->singingMod)
-				newbon->singingMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->singingMod)
+			newbon->singingMod = item->BardValue;
+		break;
+	}
 	case 23: /* Wind */
-		{
-			if(item->BardValue > newbon->windMod)
-				newbon->windMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->windMod)
+			newbon->windMod = item->BardValue;
+		break;
+	}
 	case 24: /* stringed */
-		{
-			if(item->BardValue > newbon->stringedMod)
-				newbon->stringedMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->stringedMod)
+			newbon->stringedMod = item->BardValue;
+		break;
+	}
 	case 25: /* brass */
-		{
-			if(item->BardValue > newbon->brassMod)
-				newbon->brassMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->brassMod)
+			newbon->brassMod = item->BardValue;
+		break;
+	}
 	case 26: /* Percussion */
-		{
-			if(item->BardValue > newbon->percussionMod)
-				newbon->percussionMod = item->BardValue;
-			break;
-		}
+	{
+		if (item->BardValue > newbon->percussionMod)
+			newbon->percussionMod = item->BardValue;
+		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) ||
-			(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->skillmodmax[item->SkillModType] = item->SkillModMax;
 		}
 	}
 
 	// Add Item Faction Mods
-	if (item->FactionMod1)
-	{
-		if (item->FactionAmt1 > 0 && item->FactionAmt1 > GetItemFactionBonus(item->FactionMod1))
-		{
+	if (item->FactionMod1) {
+		if (item->FactionAmt1 > 0 && item->FactionAmt1 > GetItemFactionBonus(item->FactionMod1)) {
 			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);
 		}
 	}
-	if (item->FactionMod2)
-	{
-		if (item->FactionAmt2 > 0 && item->FactionAmt2 > GetItemFactionBonus(item->FactionMod2))
-		{
+	if (item->FactionMod2) {
+		if (item->FactionAmt2 > 0 && item->FactionAmt2 > GetItemFactionBonus(item->FactionMod2)) {
 			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);
 		}
 	}
-	if (item->FactionMod3)
-	{
-		if (item->FactionAmt3 > 0 && item->FactionAmt3 > GetItemFactionBonus(item->FactionMod3))
-		{
+	if (item->FactionMod3) {
+		if (item->FactionAmt3 > 0 && item->FactionAmt3 > GetItemFactionBonus(item->FactionMod3)) {
 			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);
 		}
 	}
-	if (item->FactionMod4)
-	{
-		if (item->FactionAmt4 > 0 && item->FactionAmt4 > GetItemFactionBonus(item->FactionMod4))
-		{
+	if (item->FactionMod4) {
+		if (item->FactionAmt4 > 0 && item->FactionAmt4 > GetItemFactionBonus(item->FactionMod4)) {
 			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);
 		}
 	}
 
 	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);
 		else
 			newbon->SkillDamageAmount[item->ExtraDmgSkill] += item->ExtraDmgAmt;
 	}
 
-	if (!isAug)
-	{
-		int i;
-		for (i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++) {
-			AddItemBonuses(inst->GetAugment(i),newbon,true);
-		}
+	if (!isAug) {
+		for (int i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++)
+			AddItemBonuses(inst->GetAugment(i), newbon, true, false, rec_level);
 	}
-
 }
 
 void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug) {
diff --git a/zone/bot.cpp b/zone/bot.cpp
index 01f2da41d..5ce63714c 100644
--- a/zone/bot.cpp
+++ b/zone/bot.cpp
@@ -8829,7 +8829,7 @@ void Bot::CalcItemBonuses(StatBonuses* newbon)
 		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))
 	{
 		return;
@@ -8848,12 +8848,13 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
 			return;
 	}
 
-	if(GetLevel() < item->ReqLevel)
+	if(GetLevel() < inst->GetItemRequiredLevel(true))
 	{
 		return;
 	}
 
-	if(GetLevel() >= item->RecLevel)
+	auto rec_level = isAug ? rec_override : inst->GetItemRecommendedLevel(true);
+	if(GetLevel() >= rec_level)
 	{
 		newbon->AC += item->AC;
 		newbon->HP += item->HP;
@@ -8907,55 +8908,54 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
 	else
 	{
 		int lvl = GetLevel();
-		int reclvl = item->RecLevel;
 
-		newbon->AC += CalcRecommendedLevelBonus( lvl, reclvl, item->AC );
-		newbon->HP += CalcRecommendedLevelBonus( lvl, reclvl, item->HP );
-		newbon->Mana += CalcRecommendedLevelBonus( lvl, reclvl, item->Mana );
-		newbon->Endurance += CalcRecommendedLevelBonus( lvl, reclvl, item->Endur );
-		newbon->ATK += CalcRecommendedLevelBonus( lvl, reclvl, item->Attack );
-		newbon->STR += CalcRecommendedLevelBonus( lvl, reclvl, (item->AStr + item->HeroicStr) );
-		newbon->STA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ASta + item->HeroicSta) );
-		newbon->DEX += CalcRecommendedLevelBonus( lvl, reclvl, (item->ADex + item->HeroicDex) );
-		newbon->AGI += CalcRecommendedLevelBonus( lvl, reclvl, (item->AAgi + item->HeroicAgi) );
-		newbon->INT += CalcRecommendedLevelBonus( lvl, reclvl, (item->AInt + item->HeroicInt) );
-		newbon->WIS += CalcRecommendedLevelBonus( lvl, reclvl, (item->AWis + item->HeroicWis) );
-		newbon->CHA += CalcRecommendedLevelBonus( lvl, reclvl, (item->ACha + item->HeroicCha) );
+		newbon->AC += CalcRecommendedLevelBonus( lvl, rec_level, item->AC );
+		newbon->HP += CalcRecommendedLevelBonus( lvl, rec_level, item->HP );
+		newbon->Mana += CalcRecommendedLevelBonus( lvl, rec_level, item->Mana );
+		newbon->Endurance += CalcRecommendedLevelBonus( lvl, rec_level, item->Endur );
+		newbon->ATK += CalcRecommendedLevelBonus( lvl, rec_level, item->Attack );
+		newbon->STR += CalcRecommendedLevelBonus( lvl, rec_level, (item->AStr + item->HeroicStr) );
+		newbon->STA += CalcRecommendedLevelBonus( lvl, rec_level, (item->ASta + item->HeroicSta) );
+		newbon->DEX += CalcRecommendedLevelBonus( lvl, rec_level, (item->ADex + item->HeroicDex) );
+		newbon->AGI += CalcRecommendedLevelBonus( lvl, rec_level, (item->AAgi + item->HeroicAgi) );
+		newbon->INT += CalcRecommendedLevelBonus( lvl, rec_level, (item->AInt + item->HeroicInt) );
+		newbon->WIS += CalcRecommendedLevelBonus( lvl, rec_level, (item->AWis + item->HeroicWis) );
+		newbon->CHA += CalcRecommendedLevelBonus( lvl, rec_level, (item->ACha + item->HeroicCha) );
 
-		newbon->MR += CalcRecommendedLevelBonus( lvl, reclvl, (item->MR + item->HeroicMR) );
-		newbon->FR += CalcRecommendedLevelBonus( lvl, reclvl, (item->FR + item->HeroicFR) );
-		newbon->CR += CalcRecommendedLevelBonus( lvl, reclvl, (item->CR + item->HeroicCR) );
-		newbon->PR += CalcRecommendedLevelBonus( lvl, reclvl, (item->PR + item->HeroicPR) );
-		newbon->DR += CalcRecommendedLevelBonus( lvl, reclvl, (item->DR + item->HeroicDR) );
-		newbon->Corrup += CalcRecommendedLevelBonus( lvl, reclvl, (item->SVCorruption + item->HeroicSVCorrup) );
+		newbon->MR += CalcRecommendedLevelBonus( lvl, rec_level, (item->MR + item->HeroicMR) );
+		newbon->FR += CalcRecommendedLevelBonus( lvl, rec_level, (item->FR + item->HeroicFR) );
+		newbon->CR += CalcRecommendedLevelBonus( lvl, rec_level, (item->CR + item->HeroicCR) );
+		newbon->PR += CalcRecommendedLevelBonus( lvl, rec_level, (item->PR + item->HeroicPR) );
+		newbon->DR += CalcRecommendedLevelBonus( lvl, rec_level, (item->DR + item->HeroicDR) );
+		newbon->Corrup += CalcRecommendedLevelBonus( lvl, rec_level, (item->SVCorruption + item->HeroicSVCorrup) );
 
-		newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr );
-		newbon->STACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta );
-		newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex );
-		newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi );
-		newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt );
-		newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis );
-		newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha );
-		newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR );
-		newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR );
-		newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR );
-		newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR );
-		newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR );
-		newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup );
+		newbon->STRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicStr );
+		newbon->STACapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSta );
+		newbon->DEXCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDex );
+		newbon->AGICapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicAgi );
+		newbon->INTCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicInt );
+		newbon->WISCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicWis );
+		newbon->CHACapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCha );
+		newbon->MRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicMR );
+		newbon->CRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicFR );
+		newbon->FRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCR );
+		newbon->PRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicPR );
+		newbon->DRCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDR );
+		newbon->CorrupCapMod += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSVCorrup );
 
-		newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicStr );
-		newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSta );
-		newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDex );
-		newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicAgi );
-		newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicInt );
-		newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicWis );
-		newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCha );
-		newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicMR );
-		newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicFR );
-		newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicCR );
-		newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicPR );
-		newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicDR );
-		newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, reclvl, item->HeroicSVCorrup );
+		newbon->HeroicSTR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicStr );
+		newbon->HeroicSTA += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSta );
+		newbon->HeroicDEX += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDex );
+		newbon->HeroicAGI += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicAgi );
+		newbon->HeroicINT += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicInt );
+		newbon->HeroicWIS += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicWis );
+		newbon->HeroicCHA += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCha );
+		newbon->HeroicMR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicMR );
+		newbon->HeroicFR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicFR );
+		newbon->HeroicCR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicCR );
+		newbon->HeroicPR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicPR );
+		newbon->HeroicDR += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicDR );
+		newbon->HeroicCorrup += CalcRecommendedLevelBonus( lvl, rec_level, item->HeroicSVCorrup );
 	}
 
 	//FatherNitwit: New style haste, shields, and regens
@@ -9124,10 +9124,8 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
 
 	if (!isAug)
 	{
-		int i;
-		for (i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++) {
-			AddItemBonuses(inst->GetAugment(i),newbon,true);
-		}
+		for (int i = 0; i < EmuConstants::ITEM_COMMON_SIZE; i++)
+			AddItemBonuses(inst->GetAugment(i),newbon,true, false, rec_level);
 	}
 
 }
diff --git a/zone/bot.h b/zone/bot.h
index a280a2a58..c35fd1f7b 100644
--- a/zone/bot.h
+++ b/zone/bot.h
@@ -193,7 +193,7 @@ public:
 	virtual int32 CheckAggroAmount(uint16 spellid);
 	virtual void CalcBonuses();
 	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);
 	virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
 	virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther);
diff --git a/zone/client.h b/zone/client.h
index 159f26fdb..3d86ab690 100644
--- a/zone/client.h
+++ b/zone/client.h
@@ -1275,7 +1275,7 @@ public:
 protected:
 	friend class Mob;
 	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);
 	int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
 	void CalcEdibleBonuses(StatBonuses* newbon);
diff --git a/zone/mob.cpp b/zone/mob.cpp
index d345085cb..02ecb8ef4 100644
--- a/zone/mob.cpp
+++ b/zone/mob.cpp
@@ -5681,4 +5681,170 @@ int32 Mob::GetMeleeMitigation() {
 	mitigation += itembonuses.MeleeMitigationEffect;
 	mitigation += aabonuses.MeleeMitigationEffect;
 	return mitigation;
-}
\ No newline at end of file
+}
+
+/* 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;
+}
diff --git a/zone/mob.h b/zone/mob.h
index 5d558278d..06d322d70 100644
--- a/zone/mob.h
+++ b/zone/mob.h
@@ -233,6 +233,8 @@ public:
 		int resist_override = 0, bool CharismaCheck = false, bool CharmTick = false, bool IsRoot = false,
 		int level_override = -1);
 	int ResistPhysical(int level_diff, uint8 caster_level);
+	int ResistElementalWeaponDmg(const ItemInst *item);
+	int CheckBaneDamage(const ItemInst *item);
 	uint16 GetSpecializeSkillValue(uint16 spell_id) const;
 	void SendSpellBarDisable();
 	void SendSpellBarEnable(uint16 spellid);