private static bool CheckTarget(Unit enemy, bool doubleOwnage = false)
{
if (enemy.IsIllusion || !enemy.IsValidTarget(dagon.GetCastRange(), true, hero.NetworkPosition))
{
return(false);
}
if (enemy.IsLinkensProtected() || enemy.IsMagicImmune())
{
return(false);
}
if (!enemy.CanDie() || enemy.Modifiers.Any(x => IgnoreModifiers.Any(x.Name.Equals)))
{
return(false);
}
var damage = AbilityDamage.CalculateDamage(dagon, hero, enemy);
if (doubleOwnage)
{
damage *= 2;
}
return(enemy.Health < damage);
}
public override bool CanBeCasted(EvadableAbility ability, Unit unit)
{
if (Sleeper.Sleeping || !Ability.CanBeCasted() || !Hero.CanUseItems() || Hero.CanReincarnate())
{
return(false);
}
Debugger.WriteLine("// * Bloodstone calculations");
var damageSource = ability.AbilityOwner;
if (ability.IsDisable)
{
var totalDamage = (damageSource.MinimumDamage + damageSource.BonusDamage)
* damageSource.SecondsPerAttack * 2;
var totalMana = damageSource.Mana;
foreach (var spell in damageSource.Spellbook.Spells.Where(x => x.Level > 0 && x.Cooldown <= 0))
{
if (totalMana >= spell.ManaCost)
{
try
{
totalDamage += (int)Math.Round(AbilityDamage.CalculateDamage(spell, damageSource, unit));
totalMana -= spell.ManaCost;
}
catch (Exception)
{
}
}
}
Debugger.WriteLine("// * Incoming damage: " + totalDamage + " from: " + damageSource.GetName());
Debugger.WriteLine("// * HP left: " + unit.Health);
return(unit.Health <= totalDamage);
}
float damage;
try
{
damage = (int)Math.Round(AbilityDamage.CalculateDamage(ability.Ability, ability.AbilityOwner, Hero));
}
catch (Exception)
{
return(false);
}
if (damage > 850)
{
Debugger.WriteLine("// * Damage calculations probably incorrect // " + damage + " // " + ability.Name);
damage = 350;
}
Debugger.WriteLine("// * Incoming damage: " + damage + " from: " + ability.Name);
Debugger.WriteLine("// * HP left: " + unit.Health);
return(unit.Health <= damage);
}
public bool ShouldSpendGold(EvadableAbility ability)
{
if (sleeper.Sleeping)
{
return(false);
}
float damage;
try
{
damage = (int)Math.Round(AbilityDamage.CalculateDamage(ability.Ability, ability.AbilityOwner, Hero));
}
catch (Exception)
{
return(false);
}
if (damage > 850)
{
Debugger.WriteLine("// * Damage calculations probably incorrect // " + damage + " // " + ability.Name);
damage = 350;
}
// Debugger.WriteLine("// * Incoming damage: " + damage + " from: " + ability.Name);
// Debugger.WriteLine("// * HP left: " + Hero.Health);
return(Hero.Health <= damage);
}
public override bool CanBeCasted(EvadableAbility ability, Unit unit)
{
if (Sleeper.Sleeping)
{
return(false);
}
var damageSource = ability.AbilityOwner;
if (ability.IsDisable)
{
var totalDamage = (damageSource.MinimumDamage + damageSource.BonusDamage)
* damageSource.SecondsPerAttack * 2;
var totalMana = damageSource.Mana;
foreach (var spell in damageSource.Spellbook.Spells.Where(x => x.Level > 0 && x.Cooldown <= 0))
{
if (totalMana >= spell.ManaCost)
{
totalDamage += (int)Math.Round(AbilityDamage.CalculateDamage(spell, damageSource, unit));
totalMana -= spell.ManaCost;
}
}
return(unit.Health <= totalDamage);
}
var damage = (int)Math.Round(AbilityDamage.CalculateDamage(ability.Ability, damageSource, unit));
return(unit.Health <= damage);
}
public override bool CanBeCasted(EvadableAbility ability, Unit unit)
{
if (Sleeper.Sleeping || !Hero.CanUseItems())
{
return(false);
}
if (armletEnabled && AffectedByDot())
{
return(false);
}
var damageSource = ability.AbilityOwner;
var health = (int)unit.Health;
if (armletEnabled)
{
health = Math.Max(health - ArmletHpGain, 1);
}
//if (ability.IsDisable)
//{
// var totalDamage = (damageSource.MinimumDamage + damageSource.BonusDamage)
// * damageSource.AttacksPerSecond * 2;
// var totalMana = damageSource.Mana;
// foreach (var spell in damageSource.Spellbook.Spells.Where(x => x.Level > 0 && x.Cooldown <= 0))
// {
// if (totalMana >= spell.ManaCost)
// {
// totalDamage += (int)Math.Round(AbilityDamage.CalculateDamage(spell, damageSource, unit));
// totalMana -= spell.ManaCost;
// }
// }
// return health <= totalDamage;
//}
var damage = 150d;
try
{
damage = Math.Round(AbilityDamage.CalculateDamage(ability.Ability, damageSource, unit));
}
catch
{
Console.WriteLine("[Evader] Failed to calculate damage for: " + ability.Name);
}
if (HpRestored(ability.GetRemainingTime(Hero)) + health < damage)
{
return(false);
}
return(health <= damage);
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
}
/// <summary>
/// The kill steal.
/// </summary>
/// <param name="hero">
/// The hero.
/// </param>
/// <param name="minHealth">
/// The min health.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public bool KillSteal(Unit hero, float minHealth)
{
if (!hero.IsAlive || !this.CanUseOn(hero) || !(hero.Health > minHealth) ||
!(AbilityDamage.CalculateDamage(this.ability, Variables.Hero, hero) >= hero.Health) || !hero.CanDie())
{
return(false);
}
this.UseOn(hero);
return(true);
}
public override float CalculateDamage(Hero source, Unit target)
{
var damage = AbilityDamage.CalculateDamage(Ability, source, target);
if (target is Tower)
{
damage *= towerDamageReduction;
}
return((float)Math.Round(damage));
}
public bool ShouldReturn(Hero hero, Target enemy, bool doubleChakramDamage)
{
var damage = AbilityDamage.CalculateDamage(Ability, hero, enemy.Hero);
if (!doubleChakramDamage)
{
damage /= 2;
}
return(!Sleeper.Sleeping && CanReturn && enemy.IsValid() &&
(!Damaging(enemy) && enemy.FindAngle(Position) > 0.5 || damage >= enemy.Health));
}
private async Task OnUpdate(CancellationToken token)
{
//List<Hero> enemies = new List<Hero> ();
//List<Unit> greenbombsnearby = new List<Unit> ();
//greenbombsnearby.Clear ();
//enemies.Clear ();
if (config.EnableCheat)
{
greenbombsnearby = new List <Unit>();
if (config.techiesRampage.RemoteMines != null)
{
enemies = ObjectManager.GetEntities <Hero> ().Where(x => (x.Team != main.Team)).ToList();
if (enemies.Count > 0)
{
foreach (Hero enemy in enemies)
{
int bombsneeded = 0;
float damage = 0.0f;
int bombscounter = 0;
damage = AbilityDamage.CalculateDamage(config.techiesRampage.RemoteMines, context.Owner, enemy as Unit, 0, 0, enemy.MagicDamageResist, enemy.Health);
//damage = getDamage(enemy);
greenbombsnearby = ObjectManager.GetEntities <Unit> ().Where(x => x.IsInRange(enemy, 400) && x.IsAlive && x.Name == "npc_dota_techies_remote_mine" && x.Team == main.Team && x.IsControllableByPlayer(ObjectManager.LocalPlayer)).ToList();
bombsneeded = 0;
float damageneeded = 0;
while (greenbombsnearby.Count > 0 && damageneeded < enemy.Health)
{
damageneeded += damage;
bombsneeded++;
}
if (greenbombsnearby.Count > 0 && greenbombsnearby.Count >= bombsneeded)
{
foreach (Unit bomb in greenbombsnearby)
{
if (bombscounter < bombsneeded)
{
Ability selfdetonate = UnitExtensions.GetAbilityById(bomb, AbilityId.techies_remote_mines_self_detonate);
if (selfdetonate != null)
{
selfdetonate.UseAbility();
bombscounter++;
}
}
}
}
}
}
}
}
await Task.Delay(25, token);
}
private static void GameOnOnUpdate(EventArgs args)
{
if (!Checker.IsActive())
{
return;
}
if (!IsEnable)
{
return;
}
if (_sleeper.Sleeping)
{
return;
}
_sleeper.Sleep(500);
InSys = InSys.Where(x => x != null && x.IsValid).ToList();
var randomEnemy = Manager.HeroManager.GetEnemyViableHeroes().FirstOrDefault(x => !x.IsMagicImmune());
if (randomEnemy == null || !randomEnemy.IsValid)
{
return;
}
foreach (
var spell in
Members.MyHero.Spellbook.Spells.Where(
x =>
!x.IsAbilityBehavior(AbilityBehavior.Passive) && !InSys.Contains(x) &&
(x.GetDamage(0) > 0 || WhiteList.Contains(x.Name) || AbilityDamage.CalculateDamage(x, Members.MyHero, randomEnemy) > 0)))
{
InSys.Add(spell);
AddToCalcMenu(spell.StoredName());
Log.Debug($"dmgCalc.ability.new [{spell.Name}] [{spell.GetDamage(0)}]");
}
try
{
var items = Manager.HeroManager.GetItemList(Members.MyHero);
items =
items.Where(
x =>
!InSys.Contains(x) && AbilityDamage.CalculateDamage(x, Members.MyHero, randomEnemy) > 0 || x.GetDamage(0) > 0)
.ToList();
foreach (var spell in items)
{
InSys.Add(spell);
AddToCalcMenu(spell.StoredName());
Log.Debug($"dmgCalc.item.new [{spell.Name}]");
}
}
catch (Exception)
{
//
}
}
/// <summary>
/// The load.
/// </summary>
private static void Init()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Utils.Sleeps = new Dictionary <string, double>();
NotifiedSubscribers.Clear();
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Orbwalking.Events_OnLoad(null, null);
Utils.Sleeps = new Dictionary <string, double>();
}
private static void Drawing_OnDraw(EventArgs args)
{
if (!Checker.IsActive())
{
return;
}
if (!IsEnable)
{
return;
}
if (InSys == null || InSys.Count == 0)
{
return;
}
var haveEb = InSys.Any(x => x.StoredName() == "item_ethereal_blade" && x.CanBeCasted());
foreach (var v in Manager.HeroManager.GetEnemyViableHeroes())
{
try
{
var pos = HUDInfo.GetHPbarPosition(v);
if (pos.IsZero)
{
continue;
}
var myDmg = InSys.Where(x => x.CanBeCasted())
.Sum(
x =>
AbilityDamage.CalculateDamage(x, Members.MyHero, v,
minusMagicResistancePerc: haveEb ? 40 : 0));
var healthAfterShit = (int)(v.Health - myDmg);
var size = HUDInfo.GetHpBarSizeY();
var text = $"{healthAfterShit} ({myDmg})";
var textSize = Drawing.MeasureText(text, "Arial",
new Vector2((float)(size * 1.5), 500), FontFlags.AntiAlias);
var textPos = pos + new Vector2(HUDInfo.GetHPBarSizeX() + 4, 0);
Drawing.DrawText(
text,
textPos,
new Vector2(textSize.Y, 0),
new Color(R, G, B, 255),
FontFlags.AntiAlias | FontFlags.StrikeOut);
}
catch (Exception)
{
Printer.Print($"[DamageCalculation]: {v.StoredName()}");
}
}
}
private static void GameOnOnUpdate(EventArgs args)
{
if (!Checker.IsActive())
{
return;
}
if (!IsEnable)
{
return;
}
if (_sleeper.Sleeping)
{
return;
}
_sleeper.Sleep(500);
InSys = InSys.Where(x => x != null && x.IsValid).ToList();
var randomEnemy = Manager.HeroManager.GetEnemyViableHeroes().FirstOrDefault();
if (randomEnemy == null || !randomEnemy.IsValid)
{
return;
}
foreach (
var spell in
Members.MyHero.Spellbook.Spells.Where(
x =>
!x.IsAbilityBehavior(AbilityBehavior.Passive) && !InSys.Contains(x) && x.Level > 0 &&
AbilityDamage.CalculateDamage(x, Members.MyHero, randomEnemy) > 0))
{
InSys.Add(spell);
}
try
{
var items = Manager.HeroManager.GetItemList(Members.MyHero);
items =
items.Where(
x =>
!InSys.Contains(x) && AbilityDamage.CalculateDamage(x, Members.MyHero, randomEnemy) > 0)
.ToList();
foreach (var spell in items)
{
InSys.Add(spell);
}
}
catch (Exception)
{
//
}
}
public static void OnUpdate(EventArgs args)
{
if (!MenuManager.AimIsActive || Updater.Sleeping || MenuManager.ComboIsActive)
{
return;
}
var target =
Heroes.GetByTeam(Me.GetEnemyTeam())
.FirstOrDefault(
x =>
x.IsAlive && x.IsVisible && x.IsValidRazeTarget() &&
(!MenuManager.AimKillStealOnly ||
AbilityDamage.CalculateDamage(Core.RazeLow, Core.Me, x) > x.Health + x.HealthRegeneration));
if (target != null)
{
if (!KillStealer.Sleeping && Core.Razes.Any(x => x.CanBeCasted() && x.CanHit(target, x.GetAbilityDelay() + 50, false)) && !Core.Razes.Any(y => y.IsInAbilityPhase))
{
/*var mePos = Me.Position;
* var targetPos = Prediction.PredictedXYZ(Target, 550);//Target.Position;
* var angle = Me.FindAngleBetween(targetPos, true);
* var point = new Vector3(
* (float)
* (mePos.X +
* 100 *
* Math.Cos(angle)),
* (float)
* (mePos.Y +
* 100 *
* Math.Sin(angle)),
* Target.Position.Z);
* Me.Move(point);*/
Me.Attack(target);
KillStealer.Sleep(350);
}
if (Helper.RazeAimCaster(Core.RazeLow, target))
{
Updater.Sleep(1000);
}
else if (Helper.RazeAimCaster(Core.RazeNormal, target))
{
Updater.Sleep(1000);
}
else if (Helper.RazeAimCaster(Core.RazeHigh, target))
{
Updater.Sleep(1000);
}
}
}
public override float CalculateDamage(Hero source, Unit target)
{
var damage = AbilityDamage.CalculateDamage(Ability, source, target);
if (target is Tower)
{
damage *= towerDamageReduction;
}
else if (grow?.Level >= 1)
{
damage *= owner.AghanimState() ? tossBonusDamageScepter[grow.Level - 1] : tossBonusDamage[grow.Level - 1];
}
return((float)Math.Round(damage));
}
/// <summary>
/// The kill steal.
/// </summary>
/// <param name="minHealth">
/// The min Health.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public bool KillSteal(float minHealth)
{
foreach (var hero in
Heroes.GetByTeam(Variables.EnemyTeam)
.Where(
hero =>
hero.IsValid && hero.IsVisible && hero.IsAlive && this.CanUseOn(hero) && hero.Health > minHealth &&
AbilityDamage.CalculateDamage(this.ability, Variables.Hero, hero) >= hero.Health &&
hero.CanDie()))
{
this.UseOn(hero);
return(true);
}
return(false);
}
public override bool CanBeCasted(EvadableAbility ability, Unit unit)
{
if (Sleeper.Sleeping || !Ability.CanBeCasted())
{
return(false);
}
Debugger.WriteLine("// * Bloodstone calculations");
var damageSource = ability.AbilityOwner;
if (ability.IsDisable)
{
var totalDamage = (damageSource.MinimumDamage + damageSource.BonusDamage)
* damageSource.SecondsPerAttack * 2;
var totalMana = damageSource.Mana;
foreach (var spell in damageSource.Spellbook.Spells.Where(x => x.Level > 0 && x.Cooldown <= 0))
{
if (totalMana >= spell.ManaCost)
{
totalDamage += (int)Math.Round(AbilityDamage.CalculateDamage(spell, damageSource, unit));
totalMana -= spell.ManaCost;
}
}
Debugger.WriteLine("// * Incoming damage: " + totalDamage + " from: " + damageSource.GetName());
Debugger.WriteLine("// * HP left: " + unit.Health);
return(unit.Health <= totalDamage);
}
var damage = (int)Math.Round(AbilityDamage.CalculateDamage(ability.Ability, damageSource, unit));
Debugger.WriteLine("// * Incoming damage: " + damage + " from: " + ability.Name);
Debugger.WriteLine("// * HP left: " + unit.Health);
return(unit.Health <= damage);
}
private async Task OnUpdate2(CancellationToken token)
{
if (config.techiesRampage.ForceStaff != null && config.EnableCheat)
{
List <Hero> enemies = ObjectManager.GetEntities <Hero> ().Where(x => (x.Team != main.Team) && x.IsVisible && x.IsInRange(context.Owner, config.techiesRampage.ForceStaff.CastRange, true)).ToList();
if (enemies.Count > 0)
{
foreach (Hero enemy in enemies)
{
Vector3 pos = FindVector(enemy.Position, enemy.Rotation, config.techiesRampage.ForceStaff.PushLength);
int bombsneeded = 0;
float damage = 0.0f;
damage = AbilityDamage.CalculateDamage(config.techiesRampage.RemoteMines, context.Owner, enemy as Unit, 0, 0, enemy.MagicDamageResist, enemy.Health);
//damage = getDamage(enemy);
greenbombsnearby = ObjectManager.GetEntities <Unit> ().Where(x => pos.Distance(x.Position) <= 400 && x.IsAlive && x.Name == "npc_dota_techies_remote_mine" && x.Team == main.Team && x.IsControllableByPlayer(ObjectManager.LocalPlayer)).ToList();
float damageneeded = 0;
while (greenbombsnearby.Count > 0 && damageneeded < enemy.Health)
{
damageneeded += damage;
bombsneeded++;
}
if (greenbombsnearby.Count > 0 && greenbombsnearby.Count >= bombsneeded && config.techiesRampage.ForceStaff.CanBeCasted)
{
config.techiesRampage.ForceStaff.UseAbility(enemy);
}
}
}
count = enemies.Count;
}
await Task.Delay(25, token);
}
public static void UpdateDamage(Hero[] enemyHeroes, Hero[] allyHeroes)
{
if (!Utils.SleepCheck("GankDamage.Update"))
{
return;
}
if (!OnUpdateChecks.CanUpdate() || !MainMenu.GankDamageMenu.Item("enableGankDamage").GetValue <bool>())
{
return;
}
enemies = enemyHeroes;
allies = allyHeroes;
Utils.Sleep(1000, "GankDamage.Update");
if (MainMenu.GankDamageMenu.Item("enableGankDamageEnemies").GetValue <bool>())
{
foreach (var enemyHero in enemyHeroes)
{
var hero = enemyHero;
var heroName = NameManager.Name(hero);
if (!IncomingDamages.ContainsKey(heroName))
{
IncomingDamages.Add(heroName, 0);
}
var tempDmg = 0f;
foreach (var allyHero in
allyHeroes.Where(
x =>
AllyHeroes.AbilityDictionary.ContainsKey(NameManager.Name(x)) &&
AllyHeroes.ItemDictionary.ContainsKey(NameManager.Name(x)) && x.Distance2D(hero) < 1700))
{
var abilities = AllyHeroes.AbilityDictionary[NameManager.Name(allyHero)];
var items = AllyHeroes.ItemDictionary[NameManager.Name(allyHero)].Where(x => x.IsValid).ToList();
var list = new List <Ability>(abilities.Count + items.Count);
list.AddRange(abilities);
list.AddRange(items);
tempDmg +=
list.Where(x => x.CanBeCasted())
.Sum(ability => AbilityDamage.CalculateDamage(ability, allyHero, hero));
}
IncomingDamages[heroName] = tempDmg;
}
}
if (!MainMenu.GankDamageMenu.Item("enableGankDamageAllies").GetValue <bool>())
{
return;
}
foreach (var allyHero in allyHeroes)
{
var hero = allyHero;
var heroName = NameManager.Name(hero);
if (!IncomingDamages.ContainsKey(heroName))
{
IncomingDamages.Add(heroName, 0);
}
var tempDmg = 0f;
foreach (var enemyHero in
enemyHeroes.Where(
x =>
EnemyHeroes.AbilityDictionary.ContainsKey(NameManager.Name(x)) &&
EnemyHeroes.ItemDictionary.ContainsKey(NameManager.Name(x)) && x.Distance2D(hero) < 1700))
{
var abilities = EnemyHeroes.AbilityDictionary[NameManager.Name(enemyHero)];
var items = EnemyHeroes.ItemDictionary[NameManager.Name(enemyHero)].Where(x => x.IsValid).ToList();
var list = new List <Ability>(abilities.Count + items.Count);
list.AddRange(abilities);
list.AddRange(items);
tempDmg +=
list.Where(x => x.CanBeCasted())
.Sum(ability => AbilityDamage.CalculateDamage(ability, enemyHero, hero));
}
IncomingDamages[heroName] = tempDmg;
}
}
public void OnUpdate()
{
if (!Utils.SleepCheck("AbilityLastHit.Sleep"))
{
return;
}
Utils.Sleep(500, "AbilityLastHit.Sleep");
if (!menuManager.IsEnabled || !hero.IsAlive || !hero.CanCast() && !heroMeepo)
{
pause = true;
return;
}
var autoDisable = menuManager.AutoDisableTime;
if (autoDisable > 0 && Game.GameTime / 60 >= autoDisable)
{
menuManager.Disable();
}
if (pause)
{
pause = false;
}
availableAbilities =
abilities.Where(x => menuManager.AbilityActive(x.Name) && (x.CanBeCasted || heroMeepo)).ToList();
//debug
//foreach (var creep in
// from source in Creeps.All.Where(x => x.Team != heroTeam && x.IsValid && x.IsAlive && x.IsSpawned)
// let creep = new Classes.Creep(source)
// where !killableList.Select(x => x.Handle).Contains(source.Handle)
// select creep)
//{
// killableList.Add(creep);
//}
var myAutoAttackDamage = hero.MinimumDamage + hero.BonusDamage;
foreach (var killable in killableList.Where(x => x.IsValid && x.Distance(hero) < 1500))
{
var autoAttackDamageDone = killable.Unit.DamageTaken(myAutoAttackDamage, DamageType.Physical, hero);
var siege = killable.Unit.ClassID == ClassID.CDOTA_BaseNPC_Tower
|| killable.Unit.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege;
if (siege)
{
autoAttackDamageDone /= 2;
}
killable.HeroDamage = autoAttackDamageDone;
foreach (var ability in abilities.Where(x => x.Level > 0))
{
var creep = killable as Classes.Creep;
if (creep != null)
{
var damage = AbilityDamage.CalculateDamage(ability.Source, hero, creep.Unit);
switch (ability.Name)
{
case "meepo_poof":
damage *= 2;
break;
case "ember_spirit_sleight_of_fist":
damage = autoAttackDamageDone / 2;
break;
case "templar_assassin_meld":
if (siege)
{
var armor = new[] { 2, 4, 6, 8 };
var bonusTemplar = new[] { 50, 100, 150, 200 };
damage =
killable.Unit.SpellDamageTaken(
myAutoAttackDamage + bonusTemplar[ability.Level - 1],
DamageType.Physical,
hero,
ability.Name,
true,
armor[ability.Level - 1]);
}
break;
case "clinkz_searing_arrows":
var bonusClinkz = new[] { 30, 40, 50, 60 };
var tempDamage =
killable.Unit.SpellDamageTaken(
myAutoAttackDamage + bonusClinkz[ability.Level - 1],
DamageType.Physical,
hero,
ability.Name,
true);
if (siege)
{
tempDamage /= 2;
}
damage = tempDamage;
break;
}
creep.SaveDamage(ability.Handle, damage);
}
if (ability.DoesTowerDamage)
{
var tower = killable as Tower;
tower?.SaveDamage(
ability.Handle,
AbilityDamage.CalculateDamage(ability.Source, hero, tower.Unit)
/ ability.TowerDamageReduction);
}
}
killable.DamageCalculated = true;
}
}
public static void OnUpdate(EventArgs args)
{
if (!OnUpdateChecks.CanUpdate())
{
return;
}
if (!Utils.SleepCheck("DamageUpdate") || !Utils.SleepCheck("GlobalCasting"))
{
return;
}
Utils.Sleep(100, "DamageUpdate");
foreach (var hero in
new List <Hero>(EnemyHeroes.Heroes).Where(x => x != null && x.IsValid && x.IsAlive && x.IsVisible))
{
var heroName = NameManager.Name(hero);
var heroHandle = hero.Handle;
if (Utils.SleepCheck("calculate"))
{
var enumerable =
MyAbilities.OffensiveAbilities.Where(
ability =>
ability.Value.IsValid && ability.Key.Contains("nuke") &&
Nukes.NukesMenuDictionary[NameManager.Name(ability.Value)].Item(
NameManager.Name(ability.Value) + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) &&
MainMenu.Menu.Item("nukesToggler")
.GetValue <AbilityToggler>()
.IsEnabled(NameManager.Name(ability.Value)) &&
Nukes.NukesMenuDictionary[NameManager.Name(ability.Value)].Item(
NameManager.Name(ability.Value) + "combo").GetValue <bool>())
.OrderBy(x => ComboOrder.GetDamageOrder(x.Value))
.ToList();
float[] intakenDamage = { 0 };
var minusMagicResistancePerc = 0f;
var tempList = new List <Ability>();
float[] outtakenDamage = { 0 };
var manaLeft = AbilityMain.Me.Mana;
foreach (var ability in
enumerable.Where(
ability =>
(ability.Value.CanBeCasted() || ability.Value.IsInAbilityPhase ||
(AbilityMain.Me.ClassID == ClassID.CDOTA_Unit_Hero_Invoker &&
MyAbilities.InvokerInvoke.CanBeCasted() && ability.Value.Cooldown <= 0.5 &&
ability.Value.ManaCost + MyAbilities.InvokerInvoke.ManaCost < manaLeft)))
.Select(data => data.Value))
{
var name = NameManager.Name(ability);
if (manaLeft < ability.ManaCost ||
manaLeft
< Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value)
{
continue;
}
manaLeft -= ability.ManaCost;
if (DamageAmps.IsDamageAmp(ability))
{
minusMagicResistancePerc += DamageAmps.DamageAmpValue(ability);
}
float tempdmg;
if (ability.CanHit(hero, MyHeroInfo.Position))
{
tempdmg = AbilityDamage.CalculateDamage(
ability,
AbilityMain.Me,
hero,
minusHealth: intakenDamage[0] + outtakenDamage[0],
minusMagicResistancePerc: minusMagicResistancePerc);
intakenDamage[0] += tempdmg;
tempList.Add(ability);
if (!Dictionaries.InDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.InDamageDictionary.Add(heroHandle, intakenDamage[0]);
}
else
{
Dictionaries.InDamageDictionary[heroHandle] = intakenDamage[0];
}
if (intakenDamage[0] >= hero.Health)
{
MyAbilities.NukesCombo = tempList;
AbilityMain.DealtDamage = 0;
break;
}
}
else
{
tempdmg = AbilityDamage.CalculateDamage(
ability,
AbilityMain.Me,
hero,
minusHealth: outtakenDamage[0] + intakenDamage[0],
minusMagicResistancePerc: minusMagicResistancePerc);
outtakenDamage[0] += tempdmg;
}
}
if (!Dictionaries.OutDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.OutDamageDictionary.Add(heroHandle, outtakenDamage[0]);
}
else
{
Dictionaries.OutDamageDictionary[heroHandle] = outtakenDamage[0];
}
if (!Dictionaries.InDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.InDamageDictionary.Add(heroHandle, intakenDamage[0]);
}
else
{
Dictionaries.InDamageDictionary[heroHandle] = intakenDamage[0];
}
}
float dmg;
if (!Dictionaries.InDamageDictionary.TryGetValue(heroHandle, out dmg))
{
dmg = 0;
}
float outdmg;
if (!Dictionaries.OutDamageDictionary.TryGetValue(heroHandle, out outdmg))
{
outdmg = 0;
}
var hp = Math.Max(hero.Health - dmg, 0);
var lhp = Math.Max(hp - outdmg, 0);
float hitDmg;
if (!Dictionaries.HitDamageDictionary.TryGetValue(heroHandle, out hitDmg))
{
hitDmg = hero.DamageTaken(
MyDamage.BonusDamage + MyDamage.MinDamage,
DamageType.Physical,
AbilityMain.Me);
Dictionaries.HitDamageDictionary.Add(heroHandle, hitDmg);
}
else
{
hitDmg = hero.DamageTaken(
MyDamage.BonusDamage + MyDamage.MinDamage,
DamageType.Physical,
AbilityMain.Me);
Dictionaries.HitDamageDictionary[heroHandle] = hitDmg;
Utils.Sleep(250, heroHandle + "updatehitdamage");
}
var currentHits = lhp / hitDmg;
double hits;
if (!Dictionaries.HitsDictionary.TryGetValue(heroHandle.ToString(), out hits))
{
hits = Math.Ceiling(
(currentHits * MyHeroInfo.AttackRate() * hero.HealthRegeneration + lhp) / hitDmg);
Dictionaries.HitsDictionary.Add(heroHandle.ToString(), hits);
}
else if (Utils.SleepCheck(heroHandle + "updatehits"))
{
hits = Math.Ceiling(
(currentHits * MyHeroInfo.AttackRate() * hero.HealthRegeneration + lhp) / hitDmg);
Dictionaries.HitsDictionary[heroHandle.ToString()] = hits;
Utils.Sleep(250, heroHandle + "updatehits");
}
}
}
public bool ShouldReturn(Hero hero, Target enemy)
{
return(Utils.SleepCheck("Timber." + Name) && CanReturn && enemy.IsValid() &&
(enemy.GetDistance(Position) > Radius - 50 && enemy.GetTurnTime(Position) > 0 ||
AbilityDamage.CalculateDamage(Ability, hero, enemy.Hero) / 2 >= enemy.Health));
}
public static bool Cast(Ability ability, Unit target, string name, bool disabled = false)
{
if (!disabled)
{
disabled = target.IsStunned() || target.IsRooted() || target.IsHexed() || target.IsInvul();
}
if (target.HasModifier("modifier_item_blade_mail_reflect") &&
AbilityDamage.CalculateDamage(ability, AbilityMain.Me, target) > AbilityMain.Me.Health)
{
return(false);
}
if (target.HasModifier("modifier_nyx_assassin_spiked_carapace"))
{
return(false);
}
if (ability.Name == "sniper_assassinate")
{
if (AbilityMain.Me.Distance2D(target) <= AbilityMain.Me.GetAttackRange() + 100)
{
return(false);
}
}
if (ability.IsAbilityBehavior(AbilityBehavior.UnitTarget, name) && ability.Name != "lion_impale" &&
ability.Name != "lina_dragon_slave")
{
if (target.IsLinkensProtected())
{
if (!Utils.SleepCheck("AbilitySharp.CancelLinkens"))
{
return(false);
}
if (MyAbilities.Cyclone != null && MyAbilities.Cyclone.CanBeCasted())
{
MyAbilities.Cyclone.UseAbility(target);
}
else if (MyAbilities.ForceStaff != null && MyAbilities.ForceStaff.CanBeCasted())
{
MyAbilities.ForceStaff.UseAbility(target);
}
Utils.Sleep(1000, "AbilitySharp.CancelLinkens");
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
SoulRing.Cast(ability);
ability.UseAbility(target, true);
return(false);
}
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
SoulRing.Cast(ability);
ability.UseAbility(target);
DelayAction.Add(
new DelayActionItem(300, () => { AbilityMain.LaunchSnowball(); }, CancellationToken.None));
return(true);
}
if ((ability.IsAbilityBehavior(AbilityBehavior.AreaOfEffect, name) ||
ability.IsAbilityBehavior(AbilityBehavior.Point, name)) &&
(disabled ||
Prediction.StraightTime(target)
> Nukes.NukesMenuDictionary[name].Item(name + "minstraighttime").GetValue <Slider>().Value ||
target.MovementSpeed < 200))
{
if (AbilityMain.Me.ClassId == ClassId.CDOTA_Unit_Hero_Invoker && !ability.CanBeCasted())
{
var invoked = ability.Invoke();
if (!invoked)
{
return(false);
}
DelayAction.Add(
Game.Ping * 2,
() =>
{
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
var casted2 = ability.CastSkillShot(
target,
MyHeroInfo.Position,
name,
SoulRing.Check(ability) ? MyAbilities.SoulRing : null);
if (!casted2)
{
return;
}
if (!disabled && Utils.SleepCheck(ability.Handle.ToString()) &&
ability.GetCastDelay(AbilityMain.Me, target, true) * 1000 - Game.Ping > 0.1)
{
DelayAction.Add(
new DelayActionItem(
(int)
(ability.GetCastDelay(AbilityMain.Me, target, true) * 1000
- Math.Max(50, Game.Ping)),
() =>
{
if (Prediction.StraightTime(target)
< (600
+ (ability.GetCastDelay(AbilityMain.Me, target, true) * 1000
- Math.Max(50, Game.Ping))) && target.MovementSpeed > 200)
{
AbilityMain.Me.Stop();
}
},
CancellationToken.None));
}
});
Utils.Sleep((Game.Ping * 2) + 200, "cancelorder");
Utils.Sleep((Game.Ping * 2) + 200, ability.Handle.ToString());
Utils.Sleep((Game.Ping * 2) + 200, "casting");
}
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
var casted = ability.CastSkillShot(
target,
MyHeroInfo.Position,
name,
SoulRing.Check(ability) ? MyAbilities.SoulRing : null);
if (!casted)
{
return(false);
}
if (!disabled && Utils.SleepCheck(ability.Handle.ToString()) &&
ability.GetCastDelay(AbilityMain.Me, target, true) * 1000 - Game.Ping > 0.1)
{
DelayAction.Add(
new DelayActionItem(
(int)(ability.GetCastDelay(AbilityMain.Me, target, true) * 1000 - Math.Max(50, Game.Ping)),
() =>
{
if (Prediction.StraightTime(target)
< (600
+ (ability.GetCastDelay(AbilityMain.Me, target, true) * 1000
- Math.Max(50, Game.Ping))) && target.MovementSpeed > 200)
{
AbilityMain.Me.Stop();
}
},
CancellationToken.None));
}
return(true);
}
if (ability.IsAbilityBehavior(AbilityBehavior.NoTarget, name))
{
if (ability.Name == "templar_assassin_meld")
{
if (
!(target.Distance2D(MyHeroInfo.Position)
< (AbilityMain.Me.GetAttackRange() + 50 + target.HullRadius + AbilityMain.Me.HullRadius)) ||
Orbwalking.AttackOnCooldown(target) || AbilityMain.Me.IsAttacking() ||
(target.Predict(Game.Ping).Distance2D(MyHeroInfo.Position)
> (AbilityMain.Me.GetAttackRange() + 50 + target.HullRadius + AbilityMain.Me.HullRadius)) ||
!Utils.SleepCheck("GlobalCasting"))
{
return(false);
}
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
ability.UseAbility();
DelayAction.Add(
new DelayActionItem(
(int)ability.GetCastDelay(AbilityMain.Me, target) * 1000,
() => { AbilityMain.Me.Attack(target); },
CancellationToken.None));
Utils.Sleep(ability.GetCastDelay(AbilityMain.Me, target) * 1000, "GlobalCasting");
Utils.Sleep(ability.GetCastDelay(AbilityMain.Me, target) * 1000 + 200, "casting");
Utils.Sleep(ability.GetCastDelay(AbilityMain.Me, target) * 1000 + 200, "Ability.Move");
Utils.Sleep(ability.GetCastDelay(AbilityMain.Me, target) * 1000 + 200, "cancelorder");
return(true);
}
if (ability.Name.Contains("nevermore_shadowraze"))
{
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
return(ability.CastSkillShot(target, name));
}
SoulRing.Cast(ability);
Game.ExecuteCommand("dota_player_units_auto_attack_mode 0");
ManageAutoAttack.AutoAttackDisabled = true;
ability.UseAbility();
return(true);
}
return(false);
}
private static void Drawing_OnDraw(EventArgs args)
{
if (!Checker.IsActive())
{
return;
}
if (!IsEnable)
{
return;
}
if (InSys == null || InSys.Count == 0)
{
return;
}
var haveEb =
InSys.Any(
x => IsAbilityEnable(x.StoredName()) && x.StoredName() == "item_ethereal_blade" && x.CanBeCasted());
var haveVeil =
InSys.Any(
x => IsAbilityEnable(x.StoredName()) && x.StoredName() == "item_veil_of_discord" && x.CanBeCasted());
var myPhysDmg = 0f;
if (Members.MyHero.ClassID == ClassID.CDOTA_Unit_Hero_MonkeyKing)
{
var extraMkAbility = Members.MyHero.FindSpell("special_bonus_unique_monkey_king", true)?.Level == 1;
var passiveDmg = MkDmg[Members.MyHero.FindSpell("monkey_king_jingu_mastery", true).Level];
myPhysDmg = Members.MyHero.MinimumDamage + Members.MyHero.BonusDamage +
(Members.MyHero.HasModifier("modifier_monkey_king_quadruple_tap_bonuses")
? passiveDmg
: 0);
var boundless = Members.MyHero.FindSpell("monkey_king_boundless_strike", true).Level;
var coef = 1.2f + 0.20f * boundless;
myPhysDmg *= extraMkAbility ? 3f : coef;
}
foreach (var v in Manager.HeroManager.GetEnemyViableHeroes())
{
try
{
var pos = HUDInfo.GetHPbarPosition(v);
if (pos.IsZero)
{
continue;
}
var extraDamage = haveEb && !v.HasModifier("modifier_item_ethereal_blade_ethereal") ? 40 : 0;
extraDamage += haveVeil && !v.HasModifier("modifier_item_veil_of_discord_debuff") ? 25 : 0;
var myDmg = InSys.Where(x => x.CanBeCasted() && IsAbilityEnable(x.StoredName()))
.Sum(
x => WhiteList.Contains(x.Name)
? Calculations.DamageTaken(v,
myPhysDmg,
DamageType.Physical, Members.MyHero)
: AbilityDamage.CalculateDamage(x, Members.MyHero, v,
minusMagicResistancePerc: extraDamage));
var health = v.Health;
var extraLife =
(uint)(Manager.HeroManager.GetItemList(v)
.Any(x => x.StoredName() == "item_infused_raindrop" && x.Cooldown <= 0)
? 120
: 0);
if (extraLife > 100)
{
var needToCalcExtraLife =
InSys.Any(
x =>
x.DamageType == DamageType.Magical &&
AbilityDamage.CalculateDamage(x, Members.MyHero, v,
minusMagicResistancePerc: haveEb ? 40 : 0) > 120);
health += needToCalcExtraLife ? extraLife : 0;
}
var healthAfterShit = (int)(health - myDmg);
var size = HUDInfo.GetHpBarSizeY();
var text = $"{healthAfterShit} ({(int) myDmg})";
var textSize = Drawing.MeasureText(text, "Arial",
new Vector2((float)(size * 1.5), 500), FontFlags.AntiAlias);
var textPos = pos + new Vector2(HUDInfo.GetHPBarSizeX() + 4, 0);
var isEno = healthAfterShit < 0;
var name = isEno ? "killableCol" : "defCol";
Drawing.DrawText(
text,
textPos,
new Vector2(textSize.Y, 0),
new Color(R(name), G(name), B(name), 255),
FontFlags.AntiAlias | FontFlags.StrikeOut);
}
catch (Exception)
{
Printer.Print($"[DamageCalculation]: {v.StoredName()}");
}
}
}
private static void FullCombo(EventArgs args)
{
if (!Game.IsInGame || Game.IsPaused || Game.IsWatchingGame || Game.IsChatOpen)
{
return;
}
// Selects target closest to mouse using user selected range from menu.
//playerList = Heroes.All;
target = me.ClosestToMouseTarget(ClosestToMouseRange.GetValue <Slider>().Value);
allyTarget = ClosestToMouseAlly(me);
if (target != null && Utils.SleepCheck("PudgePROrotatedCheckSleep"))
{
//Game.PrintMessage("Target Rotated: " + TargetRotated(), MessageType.LogMessage);
targetRotate = TargetRotated();
Utils.Sleep(comboSleepGet, "PudgePROrotatedCheckSleep");
}
//rotToggled = me.HasModifier("modifier_pudge_rot") == true ? true : false;
//if (hook != null && hook.IsInAbilityPhase && targetRotate)
//{
// Game.PrintMessage("I WORK NOW", MessageType.LogMessage);
// me.Stop();
//}
if (hook != null && target != null && hookPredictRad.GetValue <bool>())
{
GetCastSkillShotEnemy(hook, target, "pudge_meat_hook", soulring, true);
}
//foreach (var unit in playerList)
//{
// if (unit.Team == me.Team && unit.IsAlive && !unit.IsIllusion)
// {
// allyTarget = TargetSelector.ClosestToMouse(me).;//unit;
// }
//}
//var allyTarget = TargetSelector.ClosestToMouse(me).Equals(ally);
//var targetFacingLocationB = target.InFront(1000);
//var targetFacingAngleB = target.Position.ToVector2().FindAngleBetween(targetFacingLocationB.ToVector2(), true);
//targetFacing = targetFacingAngleB;
//if (Utils.SleepCheck("PudgePROGetAbilities")) GetAbilities();
//if (hook != null && hook.IsInAbilityPhase)// && Utils.SleepCheck("PudgePROcastSleep"))
//{
// var targetFacingLocationA = target.InFront(1000);
// var targetFacingAngleA = target.Position.ToVector2().FindAngleBetween(targetFacingLocationA.ToVector2(), true);
// Game.PrintMessage("targetFacing: " + targetFacing + "targetFacingAngleA: " + targetFacingAngleA, MessageType.LogMessage);
// if (targetFacing >= targetFacingAngleA + 0.1f && targetFacing <= targetFacingAngleA - 0.1f)
// {
// Game.PrintMessage("BAD HOOK", MessageType.LogMessage);
// me.Stop();
// return;
// }
//}
//if (Utils.SleepCheck("PudgePRObadHookSleep2"))
//{
// if (Utils.SleepCheck("BLAHBLAHBLAH"))
// {
// Game.PrintMessage("target is turning " + TargetTurning(), MessageType.LogMessage);
// Utils.Sleep(100, "BLAHBLAHBLAH");
// }
// if (TargetTurning())// || (walkStraight < straightTimer && walkStraight != 0))
// {
// Game.PrintMessage("BAD HOOK", MessageType.LogMessage);
// me.Stop();
// return;
// }
// Utils.Sleep(100, "PudgePRObadHookSleep2");
//}
// Combo type.
if (Menu.Item("comboType").GetValue <StringList>().SelectedIndex == 0 && Utils.SleepCheck("PudgePROcomboTypeSleep"))
{
GetAbilities();
var dismAddRange = (dismember != null) ? dismember.GetCastRange() : 100;
if (aetherLens == null)
{
dismAddRange -= 75;
}
else if (aetherLens != null)
{
dismAddRange -= 125;
}
//Menu.Item("itemsCon").Equals("item_force_staff");
if (blink != null && target != null && target.NetworkPosition.Distance2D(me.NetworkPosition) < blink.GetCastRange() + me.HullRadius + dismAddRange)
{
useBlink.SetValue(true);
}
else
{
useBlink.SetValue(false);
}
Utils.Sleep(100, "PudgePROcomboTypeSleep");
}
else if (Menu.Item("comboType").GetValue <StringList>().SelectedIndex == 1)
{
if (useBlink.GetValue <bool>())
{
useBlink.SetValue(false);
}
}
else if (Menu.Item("comboType").GetValue <StringList>().SelectedIndex == 2)
{
// Do nothing
}
// Kill Steal with "nuke" abilities.
if (killSteal.GetValue <bool>())
{
GetAbilities();
if (hook != null && hook.CanBeCasted() && !hook.IsInAbilityPhase && !me.IsChanneling() && Utils.SleepCheck("PudgePROkillStealSleep"))
{
var targets = ObjectManager.GetEntities <Hero>().Where(hero => hero.IsAlive && !hero.IsIllusion && hero.IsVisible && hero.Team == me.GetEnemyTeam()).ToList();
if (targets != null && targets.Any())
{
foreach (var enemy in targets)
{
var hookFullDamage = AbilityDamage.CalculateDamage(hook, me, enemy);
//Game.PrintMessage("Hook Damage: " + hookFullDamage, MessageType.LogMessage);
if (enemy.Health < hookFullDamage && hook.GetCastRange() >= enemy.NetworkPosition.Distance2D(me.NetworkPosition))
{
//Game.PrintMessage("Trying to hook " + enemy, MessageType.LogMessage);
CastSkillShotEnemy(hook, target, "pudge_meat_hook", soulring, false);
}
}
}
Utils.Sleep(100, "PudgePROkillStealSleep");
}
}
if (Game.IsKeyDown(allyHookKey.GetValue <KeyBind>().Key))
{
GetAbilities();
GetPredictionValues();
aetherRange = aetherLens != null ? (uint)220 : (uint)0;
var hookRange = hook.GetCastRange() + me.HullRadius;
if (allyTarget == null || !allyTarget.IsValid || allyTarget.IsIllusion || !allyTarget.IsAlive || allyTarget.IsInvul())
{
return;
}
//if (!allyRotate)
//{
// var allyFacingLocationB = allyTarget.InFront(100);
// var allyFacingAngleB = allyTarget.Position.ToVector2().FindAngleBetween(allyFacingLocationB.ToVector2(), true);
// allyFacing = allyFacingAngleB;
// allyRotate = true;
//}
if (soulring != null && !soulRing.GetValue <bool>())
{
soulring = null;
}
if (hook != null && Menu.Item("abilities").GetValue <AbilityToggler>().IsEnabled(hook.Name) &&
hookRange >= allyTarget.NetworkPosition.Distance2D(me) && hook.CanBeCasted() &&
!me.IsChanneling() && Utils.SleepCheck("PudgePROallyComboSleep"))
{
Utils.Sleep(100, "PudgePROallyComboSleep");
CastSkillShotAlly(hook, allyTarget, me.NetworkPosition);
//Game.PrintMessage("allyTarget: " + allyTarget.Name, MessageType.LogMessage);
//var predict = Prediction.PredictedXYZ(allyTarget, 1);//(me, allyTarget, 0, hook.GetProjectileSpeed("pudge_meat_hook"), hook.GetCastRange("pudge_meat_hook"));
//var mePos = me.Position;
//var reachTime = Prediction.CalculateReachTime(allyTarget, hook.GetProjectileSpeed(), predict - mePos);
//bool allyIdle = Prediction.IsIdle(allyTarget);
//var allyLocation = SkillShotTEST(me, allyTarget, (float)hook.GetHitDelay(allyTarget), hook.GetProjectileSpeed("pudge_meat_hook"), hook.GetRadius("pudge_meat_hook"));
//Game.PrintMessage("allyLocation: " + allyLocation, MessageType.LogMessage);
//hook.UseAbility(allyLocation);
//if (!allyIdle) hook.UseAbility(allyLocation);
//else hook.UseAbility(allyTarget.NetworkPosition);
}
//if (((hook != null && Menu.Item("abilities").GetValue<AbilityToggler>().IsEnabled(hook.Name)) &&
// hookRange >= allyTarget.NetworkPosition.Distance2D(me) && hook.CanBeCasted() &&
// !me.IsChanneling() && Utils.SleepCheck("PudgePROcomboSleep")))
//{
// Utils.Sleep(comboSleepGet, "PudgePROcomboSleep");
// //Game.PrintMessage("COMBO WORKING", MessageType.LogMessage);
// CastAbility(hook, hook.GetCastRange());
// if (!Utils.SleepCheck("PudgePRObadHookSleep")) return;
// //if (walkStraight < 500 && walkStraight != 0) return;
// var allyFacingLocationA = allyTarget.InFront(100);
// var allyFacingAngleA = allyTarget.Position.ToVector2().FindAngleBetween(allyFacingLocationA.ToVector2(), true);
// //Game.PrintMessage("targetFacing: " + targetFacing + "targetFacingAngleA: " + targetFacingAngleA, MessageType.LogMessage);
// if (badHook.GetValue<bool>() && hook != null && hook.IsInAbilityPhase && ((allyFacing + rotTolerance < allyFacingAngleA || allyFacing - rotTolerance > allyFacingAngleA) || (Prediction.IsIdle(allyTarget) && !allyStop)))
// {
// //Game.PrintMessage("BAD HOOK", MessageType.LogMessage);
// me.Stop();
// allyRotate = false;
// if (Prediction.IsIdle(allyTarget)) allyStop = true;
// return;
// }
// allyRotate = false;
//}
//if (hook != null && !hook.CanBeCasted() && allyStop && Utils.SleepCheck("PudgePROidleSleep"))
//{
// //Game.PrintMessage("resetting idle", MessageType.LogMessage);
// allyStop = false;
// Utils.Sleep(100, "PudgePROidleSleep");
//}
//if (Utils.SleepCheck("PudgePRObadHookSleep") && allyRotate && Utils.SleepCheck("PudgePROrotateSleep"))
//{
// //Game.PrintMessage("resetting rotate", MessageType.LogMessage);
// allyRotate = false;
// Utils.Sleep(100, "PudgePROrotateSleep");
//}
}
// Full combo
// Check if Combo key is being held down.
if (Game.IsKeyDown(comboKey.GetValue <KeyBind>().Key) || Menu.Item("comboToggleKey").IsActive())
{
// Retrieves values for ability and item variables.
GetAbilities();
GetPredictionValues();
aetherRange = aetherLens != null ? (uint)220 : (uint)0;
var hookRange = hook.GetCastRange() + me.HullRadius;
//var targetFacingLocationA = target.InFront(1000); ;
//float targetFacingAngleA = 0;
//sleepTimer = sleepTime.GetValue<Slider>().Value;
//straightTimer = straightTime.GetValue<Slider>().Value;
if (target == null || !target.IsValid || target.IsIllusion || !target.IsAlive || target.IsInvul())
{
return;
}
if (!targetRotateOld && !newHookCheck.GetValue <bool>())
{
var targetFacingLocationB = target.InFront(100);
var targetFacingAngleB = target.Position.ToVector2().FindAngleBetween(targetFacingLocationB.ToVector2(), true);
targetFacing = targetFacingAngleB;
targetRotateOld = true;
}
if (target.HasModifier("modifier_pudge_meat_hook") && target.Distance2D(me.Position) > 1000 && Utils.SleepCheck("PudgePROblink"))
{
me.Stop();
Utils.Sleep(100, "PudgePROblink");
}
CheckLinkensProt();
if (soulring != null && !soulRing.GetValue <bool>())
{
soulring = null;
}
//if (bottle != null && bottle.CanBeCasted() && !me.IsChanneling()
// && Menu.Item("itemsHD").GetValue<AbilityToggler>().IsEnabled(bottle.Name)
// && !me.HasModifier("modifier_bottle_regeneration"))
// bottle.UseAbility(me);
UseBlink();
if (!Utils.SleepCheck("PudgePROblink"))
{
return;
}
UseForceStaff();
if (!Utils.SleepCheck("PudgePROforceStaff"))
{
return;
}
if (Utils.SleepCheck("PudgePROsheepThornSleep"))
{
UseItem(bloodthorn, bloodthorn.GetCastRange());
UseItem(orchid, orchid.GetCastRange());
UseItem(sheep, sheep.GetCastRange());
UseItem(ghost, itemUseRange);
UseItem(glimmer, itemUseRange);
Utils.Sleep(100, "PudgePROsheepThornSleep");
}
UseRot();
UseItem(dust, dust.GetCastRange());
UseItem(veil, veil.GetCastRange());
UseItem(ethereal, ethereal.GetCastRange());
UseDagon();
UseItem(urn, urn.GetCastRange());
UseItem(shivas, shivas.GetCastRange());
UseItem(pipe, itemUseRange);
UseItem(hood, itemUseRange);
UseItem(crimson, itemUseRange);
if ((hookRange < target.NetworkPosition.Distance2D(me) || !MeHasMana() || AllOnCooldown()) && !me.IsChanneling() &&
!me.Spellbook.Spells.Any(x => x.IsInAbilityPhase) && Utils.SleepCheck("PudgePROorbwalkSleep"))
{
//Game.PrintMessage("ORBWALKING.", MessageType.LogMessage);
Orbwalk();
Utils.Sleep(100, "PudgePROorbwalkSleep");
}
else if (dismember != null && Menu.Item("abilities").GetValue <AbilityToggler>().IsEnabled(dismember.Name) && dismember.GetCastRange() + me.HullRadius >= target.Position.Distance2D(me.Position) &&
dismember.CanBeCasted() && !dismember.IsInAbilityPhase && !me.IsChanneling() && Utils.SleepCheck("PudgePROpreComboSleep"))
{
//Game.PrintMessage("PRE-DISMEMBERING.", MessageType.LogMessage);
CastAbility(dismember, dismember.GetCastRange() + me.HullRadius);
Utils.Sleep(100, "PudgePROpreComboSleep");
}
else if (((hook != null && Menu.Item("abilities").GetValue <AbilityToggler>().IsEnabled(hook.Name)) ||
(dismember != null && Menu.Item("abilities").GetValue <AbilityToggler>().IsEnabled(dismember.Name))) &&
hookRange >= target.NetworkPosition.Distance2D(me) && hook.CanBeCasted() && !dismember.IsInAbilityPhase &&
!me.IsChanneling() && Utils.SleepCheck("PudgePROcomboSleep"))
{
Utils.Sleep(100, "PudgePROcomboSleep");
//Game.PrintMessage("COMBO WORKING", MessageType.LogMessage);
CastAbility(hook, hook.GetCastRange());
//if (targetFacing == targetFacingOld) targetRotate = false;
if (!Utils.SleepCheck("PudgePRObadHookSleep") && !newHookCheck.GetValue <bool>())
{
return;
}
//if (walkStraight < 500 && walkStraight != 0) return;
var targetFacingLocationA = target.InFront(100);
var targetFacingAngleA = target.Position.ToVector2().FindAngleBetween(targetFacingLocationA.ToVector2(), true);
//Game.PrintMessage(" targetFacing: " + targetFacing + " targetFacingAngleA: " + targetFacingAngleA, MessageType.LogMessage);
//if (targetFacing == targetFacingOld) targetFacing = targetFacingAngleA;
//Game.PrintMessage("NEED TO STOP HOOK " + targetRotate, MessageType.LogMessage);
if (badHook.GetValue <bool>() && hook != null && hook.IsInAbilityPhase &&
(((targetRotate && newHookCheck.GetValue <bool>()) || ((targetFacing + rotTolerance < targetFacingAngleA || targetFacing - rotTolerance > targetFacingAngleA) && !newHookCheck.GetValue <bool>())) ||
(Prediction.IsIdle(target) && ((!TargetStillIdle() && newHookCheck.GetValue <bool>()) || !targetStop && !newHookCheck.GetValue <bool>())) ||
(dismember != null && dismember.CanBeCasted() && target.Position.Distance2D(me.Position) < dismember.GetCastRange() + me.HullRadius) || !CastSkillShotEnemy(hook, target, "pudge_meat_hook", soulring, true)))
{
//Game.PrintMessage("BAD HOOK " + hook.IsInAbilityPhase + " " + (targetFacing + rotTolerance < targetFacingAngleA) + " " +
// (targetFacing - rotTolerance > targetFacingAngleA) + " " + Prediction.IsIdle(target) + " " + targetStop + " " +
// CastSkillShotEnemy(hook, target, "pudge_meat_hook", soulring, true), MessageType.LogMessage);
//Game.PrintMessage("STOPING HOOK", MessageType.LogMessage);
me.Stop();
targetRotateOld = false;
//targetFacing = targetFacingAngleA;
if (Prediction.IsIdle(target))
{
targetStop = true;
}
return;
}
targetRotateOld = false;
if (target.Position.Distance2D(me.Position) < hook.GetCastRange())
{
MoveToMousePos();
}
//if (0.1 + 0.1f < 0.5 || 0.1 - 0.1f > 0.5)
//if (Prediction.IsTurning(target))// || (walkStraight < straightTimer && walkStraight != 0))
//{
// Game.PrintMessage("BAD HOOK", MessageType.LogMessage);
// me.Stop();
// return;
//}
CastAbility(dismember, hook.GetCastRange() + me.HullRadius);
//Utils.Sleep(100, "PudgePROcomboSleep");
}
else if ((hook != null ||
(dismember != null && Menu.Item("abilities").GetValue <AbilityToggler>().IsEnabled(dismember.Name))) &&
hookRange >= target.NetworkPosition.Distance2D(me) && !hook.CanBeCasted() && !dismember.IsInAbilityPhase &&
!me.IsChanneling() && Utils.SleepCheck("PudgePROdismemSleep"))
{
Utils.Sleep(100, "PudgePROdismemSleep");
CastAbility(dismember, hook.GetCastRange() + me.HullRadius);
}
if (hook != null && !hook.CanBeCasted() && targetStop && Utils.SleepCheck("PudgePROidleSleep"))
{
//Game.PrintMessage("resetting idle", MessageType.LogMessage);
targetStop = false;
Utils.Sleep(100, "PudgePROidleSleep");
}
if (Utils.SleepCheck("PudgePRObadHookSleep") && targetRotate && Utils.SleepCheck("PudgePROrotateSleep") && !newHookCheck.GetValue <bool>())
{
//Game.PrintMessage("resetting rotate", MessageType.LogMessage);
targetRotateOld = false;
Utils.Sleep(100, "PudgePROrotateSleep");
}
}
}
public static float CalculateMyDamage(Hero globalTarget)
{
var mana = Members.MyHero.MaximumMana;
var rearm = Abilities.FindAbility("tinker_rearm");
var laser = Abilities.FindAbility("tinker_laser");
var rocked = Abilities.FindAbility("tinker_heat_seeking_missile");
var allItems = new List <Ability>();
var allItems2 = new List <Ability>(Members.MyHero.Inventory.Items.Where(x =>
IsItemEnableNew(x.StoredName()) && (x.ManaCost > 0 || x.StoredName() == "item_soul_ring"))
.OrderBy(PriorityHelper)
.ToList());
allItems.AddRange(allItems2);
if (rocked.Level > 0 && IsItemEnableNew(rocked.StoredName()))
{
allItems.Add(rocked);
}
if (laser.Level > 0 && IsItemEnableNew(laser.StoredName()))
{
allItems.Add(laser);
}
if (rearm.Level > 0)
{
allItems.Add(rearm);
}
var haveEb = allItems.Any(x => x.StoredName() == "item_ethereal_blade" && x.CanBeCasted());
var haveVeil = allItems.Any(x => x.StoredName() == "item_veil_of_discord" && x.CanBeCasted());
var myDmg = 0f;
var extraDamage = haveEb && !globalTarget.HasModifier("modifier_item_ethereal_blade_ethereal") ? 40 : 0;
extraDamage += haveVeil && !globalTarget.HasModifier("modifier_item_veil_of_discord_debuff") ? 25 : 0;
if (allItems.Count == 0 || (rearm.Level == 0))
{
myDmg = allItems.Sum(
x =>
AbilityDamage.CalculateDamage(x, Members.MyHero, globalTarget,
minusMagicResistancePerc: extraDamage));
return((int)(globalTarget.Health - myDmg));
}
//Printer.Print($"[mana]: init");
Printer.ConsolePrint($"[mana]: Init. [count]: {allItems.Count}. [possible]: {allItems.Count(x => mana > x.ManaCost)}");
var wasRearmed = true;
var templarStacks = globalTarget.FindModifier("modifier_templar_assassin_refraction_absorb_stacks");
var stacks = templarStacks?.StackCount ?? 0;
var hasRainDrop = globalTarget.FindItem("item_infused_raindrop", true)?.Cooldown <= 0;
var wasNama = mana;
var linkDef = globalTarget.IsLinkensProtected();
while (mana > 5 && allItems.Count(x => mana > x.ManaCost) > 0 && wasRearmed && wasNama >= mana)
{
wasRearmed = false;
foreach (var x in allItems)
{
if (mana > x.ManaCost)
{
//Printer.ConsolePrint($"[mana]: {x.StoredName()} -> {x.ManaCost}/{mana}");
if (x.StoredName() == "item_soul_ring")
{
mana += 150;
Printer.ConsolePrint($"[mana]: {mana} (+150) soul ring");
continue;
}
var mCost = x.ManaCost;
if (!(mana - mCost > 0))
{
break;
}
mana -= mCost;
var dmgFromSpell = AbilityDamage.CalculateDamage(x, Members.MyHero, globalTarget,
minusMagicResistancePerc: extraDamage);
if (x.GetAbilityId() == AbilityId.tinker_laser)
{
if (Members.LaserBuff)
{
dmgFromSpell += 100;
}
}
if (x.IsAbilityBehavior(AbilityBehavior.UnitTarget) && linkDef && !x.IsDisable())
{
dmgFromSpell = 0;
linkDef = false;
}
if (stacks > 0)
{
stacks--;
myDmg += 0;
}
else
{
if (AbilityDamage.GetDamageType(x) == DamageType.Magical && hasRainDrop && dmgFromSpell > 50)
{
hasRainDrop = false;
dmgFromSpell -= Math.Min(120, dmgFromSpell);
dmgFromSpell = Math.Max(dmgFromSpell, 0);
}
myDmg += dmgFromSpell;
}
//Printer.Print($"[mana]: {mana} (-{mCost}) {x.StoredName()} -> damage: {myDmg}");
if (x.StoredName() == rearm.StoredName())
{
Printer.ConsolePrint($"[mana]: {mana} (-{mCost}) {x.StoredName()}");
wasRearmed = true;
continue;
}
Printer.ConsolePrint($"[mana]: {mana} (-{mCost}) {x.StoredName()} -> damage: {dmgFromSpell} || total:{myDmg}");
}
else
{
Printer.ConsolePrint($"[mana]: {x.StoredName()} -> {x.ManaCost}/{mana} cant cast this!");
}
}
/*Printer.ConsolePrint($"[mana]: {rearm.StoredName()} -> {rearm.ManaCost}/{mana}");
* mana -= rearm.ManaCost;*/
}
var healthAfterShit = (int)(globalTarget.Health - myDmg);
return(healthAfterShit);
}
public static float CalculateMyCurrentDamage(Hero globalTarget, bool checkForRange = false)
{
var mana = Members.MyHero.Mana;
var laser = Abilities.FindAbility("tinker_laser");
var rocked = Abilities.FindAbility("tinker_heat_seeking_missile");
var allItems = new List <Ability>();
var allItems2 = new List <Ability>(Members.MyHero.Inventory.Items.Where(x =>
IsItemEnableNew(x.StoredName()) && (x.ManaCost > 0 || x.StoredName() == "item_soul_ring"))
.OrderBy(PriorityHelper)
.ToList());
allItems.AddRange(allItems2);
if (laser.Level > 0 && IsItemEnableNew(laser.StoredName()))
{
allItems.Add(laser);
}
if (rocked.Level > 0 && IsItemEnableNew(rocked.StoredName()))
{
allItems.Add(rocked);
}
var haveEb =
allItems.Any(
x =>
x.StoredName() == "item_ethereal_blade" && x.CanBeCasted() &&
(x.CanHit(globalTarget) || !checkForRange));
var haveVeil =
allItems.Any(
x =>
x.StoredName() == "item_veil_of_discord" && x.CanBeCasted() &&
(x.CanHit(globalTarget) || !checkForRange));
var myDmg = 0f;
var extraDamage = haveEb && !globalTarget.HasModifier("modifier_item_ethereal_blade_ethereal") ? 40 : 0;
extraDamage += haveVeil && !globalTarget.HasModifier("modifier_item_veil_of_discord_debuff") ? 25 : 0;
var ignoreList = new List <Ability>();
var linkDef = globalTarget.IsLinkensProtected();
foreach (
var x in
allItems.Where(x => x.CanBeCasted() && !ignoreList.Contains(x))
.Where(x => !checkForRange || x.CanHit(globalTarget)))
{
if (x.Equals(rocked))
{
if (!CanRockedHit(globalTarget))
{
ignoreList.Add(rocked);
continue;
}
}
if (mana > x.ManaCost)
{
if (x.StoredName() == "item_soul_ring")
{
mana += 150;
continue;
}
var mCost = x.ManaCost;
if (!(mana - mCost > 0))
{
break;
}
mana -= mCost;
var dmgFromSpell = AbilityDamage.CalculateDamage(x, Members.MyHero, globalTarget,
minusMagicResistancePerc: extraDamage);
if (x.GetAbilityId() == AbilityId.tinker_laser)
{
if (Members.LaserBuff)
{
dmgFromSpell += 100;
}
}
if (x.IsAbilityBehavior(AbilityBehavior.UnitTarget) && linkDef && !x.IsDisable())
{
dmgFromSpell = 0;
linkDef = false;
}
myDmg += dmgFromSpell;
}
}
return((int)(globalTarget.Health - myDmg));
}
private static void Drawing_OnDraw(EventArgs args)
{
if (!Checker.IsActive())
{
return;
}
if (!IsEnable)
{
return;
}
if (InSys == null || InSys.Count == 0)
{
return;
}
var haveEb =
InSys.Any(
x => IsAbilityEnable(x.StoredName()) && x.StoredName() == "item_ethereal_blade" && x.CanBeCasted());
var haveVeil =
InSys.Any(
x => IsAbilityEnable(x.StoredName()) && x.StoredName() == "item_veil_of_discord" && x.CanBeCasted());
foreach (var v in Manager.HeroManager.GetEnemyViableHeroes())
{
try
{
var pos = HUDInfo.GetHPbarPosition(v);
if (pos.IsZero)
{
continue;
}
var extraDamage = haveEb && !v.HasModifier("modifier_item_ethereal_blade_ethereal") ? 40 : 0;
extraDamage += haveVeil && !v.HasModifier("modifier_item_veil_of_discord_debuff") ? 25 : 0;
var myDmg = InSys.Where(x => x.CanBeCasted() && IsAbilityEnable(x.StoredName()))
.Sum(
x =>
AbilityDamage.CalculateDamage(x, Members.MyHero, v,
minusMagicResistancePerc: extraDamage));
var health = v.Health;
var extraLife =
(uint)(Manager.HeroManager.GetItemList(v)
.Any(x => x.StoredName() == "item_infused_raindrop" && x.Cooldown <= 0)
? 120
: 0);
if (extraLife > 100)
{
var needToCalcExtraLife =
InSys.Any(
x =>
x.DamageType == DamageType.Magical &&
AbilityDamage.CalculateDamage(x, Members.MyHero, v,
minusMagicResistancePerc: haveEb ? 40 : 0) > 120);
health += needToCalcExtraLife ? extraLife : 0;
}
var healthAfterShit = (int)(health - myDmg);
var size = HUDInfo.GetHpBarSizeY();
var text = $"{healthAfterShit} ({(int) myDmg})";
var textSize = Drawing.MeasureText(text, "Arial",
new Vector2((float)(size * 1.5), 500), FontFlags.AntiAlias);
var textPos = pos + new Vector2(HUDInfo.GetHPBarSizeX() + 4, 0);
var isEno = healthAfterShit < 0;
var name = isEno ? "killableCol" : "defCol";
Drawing.DrawText(
text,
textPos,
new Vector2(textSize.Y, 0),
new Color(R(name), G(name), B(name), 255),
FontFlags.AntiAlias | FontFlags.StrikeOut);
}
catch (Exception)
{
Printer.Print($"[DamageCalculation]: {v.StoredName()}");
}
}
}
