private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (!ShouldAutoGhost || !MyHero.IsAlive || MyHero.IsSilenced())
{
Await.Block("zaioNecrophosGhostSleep", AsyncHelpers.AsyncSleep);
return;
}
if (_ghostAbility.CanBeCasted() && !MyHero.IsMagicImmune())
{
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsAlive && x.Team != MyHero.Team &&
x.CanAttack() && !x.CantBeKilled() &&
x.Distance2D(MyHero) <= x.GetAttackRange() + 100 &&
x.IsAttacking(MyHero));
if (enemies.Count() >= 2 && MyHero.Health != MyHero.MaximumHealth)
{
Log.Debug(
$"Using ghost to avoid damage/death by right click {enemies.Count()} >= 2 and {MyHero.Health} != {MyHero.MaximumHealth}");
_ghostAbility.UseAbility();
Await.Block("zaioNecrophosGhostSleep", AsyncHelpers.AsyncSleep);
}
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (ZaioMenu.ShouldKillSteal && !Game.IsPaused && MyHero.IsAlive &&
(!ZaioMenu.ShouldBlockKillStealWhileComboing || Target == null || !CanExecute()))
{
Await.Block("zaio_killstealer", Killsteal);
}
else
{
Await.Block("zaio.killstealerSleep", AsyncHelpers.AsyncSleep);
}
if (TotalAttackRange != _lastAttackRange)
{
if (ZaioMenu.ShouldDisplayAttackRange)
{
DestroyAttackEffect();
CreateAttackEffect();
}
}
if (_comboTargetEffect != null && _target != null)
{
_comboTargetEffect.SetControlPoint(2, MyHero.NetworkPosition); //start point XYZ
_comboTargetEffect.SetControlPoint(7, _target.NetworkPosition); //end point XYZ
}
var prioritizeEvade = ZaioMenu.ShouldRespectEvader;
if (prioritizeEvade && !Utils.SleepCheck("Evader.Avoiding"))
{
Log.Debug($"abort because evade1");
Cancel();
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (!ShouldAutoDeny || !MyHero.IsAlive || MyHero.IsSilenced())
{
Await.Block("zaio.pudgeDenySleep", AsyncHelpers.AsyncSleep);
return;
}
if (_rotAbility.CanBeCasted() && !_rotAbility.IsToggled && !MyHero.IsMagicImmune())
{
var damage = _rotAbility.GetAbilityData("rot_damage");
var talent = MyHero.GetAbilityById(AbilityId.special_bonus_unique_pudge_2);
if (talent.Level > 0)
{
damage += talent.GetAbilityData("value");
}
var tick = _rotAbility.GetAbilityData("rot_tick");
damage *= tick * 3;
if (MyHero.Health < damage * (1 - MyHero.MagicResistance()))
{
Log.Debug($"Using rot to deny {MyHero.Health} < {damage * (1 - MyHero.MagicResistance())}!!");
_rotAbility.ToggleAbility();
Await.Block("zaio.pudgeDenySleep", AsyncHelpers.AsyncSleep);
}
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (Game.IsPaused || !me.IsAlive)
{
return;
}
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);
try
{
var time = me.GetTurnTime(e);
cooldown = Orbwalking.AttackOnCooldown(e, (float)time * 1000);
}
catch (Exception)
{
}
if (e != null && ExUnit.IsLinkensProtected(e))
{
Await.Block("linken", linken);
}
if (e != null && me.Health <= me.MaximumHealth / 100 * Config.RHealh.Item.GetValue <Slider>().Value)
{
Await.Block("AutoAbilities", AutoAbilities);
}
Await.Block("DrawingTargetDisplay", DrawingTargetDisplay);
Await.Block("DrawingRangeDisplay", DrawingRangeDisplay);
}
private static void GameDispatcher_PowerTreads(EventArgs args)
{
if (Game.IsPaused || (_powerTreadsFunc == null))
{
return;
}
Await.Block("awaitPowerTreadsToggle", _powerTreadsFunc);
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (!this.Config.KillStealEnabled.Value)
{
return;
}
if (!Game.IsPaused && Owner.IsAlive && !UnitExtensions.IsChanneling(Owner))
{
Await.Block("MyKillstealer", KillStealAsync);
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
if (this.Config.KillStealEnabled.Value && !Game.IsPaused && Owner.IsAlive)
{
Await.Block("MyKillstealer", KillStealAsync);
}
if (!Game.IsPaused)
{
Await.Block("MyWardAttacker", WardsAttack);
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
for (var index = 0; index < _razeEffects.Length; index++)
{
var ability = _razeAbilities[index];
var effect = _razeEffects[index];
if (ability == null || effect == null)
{
Await.Block("zaio.updateRazes", AsyncHelpers.AsyncSleep);
return;
}
var range = ability.GetAbilityData("shadowraze_range");
effect.SetControlPoint(0, MyHero.InFront(range));
}
}
private void GameDispatcher_OnIngameUpdate(EventArgs args)
{
foreach (
var hero in
ObjectManager.GetEntitiesParallel <Hero>()
.Where(x => x.IsValid && x.Team != MyHero.Team && x.IsAlive && x.IsVisible && !x.IsIllusion)
.ToList())
{
HealthInfo value;
if (!_visibilityInformation.TryGetValue(hero, out value))
{
_visibilityInformation.Add(hero,
new HealthInfo(Game.RawGameTime, hero.Health, hero.HealthRegeneration, hero.MagicResistance()));
}
else
{
_visibilityInformation[hero] = new HealthInfo(Game.RawGameTime, hero.Health, hero.HealthRegeneration,
hero.MagicResistance());
}
}
Await.Block("zaio.zuusVisibilityInfo", MyAsyncHelpers.AsyncSleep);
}
private static void OnIngameUpdate(EventArgs args)
{
if (Game.IsPaused)
{
return;
}
if (Utils.SleepCheck("zaio.unitControllersUpdate"))
{
Utils.Sleep(500, "zaio.unitControllersUpdate");
_controlledUnits =
_controlledUnits.Where(x => x.Key.IsValid && x.Key.IsAlive && x.Key.IsControllable)
.ToDictionary(x => x.Key, y => y.Value);
var units =
ObjectManager.GetEntitiesParallel <Unit>()
.Where(
x =>
x.IsValid && x.IsAlive && !(x is Hero) && !(x is Building) && !(x is Courier) &&
x.NetworkName != "CDOTA_Unit_Hero_Beastmaster_Hawk" && x.IsControllable &&
x.MoveCapability != MoveCapability.None && !_controlledUnits.ContainsKey(x));
foreach (var unit in units)
{
Log.Debug($"found new unit for unitcontroller {unit.Name}");
_controlledUnits.Add(unit, new UnitController(_currentHero, unit));
}
}
if (_controlledUnits.Any())
{
var selectionOverrides = ZaioMenu.SelectionOverridesControlMode;
if (selectionOverrides)
{
var selection = ObjectManager.LocalPlayer.Selection.OfType <Unit>();
foreach (
var unit in _controlledUnits.Values.Where(x => !selection.Contains(x.ControlledUnit)).ToList())
{
Await.Block($"zaioUnitController_{unit.GetHashCode()}", unit.Tick);
}
}
else
{
foreach (var unit in _controlledUnits.Values.ToList())
{
Await.Block($"zaioUnitController_{unit.GetHashCode()}", unit.Tick);
}
}
}
if ((ZaioMenu.ShouldRespectEvader && !Utils.SleepCheck("Evader.Avoiding")) || _currentHero.ComboTarget != null)
{
//Log.Debug($"abort unaggro because evade or in combo mode");
return;
}
var autoUnaggroTowers = ZaioMenu.AutoUnaggroTowers;
var autoUnaggroCreeps = ZaioMenu.AutoUnaggroCreeps;
if (autoUnaggroTowers || autoUnaggroCreeps)
{
var hero = _currentHero.Hero;
var attackers =
ObjectManager.GetEntitiesParallel <Unit>()
.Where(x => x.IsValid && x.IsAlive && x.Team != hero.Team &&
(
autoUnaggroTowers && x is Tower && ((Tower)x).AttackTarget == hero
||
autoUnaggroCreeps && x is Creep && ((Creep)x).IsSpawned &&
hero.RecentDamage > 0 && ((Creep)x).IsAttacking(hero) &&
x.IsAttacking()
)
);
if (attackers.Any())
{
foreach (var attacker in attackers)
{
var range = attacker.IsMelee ? attacker.AttackRange * 3.0f : attacker.AttackRange;
var ally = ObjectManager.GetEntitiesParallel <Unit>()
.Where(
x =>
x.IsValid && x.IsAlive && x.Team == hero.Team &&
x.NetworkName != "CDOTA_BaseNPC_Creep_Siege" &&
!(x is Courier) && !(x is Building) &&
x != hero && x.IsRealUnit() && !x.CantBeAttacked() &&
x.UnitDistance2D(attacker) <= range)
.OrderBy(x => x.Distance2D(attacker)).FirstOrDefault();
if (ally == null)
{
continue;
}
var distance = hero.UnitDistance2D(attacker);
var allyDistance = ally.UnitDistance2D(attacker);
if (allyDistance * 1.1f < distance)
{
Log.Debug($"attack ally to unaggro");
hero.Attack(ally);
Await.Block("zaioUnaggroBlock", MyAsyncHelpers.AsyncSleep);
}
else
{
Vector3 dir;
if (hero.Distance2D(ally) < range / 2)
{
dir = (ally.NetworkPosition - attacker.NetworkPosition).Normalized();
}
else
{
dir = (hero.NetworkPosition - attacker.NetworkPosition).Normalized();
}
var pos = attacker.NetworkPosition + dir * (allyDistance + 300);
hero.Move(pos);
Log.Debug($"move behind ally to unaggro {allyDistance} vs {distance}");
Await.Block("zaioUnaggroBlock", MyAsyncHelpers.AsyncSleep);
}
return;
}
}
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
var myHeroNetworkPosition = this.MyHero.NetworkPosition;
if (!await MoveOrBlinkToEnemy(target, tk, 480, 480))
{
if (!this.MyHero.IsSilenced() && this.MyHero.Distance2D(target) >= 480 && this.MyHero.Distance2D(target) <= maxYards)
{
var pos = (target.NetworkPosition - myHeroNetworkPosition).Normalized();
pos *= 100;
pos = target.NetworkPosition + pos;
float mana = MyHero.MaximumMana;
if (this._ultAbility.IsAbilityEnabled())
{
if (target.IsMoving)
{
Log.Debug($"Jumping the gun");
var moves = C**k.InFront(target, 300);
double consumedMana = (_ultAbility.GetAbilityData("ball_lightning_initial_mana_base") + ((_ultAbility.GetAbilityData("ball_lightning_initial_mana_percentage") / 100) * mana))
+ ((MyHero.Distance2D(moves) / 100) * (((_ultAbility.GetAbilityData("ball_lightning_travel_cost_percent") / 100) * mana)));
Log.Debug($"{consumedMana}");
if (consumedMana <= MyHero.Mana && (MyHero.Mana - consumedMana >= minMana))
{
this._ultAbility.UseAbility(moves);
await Await.Delay((int)((_ultAbility.FindCastPoint() + MyHero.GetTurnTime(moves)) * 2250 + Game.Ping), tk);
MyHero.Attack(target);
Await.Block("zaioAutoAttack", StormAuto);
}
}
else
{
Log.Debug($"Jumping close but far");
double consumedMana = (_ultAbility.GetAbilityData("ball_lightning_initial_mana_base") + ((_ultAbility.GetAbilityData("ball_lightning_initial_mana_percentage") / 100) * mana))
+ ((MyHero.Distance2D(pos) / 100) * (((_ultAbility.GetAbilityData("ball_lightning_travel_cost_percent") / 100) * mana)));
Log.Debug($"{consumedMana} {(MyHero.Distance2D(pos) / 100)}");
if (consumedMana <= MyHero.Mana && (MyHero.Mana - consumedMana >= minMana))
{
this._ultAbility.UseAbility(pos);
Log.Debug($"{(int)((_ultAbility.FindCastPoint() + MyHero.GetTurnTime(pos)) * 2250 + Game.Ping)}");
await Await.Delay((int)((_ultAbility.FindCastPoint() + MyHero.GetTurnTime(pos)) * 2250 + Game.Ping), tk);
MyHero.Attack(target);
Await.Block("zaioAutoAttack", StormAuto);
}
}
}
}
Log.Debug($"return because of blink");
return;
}
await this.HasNoLinkens(target, tk);
await this.UseItems(target, tk);
await this.DisableEnemy(target, tk);
if (!MyHero.IsSilenced())
{
bool hasAgha = MyHero.HasItem(ClassId.CDOTA_Item_UltimateScepter);
float qCost = _qAbility.GetAbilityData("Mana cost");
float wCost = _wAbility.GetAbilityData("Mana cost");
float myMana = MyHero.Mana;
float mana = MyHero.MaximumMana;
var pos = (target.NetworkPosition - myHeroNetworkPosition).Normalized();
pos *= 100;
pos = target.NetworkPosition + pos;
double consumedMana = (_ultAbility.GetAbilityData("ball_lightning_initial_mana_base") + ((_ultAbility.GetAbilityData("ball_lightning_initial_mana_percentage") / 100) * mana))
+ ((MyHero.Distance2D(pos) / 100) * (((_ultAbility.GetAbilityData("ball_lightning_travel_cost_percent") / 100) * mana)));
if (_qAbility.IsAbilityEnabled() && _qAbility.CanBeCasted() &&
_wAbility.IsAbilityEnabled() && _wAbility.CanBeCasted() &&
(qCost + wCost) <= myMana && !this.MyHero.HasModifier("modifier_storm_spirit_overload") &&
!target.HasModifier("modifier_item_lotus_orb_active"))
{
if (!hasAgha)
{
this._wAbility.UseAbility(target);
await Await.Delay(GetAbilityDelay(_wAbility), tk);
MyHero.Attack(target);
await Await.Delay(500);
}
else
{
this._wAbility.UseAbility();
await Await.Delay(GetAbilityDelay(_wAbility), tk);
MyHero.Attack(target);
await Await.Delay(500);
}
}
if (_qAbility.IsAbilityEnabled() && _qAbility.CanBeCasted() && !this.MyHero.HasModifier("modifier_storm_spirit_overload") &&
((!_wAbility.CanBeCasted() && (MyHero.Mana <= _qAbility.GetAbilityData("Mana cost") + consumedMana)) || MyHero.Distance2D(target) <= _qAbility.GetAbilityData("static_remnant_radius")))
{
this._qAbility.UseAbility();
await Await.Delay(GetAbilityDelay(_qAbility), tk);
MyHero.Attack(target);
await Await.Delay(500);
}
if (_ultAbility.IsAbilityEnabled() && (!_qAbility.CanBeCasted() || this.MyHero.Distance2D(target) >= _qAbility.GetAbilityData("static_remnant_radius")) && (!_wAbility.CanBeCasted(target) || MyHero.Distance2D(target) >= _wAbility.GetAbilityData("Cast range")) &&
this.MyHero.Distance2D(target) <= maxYards && !this.MyHero.HasModifier("modifier_storm_spirit_overload"))
{
this._ultAbility.UseAbility(pos);
await Await.Delay(GetAbilityDelay(_ultAbility), tk);
MyHero.Attack(target);
await Await.Delay(500);
}
if (this.MyHero.HasModifier("modifier_storm_spirit_overload"))
{
MyHero.Attack(target);
await Await.Delay(500);
}
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
}
protected override async Task <bool> Killsteal()
{
if (await base.Killsteal())
{
return(true);
}
if (MyHero.IsSilenced())
{
return(false);
}
float _qAutoDamage = this._qAbility.GetAbilityData("static_remnant_damage") + this._eAbility.GetDamage(_eAbility.Level - 1);
_qAutoDamage += (MyHero.MinimumDamage + MyHero.BonusDamage);
_qAutoDamage *= GetSpellAmp();
float _eAutoDamage = this._eAbility.GetDamage(_eAbility.Level - 1);
_eAutoDamage += (MyHero.MinimumDamage + MyHero.BonusDamage);
_eAutoDamage *= GetSpellAmp();
var qAutokillableTar =
ObjectManager.GetEntitiesParallel <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.MyHero.Team && !x.IsIllusion &&
this._qAbility.CanBeCasted() && this._qAbility.CanHit(x) &&
x.Health < (_qAutoDamage * (1 - x.MagicResistance())) &&
!x.IsMagicImmune() && !x.CantBeKilled() && !x.CantBeAttacked() &&
x.Distance2D(this.MyHero) <= 235);
var AutokillableTar =
ObjectManager.GetEntitiesParallel <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.MyHero.Team && !x.IsIllusion &&
x.Health < _eAutoDamage * (1 - x.MagicResistance()) &&
!x.IsMagicImmune() && !x.CantBeKilled() && !x.CantBeAttacked() &&
x.Distance2D(this.MyHero) <= 480);
if (this.MyHero.HasModifier("modifier_storm_spirit_overload") && AutokillableTar != null)
{
MyHero.Attack(AutokillableTar);
Await.Block("zaioAutoAttack", StormAuto);
}
if (this._qAbility.IsKillstealAbilityEnabled() && this._qAbility.CanBeCasted() && !MyHero.HasModifier("modifier_storm_spirit_overload"))
{
if (AutokillableTar != null && _qAbility.CanBeCasted())
{
Log.Debug($"Killing with auto {MyHero.HasModifier("modifier_storm_spirit_overload")}");
_qAbility.UseAbility();
await Await.Delay(300);
MyHero.Attack(AutokillableTar);
Await.Block("zaioAutoAttack", StormAuto);
}
if (qAutokillableTar != null && _qAbility.CanBeCasted())
{
Log.Debug($"Killing with q and auto");
_qAbility.UseAbility();
await Await.Delay(300);
MyHero.Attack(qAutokillableTar);
Await.Block("zaioAutoAttack", StormAuto);
}
}
if (this._ultAbility.IsKillstealAbilityEnabled() && this._ultAbility.CanBeCasted() && !MyHero.HasModifier("modifier_storm_spirit_overload"))
{
if (AutokillableTar != null && _ultAbility.CanBeCasted() && !_qAbility.CanBeCasted())
{
var moves = C**k.InFront(AutokillableTar, 100);
Log.Debug($"Killable with auto, q not available");
_ultAbility.UseAbility(moves);
await Await.Delay((int)((_ultAbility.FindCastPoint() + MyHero.GetTurnTime(moves)) * 2500 + Game.Ping));
MyHero.Attack(AutokillableTar);
Await.Block("zaioAutoAttack", StormAuto);
}
}
return(false);
}
#pragma warning disable 1998
private static async void GameDispatcher_OnIngameUpdate(EventArgs args)
#pragma warning restore 1998
{
Await.Block("splitterLogic", SplitterLogic);
}