public Dictionary <DamageType, float> GetAutoAttackDamage(KillableUnit unit)
{
var damages = new Dictionary <DamageType, float>();
var passiveAbilities = abilities.OfType <IPassiveAbility>().Where(x => x.IsValid(Hero, unit)).ToList();
foreach (var ability in passiveAbilities)
{
var damage = ability.GetBonusDamage(Hero, unit, passiveAbilities);
if (damages.ContainsKey(ability.DamageType))
{
damages[ability.DamageType] += damage;
}
else
{
damages.Add(ability.DamageType, damage);
}
}
if (damages.ContainsKey(DamageType.Physical))
{
damages[DamageType.Physical] += AutoAttackDamage;
}
else
{
damages.Add(DamageType.Physical, AutoAttackDamage);
}
return(damages);
}
public Vector2 GetHealthBarPosition(KillableUnit unit)
{
var position = unit.HpBarPosition;
if (position.IsZero)
{
return(Vector2.Zero);
}
switch (unit.UnitType)
{
case UnitType.Creep:
case UnitType.Courier:
{
return(position + new Vector2(creepX, creepY));
}
case UnitType.Tower:
{
return(position + new Vector2(towerX, towerY));
}
default:
{
return(position);
}
}
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
return(Math.Min(Damage[Ability.Level - 1], unit.Mana) * multiplier);
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
return(Damage[Level - 1]);
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
return((float)(Damage[Level - 1] * Math.Pow(2, Math.Floor((1 - unit.HealthPercentage) / 0.2)) * reduction));
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
return(hero.IsMelee ? meleeBonus : rangedBonus);
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
return((unit.Modifiers.FirstOrDefault(x => x.Name == FurySwipesModifier)?.StackCount ?? 0) * Damage[Level - 1]);
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!CanDoDamage(hero, unit, abilities))
{
return(0);
}
var minimumDamage = hero.MinimumDamage;
return((hero.IsMelee ? minimumDamage * meleeBonus : minimumDamage *rangedBonus) - minimumDamage);
}
protected virtual bool CanDoDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!DealsDamageToAllies && unit.Team == hero.Team)
{
return(false);
}
if (!DealsDamageToTowers && unit.UnitType == UnitType.Tower)
{
return(false);
}
return(true);
}
protected virtual bool CanDoDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
if (!DealsDamageToAllies && unit.Team == hero.Team)
{
return(false);
}
if (!DealsDamageToTowers && unit.UnitType == UnitType.Tower)
{
return(false);
}
return(!abilities.Any(x => DoesNotStackWith.Contains(x.AbilityId)));
}
public Vector2 GetHealthBarSize(KillableUnit unit)
{
switch (unit.UnitType)
{
case UnitType.Creep:
{
return(unit.HpBarSize + new Vector2(CreepSizeX, CreepSizeY));
}
case UnitType.Tower:
{
return(unit.HpBarSize + new Vector2(TowerSizeX, TowerSizeY));
}
default:
{
return(unit.HpBarSize);
}
}
}
public Vector2 GetHealthBarPosition(KillableUnit unit)
{
switch (unit.UnitType)
{
case UnitType.Creep:
{
return(unit.HpBarPosition + new Vector2(CreepX, CreepY));
}
case UnitType.Tower:
{
return(unit.HpBarPosition + new Vector2(TowerX, TowerY));
}
default:
{
return(unit.HpBarPosition);
}
}
}
public override bool IsValid(Hero hero, KillableUnit unit)
{
return(base.IsValid(hero, unit) && hero.Modifiers.Any(x => x.Name == ShadowWalkModifier));
}
public override bool IsValid(Hero hero, KillableUnit unit)
{
return(base.IsValid(hero, unit) && (DealsDamageToTowers || unit.UnitType != UnitType.Tower));
}
public override bool IsValid(Hero hero, KillableUnit unit)
{
return(base.IsValid(hero, unit) && Ability.CanBeCasted());
}
public float CalculateAverageDamageOn(KillableUnit unit)
{
return(unit.Unit.DamageTaken(Unit.DamageAverage, DamageType.Physical, Unit)
* Damage.Multiplier(AttackDamageType.Siege, unit.ArmorType));
}
public virtual bool IsValid(Hero hero, KillableUnit unit)
{
return(Ability != null && Ability.IsValid && Ability.Level > 0 &&
(!IsItem || hero.Inventory.Items.Any(x => x.Handle == Ability.Handle)));
}
public IEnumerable <IActiveAbility> GetValidAbilities(KillableUnit unit)
{
return(abilities.OfType <IActiveAbility>().Where(x => x.IsValid(Hero, unit)));
}
public override float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities)
{
// fix for quell damage stacking
return(0);
}
public override bool IsValid(Hero hero, KillableUnit unit)
{
return(base.IsValid(hero, unit) && hero.HasModifier(JinguMasteryModifier));
}
public abstract float GetBonusDamage(Hero hero, KillableUnit unit, IEnumerable <IPassiveAbility> abilities);
