public static double GetItemDamage(this Obj_AI_Hero source, uint itemID, Obj_AI_Hero target) { if (!source.HasItem(itemID) || !source.CanUseItem(itemID) || source.IsDead || target == null || !target.IsValidTarget()) { return(0d); } switch (itemID) { case 3153: //BladeoftheRuinedKing 破败 return(source.CalculateDamage(target, DamageType.Magical, 100)); case 3030: //HextechGLP800 冰冻枪 var GLP800DMG = 100 + source.Level * 5.5 + 0.35 * source.FlatMagicDamageMod + 1; return(source.CalculateDamage(target, DamageType.Magical, GLP800DMG)); case 3144: //BilgewaterCutlass 比尔沃特吉弯刀 return(source.CalculateDamage(target, DamageType.Magical, 100)); case 3146: //HextechGunblade 科技枪 var HexGunDMG = 175 + source.Level * 4.1 + 0.30 * source.FlatMagicDamageMod + 1; return(source.CalculateDamage(target, DamageType.Magical, HexGunDMG)); case 3152: //HextechProtobelt01 推推棒 var HexProDMG = 150 + 0.25 * source.FlatMagicDamageMod; return(source.CalculateDamage(target, DamageType.Magical, HexProDMG)); default: return(0d); } }
private static double Qdmg(Obj_AI_Base enemy) { if (Spells.Q.Ready) { return(Player.CalculateDamage(enemy, DamageType.Physical, (float)new double[] { 0.5, 0.55, 0.6, 0.65, 0.7 }[Player.SpellBook.GetSpell(SpellSlot.Q).Level] +Player.TotalAttackDamage)); } return(0); }
private static double Qdmg(Obj_AI_Base enemy) { if (Spells.Q.Ready) { var level = Player.SpellBook.GetSpell(SpellSlot.Q).Level; return(Player.CalculateDamage(enemy, DamageType.Physical, (0.45 + 0.05 * level + Player.TotalAttackDamage))); } return(0); }
public static float RDamage(Obj_AI_Base target) { if (target.HasBuff("garenpassiveenemytarget")) { return((float)_player.CalculateDamage(target, DamageType.True, Damage.GetSpellDamage(_player, target, SpellSlot.R))); } return((float)_player.CalculateDamage(target, DamageType.Magical, Damage.GetSpellDamage(_player, target, SpellSlot.R))); }
public static float SmiteDamage(Obj_AI_Base target) { float damage = new float[] { 390, 410, 430, 450, 480, 510, 540, 570, 600, 640, 680, 720, 760, 800, 850, 900, 950, 1000 }[_player.Level - 1]; return((float)_player.CalculateDamage(target, DamageType.True, damage)); }
private static double Qdmg(Obj_AI_Base enemy) { var level = Player.SpellBook.GetSpell(SpellSlot.Q).Level; if (Spells.Q.Ready) { return(Player.CalculateDamage(enemy, DamageType.Magical, 50 + 30 * level + 0.55 * Player.TotalAbilityDamage)); } return(0); }
private static double Edmg(Obj_AI_Base enemy) { if (Spells.E.Ready) { var level = Player.SpellBook.GetSpell(SpellSlot.E).Level; var BaseDamage = Player.CalculateDamage(enemy, DamageType.Physical, 5 + 15 * level); var StackDamage = Player.CalculateDamage(enemy, DamageType.Physical, 10 + 5 * level + 0.25 * (Player.TotalAttackDamage - Player.BaseAttackDamage) + 0.2 * Player.TotalAbilityDamage); return(BaseDamage + StackDamage * enemy.GetBuffCount("TwitchDeadlyVenom")); } return(0); }
public static double GetUltTickDamage(Obj_AI_Base target) { double dmg = 0; var ultLevel = Player.SpellBook.GetSpell(SpellSlot.R).Level; dmg = ((100 * ultLevel) + 50) * 3; dmg += Player.TotalAbilityDamage * 0.6; dmg = Player.CalculateDamage(target, DamageType.Magical, dmg); return(dmg); }
public static int GetCustomDamage(this Obj_AI_Hero source, string auraname, Obj_AI_Hero target) { if (auraname == "sheen") { return ((int) source.CalculateDamage(target, DamageType.Physical, 1.0 * source.FlatPhysicalDamageMod + source.BaseAttackDamage)); } if (auraname == "lichbane") { return ((int) source.CalculateDamage(target, DamageType.Magical, (0.75 * source.FlatPhysicalDamageMod + source.BaseAttackDamage) + (0.50 * source.FlatMagicDamageMod))); } return(0); }
private static double Rdmg(Obj_AI_Base enemy) { if (Spells.R.Ready) { var DamagePerSphere = Player.CalculateDamage(enemy, DamageType.Magical, 45 + 45 * Player.SpellBook.GetSpell(SpellSlot.R).Level); var Spheres = GameObjects.AllGameObjects.Where(x => x.Name == "Seed" && x.IsValid && !x.IsDead && x.Distance(Player) <= Spells.R.Range).ToList(); foreach (var number in Spheres) { ; } return(DamagePerSphere * 3 + DamagePerSphere * Spheres.Count); } return(0); }
/// <summary> /// Gets the damage of an Item. /// </summary> /// <param name="source"><see cref="Obj_AI_Base" /> where the damage is coming from.</param> /// <param name="target"><see cref="Obj_AI_Base" /> where the damage is going to.</param> /// <param name="damageItem">Item</param> /// <returns>Damage of the item.</returns> public static double GetItemDamage(this Obj_AI_Hero source, Obj_AI_Base target, DamageItems damageItem) { switch (damageItem) { case DamageItems.BilgewaterCutlass: return(source.CalculateDamage(target, DamageType.Magical, 100)); case DamageItems.BlackFireTorch: return(source.CalculateDamage(target, DamageType.Magical, target.MaxHealth * 0.2)); case DamageItems.BladeOfTheRuinedKing: return(source.CalculateDamage(target, DamageType.Physical, target.MaxHealth * 0.1)); case DamageItems.FrostQueenClaim: return(source.CalculateDamage(target, DamageType.Magical, 50 + 5 * source.Level)); case DamageItems.HextechGunblade: return(source.CalculateDamage(target, DamageType.Magical, 150 + 0.4 * source.FlatMagicDamageMod)); case DamageItems.RavenousHydra: return(source.CalculateDamage( target, DamageType.Physical, source.BaseAttackDamage + source.FlatPhysicalDamageMod)); case DamageItems.OdynsVeil: return(source.CalculateDamage(target, DamageType.Magical, 200)); case DamageItems.Tiamat: return(source.CalculateDamage( target, DamageType.Physical, source.BaseAttackDamage + source.FlatPhysicalDamageMod)); case DamageItems.LiandrysTorment: var d = target.Health * .2f * 3f; return((target.CanMove || target.HasBuffOfType(BuffType.Slow)) ? d : d * 2); } return(0d); }
static void TotalActiveDamage() { bool hasCutlass = Menus._menu["offensive"]["cutlass"].Enabled && _player.HasAndCanUseItem(ItemId.BilgewaterCutlass); bool hasBotrk = Menus._menu["offensive"]["botrk"].Enabled && _player.HasAndCanUseItem(ItemId.BladeoftheRuinedKing); bool hasGunblade = Menus._menu["offensive"]["gunblade"].Enabled && _player.HasAndCanUseItem(ItemId.HextechGunblade); bool hasTiamat = Menus._menu["offensive"]["tiamat"].Enabled && _player.HasAndCanUseItem(ItemId.Tiamat); bool hasRavenous = Menus._menu["offensive"]["ravenous"].Enabled && _player.HasAndCanUseItem(ItemId.RavenousHydra); if (hasCutlass || hasBotrk || hasGunblade || hasTiamat || hasRavenous) { _target = GameObjects.EnemyHeroes .OrderBy(a => a.Health) .Where(a => a.IsLegitimate()) .FirstOrDefault(); } if (_target != null) { if (hasTiamat || hasRavenous) { if (_target.IsInRange(250)) { _totalDamage += (float)_player.CalculateDamage(_target, DamageType.Physical, (_player.TotalAttackDamage)); if (hasTiamat) { useTiamat = true; } else if (hasRavenous) { useRavenous = true; } } else if (_target.IsInRange(400)) { _totalDamage += (float)_player.CalculateDamage(_target, DamageType.Physical, (_player.TotalAttackDamage * 0.6)); if (hasTiamat) { useTiamat = true; } else if (hasRavenous) { useRavenous = true; } } } if (_target.IsInRange(550)) { if (hasCutlass) { _totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, 100); useCutlass = true; } if (hasBotrk) { _totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, 100); useBotrk = true; } } if (_target.IsInRange(700) && hasGunblade) { float damage = new float[] { 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 220, 225, 230, 235, 240, 245, 250 }[_player.Level - 1]; damage += _player.TotalAbilityDamage * 0.3f; _totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, damage); useGunblade = true; } } }
/// <summary> /// Gets the spell damage. /// </summary> /// <param name="source">The source.</param> /// <param name="target">The target.</param> /// <param name="spellSlot">The spell slot.</param> /// <param name="stage">The stage.</param> /// <returns>System.Double.</returns> public static double GetSpellDamage( this Obj_AI_Hero source, Obj_AI_Base target, SpellSlot spellSlot, DamageStage stage = DamageStage.Default) { if (source == null || !source.IsValid || target == null || !target.IsValid) { return(0); } if (!DamageLibrary.Damages.TryGetValue(source.ChampionName, out ChampionDamage value)) { return(0); } var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData; if (spellData == null) { return(0); } var scaleSlot = spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot; var spellLevel = source.SpellBook.GetSpell(scaleSlot).Level; if (spellLevel == 0) { return(0); } var alreadyAdd1 = false; var targetHero = target as Obj_AI_Hero; var targetMinion = target as Obj_AI_Minion; var dmgBase = 0d; var dmgBonus = 0d; var dmgPassive = 0d; var dmgReduce = 1d; if (spellData.DamagesPerLvl?.Count > 0) { dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)]; } else if (spellData.Damages?.Count > 0) { dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]; if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var scalingTarget = spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target; var buffCount = scalingTarget.GetRealBuffCount(spellData.ScalingBuff); dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0; } } if (dmgBase > 0) { if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0) { dmgBase += spellData.BonusDamageOnMinion[Math.Min( spellLevel - 1, spellData.BonusDamageOnMinion.Count - 1)]; } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single) { alreadyAdd1 = true; } dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase); } if (spellData.BonusDamages?.Count > 0) { foreach (var bonusDmg in spellData.BonusDamages) { var dmg = source.GetBonusSpellDamage(target, bonusDmg, spellLevel - 1); if (dmg <= 0) { continue; } if (!alreadyAdd1 && (spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single)) { alreadyAdd1 = true; } dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg); } } var totalDamage = dmgBase + dmgBonus; if (totalDamage > 0) { if (spellData.ScalePerCritPercent > 0) { totalDamage *= source.Crit * 100 * spellData.ScalePerCritPercent; } if (spellData.ScalePerTargetMissHealth > 0) { totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth * spellData.ScalePerTargetMissHealth + 1; } if (target is Obj_AI_Minion) { if (spellData.MaxDamageOnMinion?.Count > 0) { totalDamage = Math.Min( totalDamage, spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]); } if (target.Team == GameObjectTeam.Neutral && spellData.MaxDamageOnMonster?.Count > 0) { totalDamage = Math.Min( totalDamage, spellData.MaxDamageOnMonster[Math.Min(spellLevel - 1, spellData.MaxDamageOnMonster.Count - 1)]); } } if (spellData.IsModifiedDamage) { if (targetHero != null && targetHero.HasItem(ItemId.NinjaTabi)) { dmgReduce *= 0.9; } } } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage) { var itemDamage = DamageItems.ComputeItemDamages(source, target); totalDamage += source.CalculateDamage(target, DamageType.Physical, itemDamage.PhysicalDamage); totalDamage += source.CalculateDamage(target, DamageType.Magical, itemDamage.MagicalDamage); } if (source.ChampionName == "Sejuani" && target.HasBuff("sejuanistun")) { switch (target.Type) { case GameObjectType.obj_AI_Hero: if (source.Level < 7) { dmgPassive += 0.1 * target.MaxHealth; } else if (source.Level < 14) { dmgPassive += 0.15 * target.MaxHealth; } else { dmgPassive += 0.2 * target.MaxHealth; } break; case GameObjectType.obj_AI_Minion: dmgPassive += 400; break; } dmgPassive = source.CalculateDamage(target, DamageType.Magical, dmgPassive); } return(Math.Max(Math.Floor(totalDamage * dmgReduce + dmgPassive), 0)); }
/// <summary> /// Get the spell damage value. /// </summary> /// <param name="source"> /// The source /// </param> /// <param name="target"> /// The target /// </param> /// <param name="spellSlot"> /// The spell slot /// </param> /// <param name="stage"> /// The stage /// </param> /// <returns> /// The <see cref="double" /> value of damage. /// </returns> public static double GetSpellDamage( this Obj_AI_Hero source, Obj_AI_Base target, SpellSlot spellSlot, DamageStage stage = DamageStage.Default) { if (source == null || !source.IsValid || target == null || !target.IsValid) { return(0); } ChampionDamage value; if (!DamageCollection.TryGetValue(source.ChampionName, out value)) { return(0); } var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData; if (spellData == null) { return(0); } var spellLevel = source.Spellbook.GetSpell(spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot) .Level; if (spellLevel == 0) { return(0); } var baseDamage = 0d; var bonusDamage = 0d; if (spellData.Damages?.Count > 0) { if (spellData.DamageType == DamageType.Mixed) { var oriDamage = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]; baseDamage = source.CalculateMixedDamage(target, oriDamage / 2, oriDamage / 2); if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount( spellData.ScalingBuff); baseDamage = buffCount != 0 ? baseDamage * (buffCount + spellData.ScalingBuffOffset) : 0; } } else { baseDamage = source.CalculateDamage( target, spellData.DamageType, spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]); if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount( spellData.ScalingBuff); baseDamage = buffCount != 0 ? baseDamage * (buffCount + spellData.ScalingBuffOffset) : 0; } } } if (spellData.DamagesPerLvl?.Count > 0) { baseDamage = source.CalculateDamage( target, spellData.DamageType, spellData.Damages[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)]); } if (spellData.BonusDamages?.Count > 0) { foreach (var bonusDmg in spellData.BonusDamages.Where(i => source.ResolveBonusSpellDamage(target, i, spellLevel - 1) > 0)) { if (bonusDmg.DamageType == DamageType.Mixed) { var oriDamage = source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1); bonusDamage += source.CalculateMixedDamage(target, oriDamage / 2, oriDamage / 2); } else { bonusDamage += source.CalculateDamage( target, bonusDmg.DamageType, source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1)); } } } var totalDamage = baseDamage + bonusDamage; var passiveDamage = 0d; if (totalDamage > 0) { if (spellData.ScalePerTargetMissHealth > 0) { totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth * spellData.ScalePerTargetMissHealth + 1; } if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0) { totalDamage = Math.Min( totalDamage, spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]); } if (spellData.SpellEffectType == SpellEffectType.Single && target is Obj_AI_Minion) { var savagery = source.GetCunning(DamageMastery.Cunning.Savagery); if (savagery.IsValid()) { passiveDamage += savagery.Points; } } } return(totalDamage + passiveDamage); }
/* * private static void Unit_Ondash(Obj_AI_Base sender, Dash.DashArgs args) * { * var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical); * var qSpell = Config.Item("useQW2D").GetValue<bool>(); * * if (!sender.IsEnemy) * { * return; * } * * if (sender.NetworkId == target.NetworkId) * { * if (qSpell) * { * * if (Q.IsReady() * && args.EndPos.Distance(target) < Q.Range) * { * var delay = (int)(args.EndTick - Game.Time - Q.Delay - 0.1f); * if (delay > 0) * { * DelayAction.Add(delay * 1000, () => Q.Cast(args.EndPos)); * } * else * { * Q.Cast(args.EndPos); * } * if (Q.IsReady() * && args.EndPos.Distance(new Vector2 Player.Position, < Q.Range) * { * if (delay > 0) * { * DelayAction.Add(delay * 1000, () => Q.Cast(args.EndPos)); * } * else * { * W.CastOnUnit(target); * } * } * } * } * } * } */ private static double eDamage(Obj_AI_Base target) { return (Player.CalculateDamage(target, DamageType.Magical, new[] { 50, 66, 82, 98, 114 }[E.Level - 1] +0.3 * Player.FlatMagicDamageMod + 0.02 * Player.Mana)); }
/// <summary> /// Get the spell damage value. /// </summary> /// <param name="source"> /// The source /// </param> /// <param name="target"> /// The target /// </param> /// <param name="spellSlot"> /// The spell slot /// </param> /// <param name="stage"> /// The stage /// </param> /// <returns> /// The <see cref="double" /> value of damage. /// </returns> public static double GetSpellDamage( this Obj_AI_Hero source, Obj_AI_Base target, SpellSlot spellSlot, DamageStage stage = DamageStage.Default) { if (source == null || !source.IsValid || target == null || !target.IsValid) { return(0); } ChampionDamage value; if (!DamageCollection.TryGetValue(source.ChampionName, out value)) { return(0); } var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData; if (spellData == null) { return(0); } var spellLevel = source.Spellbook.GetSpell(spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot) .Level; if (spellLevel == 0) { return(0); } bool alreadyAdd1 = false, alreadyAdd2 = false; var targetHero = target as Obj_AI_Hero; var targetMinion = target as Obj_AI_Minion; double dmgBase = 0, dmgBonus = 0, dmgPassive = 0; var dmgReduce = 1d; if (spellData.DamagesPerLvl?.Count > 0) { dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)]; } else if (spellData.Damages?.Count > 0) { dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]; if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount( spellData.ScalingBuff); dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0; } } if (dmgBase > 0) { if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0) { dmgBase += spellData.BonusDamageOnMinion[Math.Min(spellLevel - 1, spellData.BonusDamageOnMinion.Count - 1)]; } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single) { if (source.HasBuff("Serrated")) { dmgBase += 15; } if (targetHero != null) { if (!spellData.IsApplyOnHit && Items.HasItem((int)ItemId.Dorans_Shield, targetHero)) { dmgBase -= 8; } } else if (targetMinion != null) { var savagery = source.GetCunning(Cunning.Savagery); if (savagery.IsValid()) { dmgBase += savagery.Points; } } alreadyAdd1 = true; } dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase); if (spellData.IsModifiedDamage && spellData.DamageType == DamageType.Physical && targetHero != null && targetHero.ChampionName == "Fizz") { dmgBase -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d)); alreadyAdd2 = true; } } if (spellData.BonusDamages?.Count > 0) { foreach (var bonusDmg in spellData.BonusDamages) { var dmg = source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1); if (dmg <= 0) { continue; } if (!alreadyAdd1 && (spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single)) { if (source.HasBuff("Serrated")) { dmg += 15; } if (targetHero != null) { if (Items.HasItem((int)ItemId.Dorans_Shield, targetHero)) { dmg -= 8; } } else if (targetMinion == null) { var savagery = source.GetCunning(Cunning.Savagery); if (savagery.IsValid()) { dmg += savagery.Points; } } alreadyAdd1 = true; } dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg); if (!alreadyAdd2 && spellData.IsModifiedDamage && bonusDmg.DamageType == DamageType.Physical && targetHero != null && targetHero.ChampionName == "Fizz") { dmgBonus -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d)); alreadyAdd2 = true; } } } var totalDamage = dmgBase + dmgBonus; if (totalDamage > 0) { if (spellData.ScalePerTargetMissHealth > 0) { totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth * spellData.ScalePerTargetMissHealth + 1; } if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0) { totalDamage = Math.Min( totalDamage, spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]); } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage) { dmgPassive += source.GetPassiveDamageInfo(target, false).Value; if (targetHero != null) { if (spellData.IsModifiedDamage && new[] { 3047, 1316, 1318, 1315, 1317 }.Any(i => Items.HasItem(i, targetHero))) { dmgReduce *= 0.9; } if (source.GetFerocity(Ferocity.FervorofBattle).IsValid()) { var fervorBuffCount = source.GetBuffCount("MasteryOnHitDamageStacker"); if (fervorBuffCount > 0) { dmgPassive += source.CalculateDamage( target, DamageType.Physical, (0.13 + (0.77 * source.Level)) * fervorBuffCount); } } } } } return (Math.Max( Math.Floor( totalDamage * dmgReduce + (spellData.IsApplyOnHit || spellData.IsModifiedDamage ? source.PassiveFlatMod(target) : 0) + dmgPassive), 0)); }
/// <summary> /// Gets the spell damage. /// </summary> /// <param name="source">The source.</param> /// <param name="target">The target.</param> /// <param name="spellSlot">The spell slot.</param> /// <param name="stage">The stage.</param> /// <returns>System.Double.</returns> public static double GetSpellDamage( this Obj_AI_Hero source, Obj_AI_Base target, SpellSlot spellSlot, DamageStage stage = DamageStage.Default) { if (source == null || !source.IsValid || target == null || !target.IsValid) { return(0); } if (!DamageLibrary.Damages.TryGetValue(source.ChampionName, out ChampionDamage value)) { return(0); } var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData; if (spellData == null) { return(0); } var spellLevel = source.SpellBook.GetSpell( spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot) .Level; if (spellLevel == 0) { return(0); } var alreadyAdd1 = false; var alreadyAdd2 = false; var targetHero = target as Obj_AI_Hero; var targetMinion = target as Obj_AI_Minion; var dmgBase = 0d; var dmgBonus = 0d; var dmgPassive = 0d; var dmgReduce = 1d; if (spellData.DamagesPerLvl?.Count > 0) { dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)]; } else if (spellData.Damages?.Count > 0) { dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]; if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target) .GetBuffCount(spellData.ScalingBuff); dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0; } } if (dmgBase > 0) { if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0) { dmgBase += spellData.BonusDamageOnMinion[Math.Min( spellLevel - 1, spellData.BonusDamageOnMinion.Count - 1)]; } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single) { alreadyAdd1 = true; } dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase); if (spellData.IsModifiedDamage && spellData.DamageType == DamageType.Physical && targetHero != null && targetHero.ChampionName == "Fizz") { dmgBase -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d)); alreadyAdd2 = true; } } if (spellData.BonusDamages?.Count > 0) { foreach (var bonusDmg in spellData.BonusDamages) { var dmg = source.GetBonusSpellDamage(target, bonusDmg, spellLevel - 1); if (dmg <= 0) { continue; } if (!alreadyAdd1 && (spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single)) { alreadyAdd1 = true; } dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg); if (alreadyAdd2 || !spellData.IsModifiedDamage || bonusDmg.DamageType != DamageType.Physical || targetHero == null || targetHero.ChampionName != "Fizz") { continue; } dmgBonus -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d)); alreadyAdd2 = true; } } var totalDamage = dmgBase + dmgBonus; if (totalDamage > 0) { if (spellData.ScalePerCritPercent > 0) { totalDamage *= source.Crit * 100 * spellData.ScalePerCritPercent; } if (spellData.ScalePerTargetMissHealth > 0) { totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth * spellData.ScalePerTargetMissHealth + 1; } if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0) { totalDamage = Math.Min( totalDamage, spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]); } if (spellData.IsApplyOnHit || spellData.IsModifiedDamage) { dmgPassive += 0; // todo get passive shit if (targetHero != null) { if (spellData.IsModifiedDamage && targetHero.HasItem(3047)) { dmgReduce *= 0.9; } } } } return(Math.Max( Math.Floor( totalDamage * dmgReduce + (spellData.IsApplyOnHit || spellData.IsModifiedDamage ? source.GetPassiveFlatMod(target) : 0) + dmgPassive), 0)); }
/// <summary> /// Get the spell damage value. /// </summary> /// <param name="source"> /// The source /// </param> /// <param name="target"> /// The target /// </param> /// <param name="spellSlot"> /// The spell slot /// </param> /// <param name="stage"> /// The stage /// </param> /// <returns> /// The <see cref="double" /> value of damage. /// </returns> public static double GetSpellDamage( this Obj_AI_Hero source, Obj_AI_Base target, SpellSlot spellSlot, DamageStage stage = DamageStage.Default) { if (source == null || !source.IsValid || target == null || !target.IsValid) { return(0d); } var spellLevel = source.Spellbook.GetSpell(spellSlot).Level; if (spellLevel == 0) { return(0d); } ChampionDamage value; if (DamageCollection.TryGetValue(source.ChampionName, out value)) { var baseDamage = 0d; var bonusDamage = 0d; var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData; if (spellData?.Damages?.Count > 0) { baseDamage = source.CalculateDamage( target, spellData.DamageType, spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count)]); if (!string.IsNullOrEmpty(spellData.ScalingBuff)) { var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount( spellData.ScalingBuff); if (buffCount != 0) { baseDamage *= buffCount + spellData.ScalingBuffOffset; } } } if (spellData?.BonusDamages?.Count > 0) { bonusDamage = spellData.BonusDamages.Sum( instance => source.CalculateDamage( target, instance.DamageType, source.ResolveBonusSpellDamage(target, instance, spellLevel - 1))); } return(baseDamage + bonusDamage); } return(0d); }
private static double Qdmg(Obj_AI_Base target) { return (Player.CalculateDamage(target, DamageType.Physical, new[] { 40, 65, 90, 115, 140 }[Program.Q.Level - 1] +0.6 * Player.FlatPhysicalDamageMod)); }
private static double Qdmg(Obj_AI_Base target) { return (Player.CalculateDamage(target, DamageType.Magical, new[] { 75, 115, 155, 195, 235 }[Q.Level - 1] +0.45 * Player.FlatMagicDamageMod)); }
/// <summary> /// TODO The get rend damage. /// </summary> /// <param name="target"> /// TODO The target. /// </param> /// <param name="customStacks"> /// TODO The custom stacks. /// </param> /// <returns> /// The <see cref="float"/>. /// </returns> public static float GetRendDamage(Obj_AI_Base target, int customStacks = -1) { // Calculate the damage and return return((float)Player.CalculateDamage(target, DamageType.Physical, GetRawRendDamage(target, customStacks))); }