protected internal override void ModDamageDoneFactorSilently(DamageSchool school, float delta)
		{
			if (m_damageDoneFactors == null)
			{
				m_damageDoneFactors = new float[(int)DamageSchool.Count];
			}
			m_damageDoneFactors[(int)school] += delta;
		}

		public override float GetDamageDoneFactor(DamageSchool school)
		{
			if (m_damageDoneFactors == null)
			{
				return 1;
			}
			return 1 + m_damageDoneFactors[(int)school];
		}

		/// <summary>
		/// Modifies the damage for the given school by the given delta.
        /// Requires a call to <see cref="WCell.RealmServer.Modifiers.UnitUpdates.UpdateAllDamages"/> afterwards.
		/// </summary>
		/// <param name="school"></param>
		/// <param name="delta"></param>
		protected internal override void RemoveDamageDoneModSilently(DamageSchool school, int delta)
		{
			if (m_damageDoneMods == null)
			{
				return;
			}
			m_damageDoneMods[(int)school] -= delta;
		}

		/// <summary>
		/// Modifies the damage for the given school by the given delta.
        /// Requires a call to <see cref="WCell.RealmServer.Modifiers.UnitUpdates.UpdateAllDamages"/> afterwards.
		/// </summary>
		/// <param name="school"></param>
		/// <param name="delta"></param>
		protected internal override void AddDamageDoneModSilently(DamageSchool school, int delta)
		{
			if (m_damageDoneMods == null)
			{
				m_damageDoneMods = new int[(int)DamageSchool.Count];
			}
			m_damageDoneMods[(int)school] += delta;
		}

		public override int GetDamageDoneMod(DamageSchool school)
		{
			var amount = 0;

			if (IsHunterPet && m_master != null)
			{
				if (school != DamageSchool.Physical)
				{
					// "0.13% spell damage (0.18 spell damage with 2/2 Wild Hunt)"	
					var bonus = m_master.GetDamageDoneMod(school);
					amount += (bonus * PetMgr.PetSpellDamageOfOwnerPercent + 50) / 100;	 // rounding
				}
			}
			if (m_damageDoneMods != null)
			{
				amount += m_damageDoneMods[(int)school];
			}
			return amount;
		}

 public override float GetCritChance(DamageSchool school)
 {
     var value = m_entry.Rank > CreatureRank.Normal ? BossSpellCritChance : 0;
     if (m_CritMods != null)
     {
         value += m_CritMods[(int)school];
     }
     return value;
 }

 public int CalcPowerCost(Unit caster, DamageSchool school)
 {
     return caster.GetPowerCost(school, this, CalcBasePowerCost(caster));
 }

		public void SetResistance(DamageSchool school, int value)
		{
			Resistances[(uint)school] = value;
		}

		public int GetResistance(DamageSchool school)
		{
			if (Resistances == null)
			{
				return 0;
			}
			return Resistances.Get((uint)school);
		}

		/// <summary>
		/// Tries to consume the given amount of Power, also considers modifiers to Power-cost.
		/// </summary>
		public bool ConsumePower(DamageSchool type, Spell spell, int neededPower)
		{
			neededPower = GetPowerCost(type, spell, neededPower);

			if (Power >= neededPower)
			{
				Power -= neededPower;
				return true;
			}

			return false;
		}

		public void ModDamageTakenPctMod(DamageSchool[] schools, int delta)
		{
			if (m_damageTakenPctMods == null)
			{
				m_damageTakenPctMods = CreateDamageSchoolArr();
			}

			foreach (var school in schools)
			{
				m_damageTakenPctMods[(int)school] += delta;
			}
		}

		/// <summary>
		/// Threat mod in percent
		/// </summary>
		public virtual int GetGeneratedThreat(int dmg, DamageSchool school, SpellEffect effect)
		{
			if (m_threatMods == null)
			{
				return dmg;
			}
			return dmg + ((dmg * m_threatMods[(int)school]) / 100);
		}

		/// <summary>
		/// Returns the modified power-cost needed to cast a Spell of the given DamageSchool 
		/// and the given base amount of power required
		/// </summary>
		public virtual int GetPowerCost(DamageSchool school, Spell spell, int cost)
		{
			int modifier = PowerCostModifier;
			if (m_schoolPowerCostMods != null)
			{
				modifier += m_schoolPowerCostMods[(int)school];
			}

			cost += modifier;

			cost = (int)(Math.Round(PowerCostMultiplier) * cost);
			return cost;
		}

		//public void ModDebuffResistance(DamageTypeMask schools, float delta)
		//{
		//    foreach (var school in UnitMechanics.DamageTypeMasks) {
		//        if ((schools & school) != 0) {
		//            ModDebuffResistance(UnitMechanics.DamageTypeLookup[school], delta);
		//        }
		//    }
		//}
		#endregion

		#region Target Resistances
		public int GetTargetResistanceMod(DamageSchool school)
		{
			if (m_TargetResMods == null)
			{
				return 0;
			}
			return m_TargetResMods[(int)school];
		}

		/// <summary>
		/// Indicates whether the owner is immune against the given DamageSchool
		/// </summary>
		public bool IsImmune(DamageSchool school)
		{
			return m_dmgImmunities != null && m_dmgImmunities[(int)school] > 0;
		}

		public void ModDebuffResistance(DamageSchool school, int delta)
		{
			if (m_debuffResistances == null)
			{
				m_debuffResistances = CreateDamageSchoolArr();
			}
			m_debuffResistances[(int)school] += delta;
		}

		public void SetDebuffResistance(DamageSchool school, int value)
		{
			if (m_debuffResistances == null)
			{
				m_debuffResistances = CreateDamageSchoolArr();
			}
			m_debuffResistances[(uint)school] = value;
		}

		public int GetDebuffResistance(DamageSchool school)
		{
			if (m_debuffResistances == null)
			{
				return 0;
			}
			return m_debuffResistances[(int)school];
		}

		/// <summary>
		/// Decreases immunity-count against given damage-school
		/// </summary>
		public void DecDmgImmunityCount(DamageSchool school)
		{
			if (m_dmgImmunities == null)
			{
				return;
			}
			int val = m_dmgImmunities[(int)school];
			if (val > 0)
			{
				m_dmgImmunities[(int)school]--;
			}
		}

		/// <summary>
		/// Adds immunity against given damage-school
		/// </summary>
		public void IncDmgImmunityCount(DamageSchool school)
		{
			if (m_dmgImmunities == null)
			{
				m_dmgImmunities = CreateDamageSchoolArr();
			}
			var val = m_dmgImmunities[(int)school];

			if (val == 0)
			{
				// new immunity: Gets rid of all Auras that use this school
				Auras.RemoveWhere(aura => aura.Spell.SchoolMask.HasAnyFlag((DamageSchoolMask)(1 << (int)school)));
			}

			m_dmgImmunities[(int)school]++;
		}