protected override void OnActivate()
{
base.OnActivate();
this.Decrepify = UnitExtensions.GetAbilityById(this.Owner, AbilityId.pugna_decrepify);
this.Blast = UnitExtensions.GetAbilityById(this.Owner, AbilityId.pugna_nether_blast);
this.Ward = UnitExtensions.GetAbilityById(this.Owner, AbilityId.pugna_nether_ward);
this.Drain = UnitExtensions.GetAbilityById(this.Owner, AbilityId.pugna_life_drain);
var factory = this.Config.Hero.Factory;
var itemMenu = this.Config.Hero.ItemMenu;
this.UseBlinkPrediction = factory.Item("Blink Prediction", new Slider(200, 0, 600));
this.UseBlinkPrediction.Item.Tooltip = "Will blink to set distance. Set to 0 if you want to disable it.";
this.DrainHP = factory.Item("Heal ally HP", new Slider(30, 0, 100));
this.DrainHP.Item.Tooltip = "Allies HP to begin healing";
this.SelfHPDrain = factory.Item("Min HP to Heal", new Slider(60, 0, 100));
this.SelfHPDrain.Item.Tooltip = "HP threshold to start healing";
this.PostDrainHP = factory.Item("Post drain HP", new Slider(30, 0, 100));
this.PostDrainHP.Item.Tooltip =
"HP threshold to stop healing. (this value must be higher than post drain HP)";
this.HealAllyTo = factory.Item("Post drain HP for ally", new Slider(100, 0, 100));
this.HealAllyTo.Item.Tooltip = "Heal ally to this hp (this value must be higher than heal ally HP)";
this.WardTargets = factory.Item("Targets for ward", new Slider(0, 1, 5));
this.WardTargets.Item.Tooltip = "Targets in range of ward for usage";
this.HealTargetHeroes = factory.Item("Heal Targets", new HeroToggler(new Dictionary <string, bool>(), false, true, false));
}
protected override async Task KillStealAsync(CancellationToken token)
{
if (Game.IsPaused || !this.Owner.IsAlive || !AbilityExtensions.CanBeCasted(this.Blast))
{
await Task.Delay(125, token);
return;
}
var damageBlast = Blast.GetAbilitySpecialData("blast_damage");
damageBlast *= Ensage.SDK.Extensions.UnitExtensions.GetSpellAmplification(this.Owner);
bool comboMana = Blast.GetManaCost(Blast.Level - 1) + Decrepify.GetManaCost(Decrepify.Level - 1) <
Owner.Mana;
var decrepifyKillable =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Health < damageBlast *(1 - x.MagicDamageResist) &&
Blast != null && Blast.IsValid && x.Distance2D(this.Owner) <= 900 &&
Ensage.Common.Extensions.AbilityExtensions.CanBeCasted(Decrepify, x) && Ensage.Common.Extensions.AbilityExtensions.CanBeCasted(Blast, x) &&
!UnitExtensions.IsMagicImmune(x) && comboMana);
var blastKillable =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Health < damageBlast *(1 - x.MagicDamageResist) &&
Ensage.Common.Extensions.AbilityExtensions.CanBeCasted(Blast, x) && !UnitExtensions.IsMagicImmune(x) && Blast.CanHit(x) &&
Ensage.SDK.Extensions.EntityExtensions.Distance2D(Owner, x.NetworkPosition) <= 800);
if (!UnitExtensions.IsChanneling(this.Owner))
{
if (decrepifyKillable != null)
{
if (Decrepify.UseAbility(decrepifyKillable))
{
await this.AwaitKillstealDelay((int)AbilityExtensions.GetCastDelay(this.Decrepify, this.Owner, decrepifyKillable, true), token); // decrepify
}
if (Blast.CanHit(decrepifyKillable))
{
if (Blast.UseAbility(decrepifyKillable))
{
await this.AwaitKillstealDelay((int)AbilityExtensions.GetCastDelay(this.Blast, this.Owner, decrepifyKillable, true), token);
}
}
}
if (blastKillable != null)
{
if (Blast.UseAbility(blastKillable.NetworkPosition))
{
await this.AwaitKillstealDelay((int)AbilityExtensions.GetCastDelay(this.Blast, this.Owner, blastKillable, true), token);
}
}
}
}
protected override void SemiR()
{
if (RootMenu["insec"].Enabled)
{
Player.IssueOrder(OrderType.MoveTo, Game.CursorPos);
var target = Extensions.GetBestEnemyHeroTargetInRange(R.Range + 410);
if (R.Ready)
{
if (Flash.Ready && Flash != null && target.IsValidTarget())
{
if (target.IsValidTarget(380))
{
foreach (var ally in GameObjects.AllyHeroes)
{
if (ally != null && UnitExtensions.Distance(ally, Player) < 1500 && !ally.IsMe)
{
if (Flash.Cast(target.ServerPosition.Extend(ally.ServerPosition, -100)))
{
R.Cast();
}
}
}
if (GameObjects.AllyHeroes.Where(x => UnitExtensions.Distance(x, Player) < E.Range)
.Count() == 1)
{
if (Flash.Cast(target.ServerPosition.Extend(Player.ServerPosition, -100)))
{
R.Cast();
}
}
}
}
}
}
}
public static bool IsFullMagicResist(this Unit source)
{
return(UnitExtensions.IsMagicImmune(source) ||
source.HasModifier("modifier_medusa_stone_gaze_stone") ||
source.HasModifier("modifier_huskar_life_break_charge") ||
source.HasModifier("modifier_oracle_fates_edict"));
}
private void Events_OnLoad(object sender, EventArgs e)
{
if (this.initialized)
{
return;
}
this.initialized = true;
GlobalVariables.LocalHero = ObjectManager.LocalHero;
GlobalVariables.EnemyTeam = UnitExtensions.GetEnemyTeam(GlobalVariables.LocalHero);
GlobalVariables.Team = GlobalVariables.LocalHero.Team;
// An aggregate catalog that combines multiple catalogs
catalog = new AggregateCatalog();
// Adds all the parts found in the Ability# assembly
catalog.Catalogs.Add(new AssemblyCatalog(typeof(AbilityBootstrapper).Assembly));
// foreach (var cacheAssembly in EnsageSharp.Sandbox.AssemblyResolver.AssemblyCache)
// {
// }
// Environment.
// catalog.Catalogs.Add(new AssemblyCatalog());
container = new CompositionContainer(catalog);
foreach (var c in catalog)
{
Console.WriteLine(c);
}
ComposeParts(this);
var delay = Game.GameTime < 0 ? 3000 : 500;
DelayAction.Add(
delay,
() =>
{
this.AbilityUnitManager.Value.OnLoad();
foreach (var abilityService in this.AbilityServices)
{
abilityService.Value.OnLoad();
}
this.MainMenuManager.Value.OnLoad();
});
DelayAction.Add(
500,
() =>
{
foreach (var abilityService in this.AbilityServices)
{
Console.WriteLine("Service: " + abilityService.Value);
}
});
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
}
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);
}
protected override void OnActivate()
{
base.OnActivate();
KillStealHandler = UpdateManager.Run(KillStealAsync, true, true);
this.context.Inventory.Attach(this);
this.Imprison = UnitExtensions.GetAbilityById(this.Owner, AbilityId.obsidian_destroyer_astral_imprisonment);
this.Orb = UnitExtensions.GetAbilityById(this.Owner, AbilityId.obsidian_destroyer_arcane_orb);
this.Ulti = UnitExtensions.GetAbilityById(this.Owner, AbilityId.obsidian_destroyer_sanity_eclipse);
}
/// <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 void CreateUnit(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <CreateUnitMsg>();
var newUnit = UnitExtensions.InstantiateUnitFromMsg(msg);
newUnit.PlayerId = _connectionPlayerMapping[netMsg.conn.connectionId];
newUnit.CurrentTile = GameState.AllTiles[msg.TileId];
newUnit.UnitId = GameState.GenerateId();
GameState.AllTiles[msg.TileId].OccupyUnit = newUnit;
GameState.AllUnits.Add(newUnit.UnitId, newUnit);
var msgToBroadcast = CreateUnitMsg.CopyMessage(msg, newUnit);
NetworkServer.SendToAll(Messages.CreateUnit, msgToBroadcast);
}
internal override void OnPreAttack(object sender, PreAttackEventArgs e)
{
if (RootMenu["combo"]["support"].Enabled)
{
if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Lasthit) ||
Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Laneclear) ||
Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Mixed))
{
if (e.Target.IsMinion && GameObjects.AllyHeroes
.Where(x => UnitExtensions.Distance(x, Player) < 1000).Count() > 1)
{
e.Cancel = true;
}
}
}
}
private void OnPounce()
{
if (Pounce.Level <= 0)
{
return;
}
if (DrawPouncePosition == true)
{
var pounceCastPos = UnitExtensions.InFront(Owner, PounceDistance + PounceRadius);
var red = new Vector3(255, 0, 0);
var green = new Vector3(0, 255, 0);
const string file = "materials/ensage_ui/particles/rectangle.vpcf";
particle.AddOrUpdate(Owner, $"DrawLine_{1}", file, ParticleAttachment.AbsOrigin, RestartType.None, 1, this.Owner.InFront(0), 2, pounceCastPos,
3, new Vector3(95, 100, 0), 4, red);
var targets = EntityManager <Hero> .Entities.FirstOrDefault(
x => x.IsAlive && x.Team != this.Owner.Team &&
x.Distance2D(this.Owner) < 1500 && !x.IsIllusion);
if (targets != null && AbilityExtensions.CanBeCasted(this.Pounce) && this.Pounce != null &&
!UnitExtensions.IsMagicImmune(targets) && !targets.IsInvulnerable())
{
var vectorOfMovement = new Vector2((float)Math.Cos(targets.RotationRad) * targets.MovementSpeed, (float)Math.Sin(targets.RotationRad) * targets.MovementSpeed);
var hitPosition = Intercepts(targets.Position, vectorOfMovement, this.Owner.Position, 933.33f);
var hitPosMod = hitPosition + new Vector3(vectorOfMovement.X * (TimeToTurn(this.Owner, hitPosition)), vectorOfMovement.Y * (TimeToTurn(this.Owner, hitPosition)), 0);
var hitPosMod2 = hitPosition + new Vector3(vectorOfMovement.X * (TimeToTurn(this.Owner, hitPosMod)), vectorOfMovement.Y * (TimeToTurn(this.Owner, hitPosMod)), 0);
if (this.Owner.Distance2D(hitPosMod2) > ((PounceDistance + PounceRadius) + targets.HullRadius))
{
return;
}
if (IsFacing(this.Owner, targets))
{
particle.AddOrUpdate(Owner, $"DrawLine_{1}", file, ParticleAttachment.AbsOrigin, RestartType.None, 1, this.Owner.InFront(0), 2, pounceCastPos,
3, new Vector3(95, 100, 0), 4, green);
}
}
}
else
{
particle.Remove($"DrawLine_{1}");
}
}
public virtual async Task KillStealAsync(CancellationToken args)
{
if (!Config.KillStealEnabled || Game.IsPaused || !Owner.IsAlive || UnitExtensions.IsChanneling(Owner))
{
return;
}
var enemies =
EntityManager <Hero> .Entities.Where(
x =>
x.IsValid &&
x.UnitState != UnitState.MagicImmune &&
x.IsAlive &&
!x.IsIllusion &&
x.Team != this.Owner.Team &&
x.Distance2D(this.Owner) <= this.Imprison.CastRange &&
this.GetImprisonDamage(x) >= (int)x.Health)
.ToList();
if (!enemies.Any())
{
return;
}
foreach (var enemy in enemies)
{
if (enemy.IsValid && this.Config.AbilityToggler.Value.IsEnabled(this.Imprison.Name) && this.Imprison.CanBeCasted())
{
Log.Debug($"Using Imprison because enemy can be ks'ed.");
this.Imprison.UseAbility(enemy);
await Await.Delay(this.GetAbilityDelay(enemy, this.Imprison));
return;
}
}
await Await.Delay(250, args);
return;
}
private void Events_OnLoad(object sender, EventArgs e)
{
if (this.initialized)
{
return;
}
GlobalVariables.LocalHero = ObjectManager.LocalHero;
GlobalVariables.EnemyTeam = UnitExtensions.GetEnemyTeam(GlobalVariables.LocalHero);
GlobalVariables.Team = GlobalVariables.LocalHero.Team;
// An aggregate catalog that combines multiple catalogs
catalog = new AggregateCatalog();
// Adds all the parts found in the Ability# assembly
var count = 0f;
//foreach (var cacheAssembly in EnsageSharp.Sandbox.Domain.PluginDomain.Assemblies)
foreach (var cacheAssembly in AssemblyResolver.AssemblyCache)
{
if (cacheAssembly.IsLibrary || !cacheAssembly.IsLoaded || !cacheAssembly.Exists || !cacheAssembly.Name.StartsWith("Ability."))
{
continue;
}
count++;
//Console.WriteLine(cacheAssembly.AssemblyName + " " + cacheAssembly.Name);
catalog.Catalogs.Add(new AssemblyCatalog(cacheAssembly.Assembly));
}
if (count == 0)
{
return;
}
catalog.Catalogs.Add(new AssemblyCatalog(typeof(AbilityBootstrapper).Assembly));
// Environment.
// catalog.Catalogs.Add(new AssemblyCatalog());
container = new CompositionContainer(catalog);
// foreach (var c in catalog)
// {
// Console.WriteLine(c);
// //foreach (var cExportDefinition in c.ExportDefinitions)
// //{
// // Console.WriteLine(cExportDefinition.ToString());
// // foreach (var o in cExportDefinition.Metadata)
// // {
// // Console.WriteLine(o.ToString());
// // }
// //}
// }
var delay = Game.GameTime < 0 ? 1500 : 500;
DelayAction.Add(
delay,
() =>
{
this.initialized = true;
ComposeParts(this);
if (!Game.IsInGame)
{
return;
}
this.AbilityFactory.Value.OnLoad();
this.AbilityUnitManager.Value.OnLoad();
this.MainMenuManager.Value.OnLoad();
if (this.AbilityServices != null && this.AbilityServices.Any())
{
foreach (var abilityService in this.AbilityServices)
{
Console.WriteLine("Service: " + abilityService.Value);
abilityService.Value?.OnLoad();
}
}
this.AbilityModuleManager.Value.OnLoad();
this.AbilityDataCollector.Value.OnLoad();
});
// DelayAction.Add(
// 500,
// () =>
// {
// foreach (var abilityService in this.AbilityServices)
// {
// Console.WriteLine("Service: " + abilityService.Value);
// }
// });
}
private async Task OnUpdate(CancellationToken token)
{
if (Game.IsPaused || !this.Config.General.ComboKey.Value.Active)
{
await Task.Delay(250, token);
return;
}
if (!this.Config.General.Enabled)
{
return;
}
foreach (var unit in this.Updater.AllUnits)
{
if (unit.Unit != BodyBlockerUnit && this.Config.Hero.ControlUnits && unit.Unit.Name != "npc_dota_templar_assassin_psionic_trap")
{
if (this.ComboMode.CurrentTarget == null || UnitExtensions.IsInvul(this.ComboMode.CurrentTarget) ||
this.ComboMode.CurrentTarget.IsAttackImmune())
{
Player.AttackEntity(unit.Unit, (Unit)null);
//unit.UnitMovementManager.Orbwalk(null);
}
else
{
Player.AttackEntity(unit.Unit, this.ComboMode.CurrentTarget);
//unit.UnitMovementManager.Orbwalk(this.ComboMode.CurrentTarget);
}
}
var ability1 = unit.Ability;
var ability2 = unit.Ability2;
var ability3 = unit.Ability3;
var ability4 = unit.Ability4;
if (this.ComboMode.CurrentTarget != null && this.Config.Hero.UseUnitAbilities &&
!UnitExtensions.IsInvul(this.ComboMode.CurrentTarget) && !this.ComboMode.CurrentTarget.IsAttackImmune() && !this.ComboMode.CurrentTarget.IsMagicImmune() &&
(ability1 != null && AbilityExtensions.CanBeCasted(ability1) ||
ability2 != null && AbilityExtensions.CanBeCasted(ability2) ||
ability3 != null && AbilityExtensions.CanBeCasted(ability3) ||
ability4 != null && AbilityExtensions.CanBeCasted(ability4)))
{
if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
UnitCastingChecks(ability1.Name, unit.Unit, this.ComboMode.CurrentTarget, ability1) &&
(ability1.TargetTeamType == TargetTeamType.Enemy ||
ability1.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability1) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability1) - 70))
{
if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability1.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability1.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability1.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
ability1.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability1))
{
if (ability1.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
UnitCastingChecks(ability2.Name, unit.Unit, this.ComboMode.CurrentTarget, ability2) &&
AbilityExtensions.CanHit(ability2, this.ComboMode.CurrentTarget) &&
(ability2.TargetTeamType == TargetTeamType.Enemy ||
ability2.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability2) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability2) - 70))
{
if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability2.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability2.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability2.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
ability2.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability2))
{
if (ability2.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability3 != null &&
AbilityExtensions.CanBeCasted(ability3) &&
UnitCastingChecks(ability3.Name, unit.Unit, this.ComboMode.CurrentTarget, ability3) &&
AbilityExtensions.CanHit(ability3, this.ComboMode.CurrentTarget) &&
(ability3.TargetTeamType == TargetTeamType.Enemy ||
ability3.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability3) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability3) - 70))
{
if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability3.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability3.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability3.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability3 != null &&
AbilityExtensions.CanBeCasted(ability3) &&
ability3.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability3))
{
if (ability3.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability4 != null &&
AbilityExtensions.CanBeCasted(ability4) &&
UnitCastingChecks(ability4.Name, unit.Unit, this.ComboMode.CurrentTarget, ability4) &&
AbilityExtensions.CanHit(ability4, this.ComboMode.CurrentTarget) &&
(ability4.TargetTeamType == TargetTeamType.Enemy ||
ability4.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability4) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability4) - 70))
{
if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability4.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability4.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability4.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability4 != null &&
AbilityExtensions.CanBeCasted(ability4) &&
ability4.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability4))
{
if (ability4.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
}
}
await Task.Delay(100, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
target =
this.TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.Distance2D(this.Owner) <= this.Owner.AttackRange * 2);
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
var modifier = Ensage.SDK.Extensions.UnitExtensions.HasModifier(this.Owner,
"modifier_item_hurricane_pike_range");
if ((this.BlinkDagger != null) &&
(this.BlinkDagger.Item.IsValid) &&
target != null && Owner.Distance2D(target) <= 1200 + sliderValue && !(Owner.Distance2D(target) <= 400) &&
this.BlinkDagger.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name))
{
var l = (this.Owner.Distance2D(target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(target), token);
}
if (!silenced)
{
try
{
var targets =
EntityManager <Hero> .Entities.Where(
x =>
x.IsValid && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Distance2D(this.Owner) <= 700)
.ToList();
foreach (var ultiTarget in targets)
{
if (this.Config.AbilityToggler.Value.IsEnabled(this.Ulti.Ability.Name) &&
this.Ulti.Ability.CanBeCasted(ultiTarget))
{
var ultiDamage = Ulti.GetDamage(ultiTarget);
if (ultiTarget.Health > ultiDamage)
{
continue;
}
var delay = this.GetAbilityDelay(ultiTarget, this.Ulti);
var radius = this.Ulti.Ability.GetAbilitySpecialData("radius");
var input =
new PredictionInput(
this.Owner,
ultiTarget,
delay,
float.MaxValue,
700,
radius,
PredictionSkillshotType.SkillshotCircle,
true)
{
CollisionTypes = CollisionTypes.None
};
// Log.Debug($"Owner: {input.Owner.Name}");
// Log.Debug($"Delay: {input.Delay}");
// Log.Debug($"Range: {input.Range}");
// Log.Debug($"Speed: {input.Speed}");
// Log.Debug($"Radius: {input.Radius}");
// Log.Debug($"Type: {input.PredictionSkillshotType}");
var output = this.Prediction.GetPrediction(input);
var amount = output.AoeTargetsHit.Count;
// Log.Debug($"{output.HitChance}");
if (output.HitChance >= HitChance.Medium &&
this.Config.MinimumTargetToUlti.Value >= amount)
{
Log.Debug(
$"Using Ulti!");
this.Ulti.UseAbility(output.CastPosition);
await Await.Delay(delay + (int)Game.Ping, token);
}
}
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Debug($"{e}");
}
}
if ((this.BloodThorn != null) &&
this.BloodThorn.Item.IsValid &&
target != null &&
this.BloodThorn.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.SheepStick != null) &&
this.SheepStick.Item.IsValid &&
target != null &&
this.SheepStick.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.Orchid != null) &&
this.Orchid.Item.IsValid && target != null &&
this.Orchid.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_orchid"))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.RodofAtos != null) &&
this.RodofAtos.Item.IsValid &&
target != null &&
this.RodofAtos.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.VeilofDiscord != null) &&
this.VeilofDiscord.Item.IsValid &&
target != null &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(target.Position);
await Await.Delay(this.GetItemDelay(target), token);
}
try
{
if (this.HurricanePike != null)
{
if (modifier && target != null && target.IsValid && target.IsAlive && this.Owner.CanAttack(target) &&
this.Orb.Ability.CanBeCasted(target))
{
await this.UseOrb(target, token);
return;
}
else if (modifier && target != null && target.IsValid && target.IsAlive && this.Owner.CanAttack(target) &&
!this.Orb.Ability.CanBeCasted(target))
{
this.Owner.Attack(target);
await Await.Delay(100, token);
}
if ((double)(this.Owner.Health / this.Owner.MaximumHealth) * 100 <=
(double)Config.HurricanePercentage.Item.GetValue <Slider>().Value&&
this.HurricanePike.Item.IsValid &&
target != null &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
return;
}
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Error($"{e}");
}
if ((this.ShivasGuard != null) &&
this.ShivasGuard.Item.IsValid &&
target != null && this.Owner.Distance2D(target) <= 900 &&
this.ShivasGuard.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))
{
Log.Debug("Using Shivas");
this.ShivasGuard.UseAbility();
await Await.Delay(20 + (int)Game.Ping, token);
}
if (this.Orb != null && this.Orb.Ability.IsValid &&
this.Config.AbilityToggler.Value.IsEnabled(this.Orb.Ability.Name) &&
this.Orb.Ability.CanBeCasted(target))
{
await this.UseOrb(target, token);
return;
}
if (this.target != null && target.IsValid &&
this.Owner.Distance2D(this.target) <= this.Owner.AttackRange(this.target))
{
this.Context.Orbwalker.Active.OrbwalkTo(target);
}
else
{
this.Context.Orbwalker.Active.OrbwalkTo(null);
}
await Await.Delay(125, token);
}
private async Task HealingWardController(CancellationToken token)
{
if (UnitExtensions.HasAghanimsScepter(this.Owner))
{
this.SwiftSlash = this.Owner.Spellbook.Spells.FirstOrDefault <Ability>(x => x.Name == "juggernaut_swift_slash");
}
if (this.healingWardUnit == null)
{
return;
}
var team = this.healingWardUnit.Team;
var healingRadius = this.HealingWardAbility.Radius;
while ((this.healingWardUnit != null) && this.healingWardUnit.IsValid && this.healingWardUnit.IsAlive)
{
if (Game.IsPaused)
{
await Task.Delay(125, token);
continue;
}
var enemyHeroes =
EntityManager <Hero> .Entities.Where(
x =>
x.IsAlive && x.IsVisible && (x.Team != team) &&
(x.Distance2D(this.healingWardUnit) < 1000))
.ToList();
var alliedHeroes = EntityManager <Hero>
.Entities.Where(
x =>
x.IsAlive && x.IsVisible && (x.Team == team) && (x.HealthPercent() <= 0.9f) &&
(x.Distance2D(this.healingWardUnit) < 800))
.OrderBy(x => x.HealthPercent())
.ToList();
if (!alliedHeroes.Any())
{
if (!this.Owner.IsAlive)
{
await Task.Delay(125, token);
continue;
}
alliedHeroes.Add(this.Owner);
}
var avoidCircles = new List <Polygon.Circle>(enemyHeroes.Count);
foreach (var enemyHero in enemyHeroes)
{
var dangerRange = enemyHero.AttackRange(this.healingWardUnit);
dangerRange = enemyHero.IsMelee ? dangerRange * 2f : dangerRange * 1.2f;
var circle = new Polygon.Circle(enemyHero.Position, dangerRange);
avoidCircles.Add(circle);
}
var healCircles = new List <Polygon.Circle>(alliedHeroes.Count);
foreach (var alliedHero in alliedHeroes)
{
var circle = new Polygon.Circle(alliedHero.Position, healingRadius);
if (avoidCircles.Exists(x => x.Center.Distance(circle.Center) <= Math.Abs(x.Radius - circle.Radius)))
{
continue;
}
healCircles.Add(circle);
}
var hasMoved = false;
if (healCircles.Any())
{
while (healCircles.Count > 1)
{
var mecResult = MEC.GetMec(healCircles.Select((target) => target.Center).ToList());
if ((mecResult.Radius != 0f) && (mecResult.Radius < healingRadius))
{
var movePos = new Vector3(
healCircles.Count <= 2
? (healCircles[0].Center + healCircles[1].Center) / 2
: mecResult.Center,
this.healingWardUnit.Position.Z);
if (avoidCircles.TrueForAll(x => !x.IsInside(movePos)))
{
this.healingWardUnit.Move(movePos);
hasMoved = true;
break;
}
}
var itemToRemove = healCircles.Where(x => x.Center != this.Owner.Position.ToVector2())
.MaxOrDefault((target) => healCircles[0].Center.DistanceSquared(target.Center));
healCircles.Remove(itemToRemove);
}
}
if (!healCircles.Any() || !hasMoved)
{
var isOwnerLow = this.Owner.HealthPercent() <= 0.5f;
var heroPos = isOwnerLow ? this.Owner.Position : alliedHeroes.First().Position;
if (!avoidCircles.Any())
{
this.healingWardUnit.Move(heroPos);
}
else
{
var z = this.healingWardUnit.Position.Z;
var clusterPos = Vector3.Zero;
foreach (var avoidCircle in avoidCircles)
{
clusterPos += avoidCircle.Center.ToVector3(z);
}
clusterPos /= avoidCircles.Count;
var movePos = (clusterPos - heroPos).Normalized();
movePos = heroPos + (movePos * healingRadius * -1f);
this.healingWardUnit.Move(movePos);
}
}
await Task.Delay(125, token);
}
this.healingWardUnit = null;
}
private void Execute()
{
if (!Sleeper.Sleeping && Config.LasthitKey)
{
foreach (var familiar in Main.Updater.AllFamiliars)
{
var enemyHero =
EntityManager <Hero> .Entities.FirstOrDefault(x =>
x.IsAlive &&
x.IsVisible &&
x.IsEnemy(Owner) &&
x.Distance2D(familiar.Unit) <= x.AttackRange + 400);
if (RunAwayBool && enemyHero != null)
{
familiar.Unit.Move(this.Owner.Position);
return;
}
var path = Main.LaneHelper.GetPathCache(familiar.Unit);
var lastPoint = path[path.Count - 1];
var closestPosition = path.Where(
x =>
x.Distance2D(lastPoint) < familiar.Unit.Position.Distance2D(lastPoint) - 300)
.OrderBy(pos => pos.Distance2D(familiar.Unit.Position))
.FirstOrDefault();
Sleeper.Sleep(250);
var closestTower = EntityManager <Tower> .Entities
.Where(x => x.IsAlive && x.IsEnemy(familiar.Unit)).OrderBy(z => z.Distance2D(familiar.Unit))
.FirstOrDefault();
var rnd = new Random();
if (closestTower != null && closestTower.IsInRange(familiar.Unit, 1000))
{
var myDist = familiar.Unit.Distance2D(closestTower);
var allyCreeps = EntityManager <Creep> .Entities.Where(x =>
x.IsAlly(familiar.Unit) && x.IsSpawned && x.IsAlive && !x.NetworkName.Contains("CDOTA_Unit_VisageFamiliar") &&
x.IsInRange(closestTower, 700) && x.Distance2D(closestTower) <= myDist);
if (allyCreeps.Any())
{
if (closestTower.AttackTarget != null && closestTower.AttackTarget.Equals(familiar.Unit))
{
var creepForAggro = allyCreeps.FirstOrDefault();
if (creepForAggro != null && !Sleeper.Sleeping)
{
CameraExtensions.PositionCamera(creepForAggro);
familiar.Unit.Attack(creepForAggro);
return;
}
else if (!Sleeper.Sleeping)
{
CameraExtensions.PositionCamera(Fountain);
familiar.Unit.Move(Fountain.Position);
return;
}
}
}
else
{
var friendlyTower = EntityManager <Tower> .Entities
.Where(x => x.IsAlive && x.IsAlly(familiar.Unit))
.OrderBy(z => z.Distance2D(familiar.Unit))
.FirstOrDefault();
if (friendlyTower != null && !Sleeper.Sleeping)
{
CameraExtensions.PositionCamera(friendlyTower);
familiar.Unit.Move(friendlyTower.Position);
Sleeper.Sleep(100);
return;
}
else if (!Sleeper.Sleeping)
{
CameraExtensions.PositionCamera(Fountain);
familiar.Unit.Move(this.Fountain.Position);
Sleeper.Sleep(100);
return;
}
}
}
var creep = GetTarget();
if (creep != null)
{
if (familiar.FamiliarMovementManager.Orbwalker.CanAttack(creep))
{
familiar.Unit.Attack(creep);
if (UseStoneForm && familiar.StoneForm.CanBeCasted)
{
var lowHpCreeps = EntityManager <Creep> .Entities.Count(x =>
x.IsSpawned && x.IsAlive && UnitExtensions.IsEnemy(x, Owner) &&
x.IsInRange(familiar.Unit, familiar.StoneForm.Radius) &&
familiar.StoneForm.GetDamage(x) >= x.Health);
if (lowHpCreeps >= 2)
{
CameraExtensions.PositionCamera(familiar.Unit);
familiar.StoneForm.UseAbility();
}
}
}
}
else if (!Ensage.Common.Extensions.UnitExtensions.IsAttacking(familiar.Unit))
{
CameraExtensions.PositionCamera(closestPosition.X, closestPosition.Y);
familiar.Unit.Attack(closestPosition);
}
}
}
}
