public virtual float Call(Character caster, Character other,
                   DamageType damageType, float value)
 {
     if(caster == null)
         return value;
     return effect(caster, other, damageType, value);
 }

 public Weapon(int mDmg, float dmgV, float mRange, DamageType dt)
 {
     _maxDamage = mDmg;
     _dmgVar = dmgV;
     _maxRange = mRange;
     _dmgType = dt;
 }

 public Weapon(int maxDmg, float dmgVar, float maxRange, DamageType dmgType)
 {
     _maxDamage = maxDmg;
     _damageVariance = dmgVar;
     _maxRange = maxRange;
     _dmgType = dmgType;
 }

 public void SetArmorValue(DamageType damType, int value)
 {
     if (armorStats.ContainsKey(damType))
         armorStats[damType] = value;
     else
         armorStats.Add(damType, value);
 }

        public static Obj_AI_Minion GetMinionTarget(float range, DamageType damagetype, bool isSkillShot = false, bool isAlly = false, bool isMonster = false, float ksdamage = -1)
        {

            var teamtype = EntityManager.UnitTeam.Enemy;
            if (isAlly)
                teamtype = EntityManager.UnitTeam.Ally;
            var miniontype = EntityManager.MinionsAndMonsters.GetLaneMinions(teamtype, Champion.ServerPosition, range).ToArray();
            if (isMonster)
                miniontype = EntityManager.MinionsAndMonsters.GetJungleMonsters(Champion.ServerPosition, range).ToArray();

            // Check list objects
            if (miniontype.Length == 0) return null;

            var target = miniontype
                .OrderByDescending(a => a.HealthPercent)
                .FirstOrDefault(a => a.IsValidTarget(range) && ((isAlly && a.IsAlly) || (!isAlly && a.IsEnemy))
                                     && ((isMonster && a.IsMonster) || (!isMonster && !a.IsMonster))
                                     && !a.IsDead && !a.IsZombie
                                     && TargetStatus(a)
                                     && (!isSkillShot || WillQHitEnemy(a))
                                     && ((ksdamage > -1 && a.Health <= Champion.CalculateDamageOnUnit(a, damagetype, ksdamage)) || ksdamage == -1)
                                     && !Champion.IsRecalling()
                                     && a.Distance(Champion) <= range);
            return target;
        }

 public Weapon()
 {
     this.id = -1;
     this.name = "Empty Handed";
     this.Equippable = false;
     this.weight = 0;
     this.value = 0;
     this.speed = 0;
     this.speedbonus = 0;
     this.strengthbonus = 0;
     this.hpbonus = 0;
     this.damage = 0;
     this.type = ItemType.Weapon;
     this.damageType = DamageType.Crushing;
     protection = new Dictionary<DamageType, int>();
     foreach (DamageType type in Enum.GetValues(typeof(DamageType)))
     {
         protection[type] = 0;
     }
     bonus = new Dictionary<Stat, int>();
     foreach (Stat stat in Enum.GetValues(typeof(Stat)))
     {
         bonus[stat] = 0;
     }
 }

	/// <summary>
	/// 
	/// </summary>
	public vp_DamageInfo(float damage, Transform source, Transform originalSource, DamageType type = DamageType.Unknown)
	{
		Damage = damage;
		Source = source;
		OriginalSource = originalSource;
		Type = type;
	}

 public Weapon()
 {
     _maxDamage = 0;
     _dmgVar = 0;
     _maxRange  = 0;
     _dmgType = DamageType.Heavy;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="PlatformerPro.DamageInfo"/> class.
 /// </summary>
 /// <param name="amount">Amount.</param>
 /// <param name="damageType">Damage type.</param>
 /// <param name="direction">Direction.</param>
 public DamageInfo(int amount, DamageType damageType, Vector2 direction, IMob damageCauser)
 {
     Amount = amount;
     DamageType = damageType;
     Direction = direction;
     DamageCauser = damageCauser;
 }

 public DamageHistoryItem(Entity damager, int amount, DamageType damType)
 {
     Damager = damager;
     Amount = amount;
     DamType = damType;
     When = DateTime.Now;
 }

        private static float GetCalculatedDamage(Obj_AI_Base target, DamageType type, float rawdamage)
        {
            var damage = 0f;
            damage += target.CalculateDamageOnUnit(target, type, rawdamage);

            return damage;
        }

 public RangedAttackSkill(int entityId, int level, DamageType damageType, string textureResourceId = "ranged_attack_skill_icon")
     : base(SkillType.RangedAttack, entityId, level, true, false)
 {
     _range = 8f;
     _damageType = damageType;
     _textureResourceId = textureResourceId;
 }

 public Damage(DamageType type, int value, int armorPenetration, int shieldPenetration)
 {
     this.type = type;
     this.value = value;
     this.armorPenetration = armorPenetration;
     this.shieldPenetration = shieldPenetration;
 }

        public override void OnDamage(float damage, DamageType type)
        {
            Debug.DrawText(string.Format("Took {0} points of {1} damage", damage, type), 3, Color.White, 3);

            if(OnDamaged != null)
                OnDamaged(damage, type);
        }

 public override float Call(Character caster, Character other,
                   DamageType damageType, float value)
 {
     var ae = generateEffect(caster, other, damageType, value, duration,
                             repeats, startEffect, endEffect);
     return ae.EffectStart();
 }

        private static void AddPassiveAttack(
            string championName,
            Func<AIHeroClient, Obj_AI_Base, bool> condition,
            DamageType damageType,
            Func<AIHeroClient, Obj_AI_Base, double> func,
            bool ignoreCalculation = false,
            bool @override = false)
        {
            var passive = new PassiveDamage
            {
                Condition = condition,
                Func = func,
                DamageType = damageType,
                Override = @override,
                IgnoreCalculation = ignoreCalculation
            };

            if (PassiveDamages.ContainsKey(championName))
            {
                PassiveDamages[championName].Add(passive);
                return;
            }

            PassiveDamages.Add(championName, new List<PassiveDamage> { passive });
        }

 public static bool Check(Obj_AI_Hero target, DamageType damageType = DamageType.True, bool ignoreShields = true)
 {
     if (target.HasBuffOfType(BuffType.Invulnerability) || target.IsInvulnerable)
     {
         return true;
     }
     foreach (var invulnerable in Items)
     {
         if (invulnerable.Champion == null || invulnerable.Champion == target.ChampionName)
         {
             if (invulnerable.DamageType == null || invulnerable.DamageType == damageType)
             {
                 if (!ignoreShields && invulnerable.IsShield && target.HasBuff(invulnerable.BuffName))
                 {
                     return true;
                 }
                 if (invulnerable.CustomCheck != null && CustomCheck(invulnerable, target, damageType))
                 {
                     return true;
                 }
             }
         }
     }
     return false;
 }

    /// <summary>
    /// Applies explosion damage to a list of found colliders, but makes sure to apply damage only once to the same gameobject.
    /// </summary>
    /// <param name="colliders"></param>
    /// <param name="amount"></param>
    /// <param name="damageType"></param>
    /// <param name="inflictor"></param>
    public static void ApplyExplosionDamage(Collider[] colliders, int amount, DamageType damageType = DamageType.Explosion, GameObject inflictor = null)
    {
        List<GameObject> seen = new List<GameObject>();
        DamageData dm = new DamageData(amount, damageType, inflictor);
        IDamagable[] damagables;
        IDamagable[] rigidBodyDamagables;

        foreach (Collider coll in colliders)
        {
            if (seen.Contains(coll.gameObject))
                continue;

            seen.Add(coll.gameObject); // avoid applying damage twice to the IDamagable components on the same game object

            damagables = coll.GetComponents(typeof (IDamagable)).Cast<IDamagable>().ToArray();
            Array.ForEach(damagables, damagable => damagable.TakeDamage(dm)); ;

            // Also apply damage to rigidbody of this collider, but only if they're different gameobjects (otherwise we already did)
            if (coll.attachedRigidbody != null && !seen.Contains(coll.attachedRigidbody.gameObject))
            {
                seen.Add(coll.attachedRigidbody.gameObject);

                rigidBodyDamagables = coll.attachedRigidbody.GetComponents(typeof(IDamagable)).Cast<IDamagable>().ToArray();
                Array.ForEach(rigidBodyDamagables, damagable => damagable.TakeDamage(dm));
            }
        }
    }

 public Item(
     string itemName = "Default",
     ItemType itemType = ItemType.None,
     StatSystem itemStats = null,
     DamageType damageType = DamageType.None,
     AmmoType itemShoots = AmmoType.None,
     ItemQuality itemQuality = ItemQuality.None,
     double value = 0.0,
     int x = 0,
     int y = 0,
     int quantity = 1)
 {
     if (itemStats != null)
     {
         Stats = itemStats;
     }
     else
     {
         Stats = new StatSystem();
     }
     Name = itemName;
     type = itemType;
     ammo = itemShoots;
     Count = quantity;
     Quality = itemQuality;
     damage = damageType;
     Value = value;
     MapX = x;
     MapY = y;
 }

 public static bool Check(Obj_AI_Hero target, DamageType damageType = DamageType.True, bool ignoreShields = true)
 {
     try
     {
         if (target.HasBuffOfType(BuffType.Invulnerability) || target.IsInvulnerable)
         {
             return true;
         }
         foreach (var invulnerable in Items)
         {
             if (invulnerable.Champion == null || invulnerable.Champion == target.ChampionName)
             {
                 if (invulnerable.DamageType == null || invulnerable.DamageType == damageType)
                 {
                     if (!ignoreShields && invulnerable.IsShield && target.HasBuff(invulnerable.BuffName))
                     {
                         return true;
                     }
                     if (invulnerable.CustomCheck != null)
                     {
                         return CustomCheck(invulnerable, target, damageType);
                     }
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
     return false;
 }