COMMITTED: Spell & DoT Shielding

[Caryatis]

Here is the code for spell and dot shielding separated out... Spell effect coming later.

mob.h

Index: mob.h
===================================================================
--- mob.h	(revision 1597)
+++ mob.h	(working copy)
@@ -839,7 +839,7 @@
 	inline int16	GetErrorNumber() const {return adverrorinfo;}
 
 	sint32	ReduceDamage(sint32 damage);
-	sint32  ReduceMagicalDamage(sint32 damage);
+	sint32  AffectMagicalDamage(sint32 damage, int16 spell_id, const bool iBuffTic, Mob* attacker);
 
 	virtual void DoSpecialAttackDamage(Mob *who, SkillType skill, sint32 max_damage, sint32 min_damage = 1, sint32 hate_override = -1);
     bool Flurry();

attack.cpp

Index: attack.cpp
===================================================================
--- attack.cpp	(revision 1597)
+++ attack.cpp	(working copy)
@@ -2929,13 +2929,14 @@
 	return(damage);
 }
 	
-sint32 Mob::ReduceMagicalDamage(sint32 damage) 
+sint32 Mob::AffectMagicalDamage(sint32 damage, int16 spell_id, const bool iBuffTic, Mob* attacker) 
 {
-	if(damage <= 0 || (!HasSpellRune() && !HasPartialSpellRune()))
+	if(damage <= 0)
 	{
 		return damage;
 	}
 
+	// See if we block the spell outright first
 	int slot = GetBuffSlotFromType(SE_NegateAttacks);
 	if(slot >= 0 && buffs[slot].magic_rune > 0)
 	{
@@ -2946,55 +2947,67 @@
 		}
 		return -6;
 	}
-
-	slot = GetBuffSlotFromType(SE_MitigateSpellDamage);
-	if(slot >= 0)
+	
+	// If this is a DoT, use DoT Shielding...
+	if(iBuffTic)
 	{
-		int damage_to_reduce = damage * GetPartialMagicRuneReduction(buffs[slot].spellid) / 100;
-		if(damage_to_reduce > buffs[slot].magic_rune)
+		damage -= (damage * this->itembonuses.DoTShielding / 100);
+	}
+	// This must be a DD then so lets apply Spell Shielding and runes.
+	else 
+	{
+		// Reduce damage by the Spell Shielding first so that the runes don't take the raw damage.
+		damage -= (damage * this->itembonuses.SpellDamageShield / 100);
+	
+		// Do runes now.
+		slot = GetBuffSlotFromType(SE_MitigateSpellDamage);
+		if(slot >= 0)
 		{
-			mlog(SPELLS__EFFECT_VALUES, "Mob::ReduceDamage SE_MitigateSpellDamage %d damage negated, %d"
-				" damage remaining, fading buff.", damage_to_reduce, buffs[slot].magic_rune);
-			damage -= damage_to_reduce;
-			BuffFadeBySlot(slot);
-			UpdateRuneFlags();
+			int damage_to_reduce = damage * GetPartialMagicRuneReduction(buffs[slot].spellid) / 100;
+			if(damage_to_reduce > buffs[slot].magic_rune)
+			{
+				mlog(SPELLS__EFFECT_VALUES, "Mob::ReduceDamage SE_MitigateSpellDamage %d damage negated, %d"
+					" damage remaining, fading buff.", damage_to_reduce, buffs[slot].magic_rune);
+				damage -= damage_to_reduce;
+				BuffFadeBySlot(slot);
+				UpdateRuneFlags();
+			}
+			else
+			{
+				mlog(SPELLS__EFFECT_VALUES, "Mob::ReduceDamage SE_MitigateMeleeDamage %d damage negated, %d"
+					" damage remaining.", damage_to_reduce, buffs[slot].magic_rune);
+				buffs[slot].magic_rune = (buffs[slot].magic_rune - damage_to_reduce);
+				damage -= damage_to_reduce;
+			}
 		}
-		else
+
+		if(damage < 1)
 		{
-			mlog(SPELLS__EFFECT_VALUES, "Mob::ReduceDamage SE_MitigateMeleeDamage %d damage negated, %d"
-				" damage remaining.", damage_to_reduce, buffs[slot].magic_rune);
-			buffs[slot].magic_rune = (buffs[slot].magic_rune - damage_to_reduce);
-			damage -= damage_to_reduce;
+			return -6;
 		}
-	}
 
-	if(damage < 1)
-	{
-		return -6;
-	}
-
-	slot = GetBuffSlotFromType(SE_AbsorbMagicAtt);
-	while(slot >= 0)
-	{
-		int16 magic_rune_left = buffs[slot].magic_rune;
-		if(magic_rune_left >= damage)
+		slot = GetBuffSlotFromType(SE_AbsorbMagicAtt);
+		while(slot >= 0)
 		{
-			magic_rune_left -= damage;
-			damage = 0;
-			buffs[slot].magic_rune = magic_rune_left;
-			break;
+			int16 magic_rune_left = buffs[slot].magic_rune;
+			if(magic_rune_left >= damage)
+			{
+				magic_rune_left -= damage;
+				damage = 0;
+				buffs[slot].magic_rune = magic_rune_left;
+				break;
+			}
+			else
+			{
+				if(magic_rune_left > 0)
+					damage -= magic_rune_left;
+				BuffFadeBySlot(slot);
+				slot = GetBuffSlotFromType(SE_AbsorbMagicAtt);
+				UpdateRuneFlags();
+			}
 		}
-		else
-		{
-			if(magic_rune_left > 0)
-				damage -= magic_rune_left;
-			BuffFadeBySlot(slot);
-			slot = GetBuffSlotFromType(SE_AbsorbMagicAtt);
-			UpdateRuneFlags();
-		}
 	}
-
-	return(damage);
+	return damage;
 }
 
 bool Mob::HasProcs() const
@@ -3159,7 +3172,7 @@
 			mlog(COMBAT__HITS, "Melee Damage reduced to %d", damage);
 		} else {
 			sint32 origdmg = damage;
-			damage = ReduceMagicalDamage(damage);
+			damage = AffectMagicalDamage(damage, spell_id, iBuffTic, attacker);
 			mlog(COMBAT__HITS, "Melee Damage reduced to %d", damage);
 			if (origdmg != damage && attacker && attacker->IsClient()) {
 				if(attacker->CastToClient()->GetFilter(FILTER_DAMAGESHIELD) != FilterHide)

[Caryatis]

OK think this is pretty solid now, its pretty annoying to test but I tested every possible combination and seems working good. The only minor thing is that if you have a DoT spell that has a DD component, the DD won't be affected by the vulnerability(the DoT will be so I'm not sure how vital it is).

mob.h

Index: mob.h
===================================================================
--- mob.h	(revision 1597)
+++ mob.h	(working copy)
@@ -87,6 +87,7 @@
 	focusResistRate,
 	focusSpellHateMod,
 	focusTriggerOnCast,
+	focusSpellVulnerability,
 } focusType;
 
 enum {
@@ -778,6 +779,7 @@
 	bool TryDeathSave();
 	void DoBuffWearOffEffect(uint32 index);
 	void TryTriggerOnCast(Mob *target, uint32 spell_id);
+	sint32 GetVulnerability(sint32 damage, Mob *caster, uint32 spell_id, int32 ticsremaining);
 
 	static int32 GetAppearanceValue(EmuAppearance iAppearance);
 	void SendAppearancePacket(int32 type, int32 value, bool WholeZone = true, bool iIgnoreSelf = false, Client *specific_target=NULL);

mob.cpp

Index: mob.cpp
===================================================================
--- mob.cpp	(revision 1597)
+++ mob.cpp	(working copy)
@@ -3036,4 +3036,88 @@
 			}
 		}
 	}
+}
+
+sint32 Mob::GetVulnerability(sint32 damage, Mob *caster, uint32 spell_id, int32 ticsremaining)
+{
+	// If we increased the datatype on GetBuffSlotFromType, this wouldnt be needed
+	uint32 buff_count = GetMaxTotalSlots();
+	for(int i = 0; i < buff_count; i++) 
+	{
+		if(IsEffectInSpell(buffs[i].spellid, SE_SpellVulnerability))
+		{
+			// For Clients, Pets and Bots that are casting the spell, see if the vulnerability affects their spell.
+			if(!caster->IsNPC())
+			{
+				sint32 focus = caster->CalcFocusEffect(focusSpellVulnerability, buffs[i].spellid, spell_id);
+				if(focus == 1)
+				{
+					damage += damage * spells[buffs[i].spellid].base[0] / 100;
+					break;
+				}
+			}
+			// If an NPC is casting the spell on a player that has a vulnerability, relaxed restrictions on focus 
+			// so that either the Client is vulnerable to DoTs or DDs of various resists or all.
+			else if (caster->IsNPC())
+			{
+				int npc_resist = 0;
+				int npc_instant = 0;
+				int npc_duration = 0;
+				for(int j = 0; j < EFFECT_COUNT; j++)
+				{
+					switch (spells[buffs[i].spellid].effectid[j]) 
+					{
+					
+					case SE_Blank:
+						break;
+
+					case SE_LimitResist:
+						if(spells[buffs[i].spellid].base[j])
+						{
+							if(spells[spell_id].resisttype == spells[buffs[i].spellid].base[j])
+								npc_resist = 1;
+						}
+						break;
+
+					case SE_LimitInstant:
+						if(!ticsremaining) 
+						{
+							npc_instant = 1;
+							break;
+						}
+
+					case SE_LimitMinDur:
+						if(ticsremaining) 
+						{
+							npc_duration = 1;
+							break;
+						}
+
+						default:{
+						// look pretty
+							break;
+						}	
+					}
+				}
+				// DDs and Dots of all resists 
+				if ((npc_instant) || (npc_duration)) 
+					damage += damage * spells[buffs[i].spellid].base[0] / 100;
+				
+				else if (npc_resist) 
+				{
+					// DDs and Dots restricted by resists
+					if ((npc_instant) || (npc_duration)) 
+					{
+						damage += damage * spells[buffs[i].spellid].base[0] / 100;
+					}
+					// DD and Dots of 1 resist ... these are to maintain compatibility with current spells, not ideal.
+					else if (!npc_instant && !npc_duration)
+					{
+						damage += damage * spells[buffs[i].spellid].base[0] / 100;
+					}
+				}
+			}
+		}
+	}
+	return damage;
 }
\ No newline at end of file

spell effects.cpp

Index: spell_effects.cpp
===================================================================
--- spell_effects.cpp	(revision 1597)
+++ spell_effects.cpp	(working copy)
@@ -203,8 +203,10 @@
 
 					//handles AAs and what not...
 					if(caster)
+					{
+						dmg = GetVulnerability(dmg, caster, spell_id, 0);
 						dmg = caster->GetActSpellDamage(spell_id, dmg);
-
+					}
 					dmg = -dmg;
 					Damage(caster, dmg, spell_id, spell.skill, false, buffslot, false);
 				}
@@ -2812,6 +2814,7 @@
 			case SE_LimitCastTime:
 			case SE_NoCombatSkills:
 			case SE_TriggerOnCast:
+			case SE_SpellVulnerability:
 			{
 				break;
 			}
@@ -3130,13 +3133,15 @@
 						if(!IsClient())
 							AddToHateList(caster, -effect_value);
 					}
-
+					effect_value = GetVulnerability(effect_value, caster, spell_id, ticsremaining);
 					TryDotCritical(spell_id, caster, effect_value);
 				}
 				effect_value = effect_value * modifier / 100;
 			}
 
 			if(effect_value < 0) {
+				if(caster && !caster->IsClient())
+					effect_value = GetVulnerability(effect_value, caster, spell_id, ticsremaining);
 				effect_value = -effect_value;
 				Damage(caster, effect_value, spell_id, spell.skill, false, i, true);
 			} else if(effect_value > 0) {
@@ -3860,6 +3865,14 @@
 			}
 			break;
 		}
+		case SE_SpellVulnerability:
+		{
+			if(type == focusSpellVulnerability)
+			{
+				value = 1;
+			}
+			break;
+		}
 #if EQDEBUG >= 6
 		//this spits up a lot of garbage when calculating spell focuses
 		//since they have all kinds of extra effects on them.