Esempio n. 1
0
        public virtual bool CanBeCasted(Unit target)
        {
            if (target == null || !target.IsValid || !Menu.IsEnabled(target.StoredName()))
            {
                return(false);
            }

            if (!target.IsAlive || !target.IsVisible || UnitExtensions.IsMagicImmune(target) ||
                EntityExtensions.Distance2D(target, Manager.MyHero.Position) > GetCastRange() || target.IsInvul() ||
                target.IsReflectingAbilities())
            {
                return(false);
            }

            if (!Menu.BreakLinkens && UnitExtensions.IsLinkensProtected(target))
            {
                return(false);
            }

            if (!Menu.HexStack && target.IsReallyHexed())
            {
                return(false);
            }

            if (!Menu.SilenceStack && UnitExtensions.IsSilenced(target) && !target.IsReallyHexed())
            {
                return(false);
            }

            if (!Menu.RootStack && UnitExtensions.IsRooted(target))
            {
                return(false);
            }

            if (!Menu.StunStack && UnitExtensions.IsStunned(target))
            {
                return(false);
            }

            if (!Menu.DisarmStack && UnitExtensions.IsDisarmed(target) && !target.IsReallyHexed())
            {
                return(false);
            }

            return(true);
        }
Esempio n. 2
0
        public override async Task ExecuteAsync(CancellationToken token)
        {
            var e = TargetSelector.Active.GetTargets()
                    .FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);

            if (e == null)
            {
                return;
            }
            var debuff = e.FindModifier("modifier_storm_spirit_electric_vortex_pull") ?? e.FindModifier("modifier_sheepstick_debuff") ?? e.FindModifier("modifier_rod_of_atos_debuff");


            var buff = e.HasModifiers(new[]
            {
                "modifier_storm_spirit_electric_vortex_pull",
                "modifier_sheepstick_debuff",
                "modifier_rod_of_atos_debuff"
            }, false) || ExUnit.IsStunned(e) || ExUnit.IsHexed(e) || ExUnit.IsRooted(e);
            var checkTimeModif = debuff?.RemainingTime <= 0.3;

            var inUltBall = ExUnit.HasModifier(me, "modifier_storm_spirit_ball_lightning") ||
                            R.IsInAbilityPhase;
            var inOverload = ExUnit.HasModifier(me, "modifier_storm_spirit_overload");
            var lotusBuff  = ExUnit.HasModifier(e, "modifier_item_lotus_orb_active");
            var inVortex   = ExUnit.HasModifier(e, "modifier_storm_spirit_electric_vortex_pull");

            var travelSpeed   = R.GetAbilityData("ball_lightning_move_speed", R.Level);
            var distance      = me.Distance2D(e);
            var travelTime    = distance / travelSpeed;
            var startManaCost = R.GetAbilityData("ball_lightning_initial_mana_base") +
                                me.MaximumMana / 100 * R.GetAbilityData("ball_lightning_initial_mana_percentage");
            var costPerUnit = (12 + me.MaximumMana * 0.007) / 100.0;
            var rManacost   = startManaCost + costPerUnit * Math.Floor(distance / 100) * 100;
            var dagon       = me.GetDagon();
            var enemies     = EntityManager <Hero> .Entities.Count(
                x => x.IsValid && x.IsAlive && !x.IsIllusion && x.Team != me.Team && x.Distance2D(me) <= 700) >= Config.Heel.Item.GetValue <Slider>().Value;

            if (!lotusBuff)
            {
                if (
                    // cheese
                    cheese != null &&
                    cheese.Item.IsValid &&
                    cheese.Item.CanBeCasted() &&
                    (me.Health <= me.MaximumHealth * 0.3 ||
                     me.Mana <= me.MaximumMana * 0.2) &&
                    distance <= 700 &&
                    Config.ItemToggler.Value.IsEnabled(cheese.Item.Name)
                    )
                {
                    cheese.UseAbility();
                    await Await.Delay(GetItemDelay(e), token);
                }
                if ( // SoulRing Item
                    soul != null &&
                    soul.Item.IsValid &&
                    soul.Item.CanBeCasted() &&
                    Config.ItemToggler.Value.IsEnabled(soul.Item.Name) &&
                    me.CanCast() &&
                    me.Health >= me.MaximumHealth * 0.4 &&
                    me.Mana <= me.MaximumMana * 0.4
                    )
                {
                    soul.UseAbility();
                    await Await.Delay(GetItemDelay(e), token);
                }
                if ( // Arcane Boots Item
                    arcane != null &&
                    arcane.Item.IsValid &&
                    arcane.Item.CanBeCasted() &&
                    Config.ItemToggler.Value.IsEnabled(arcane.Item.Name) &&
                    me.CanCast() &&
                    me.Mana <= me.MaximumMana * 0.4
                    )
                {
                    arcane.UseAbility();
                    await Await.Delay(GetItemDelay(e), token);
                }

                uint elsecount = 0;
                elsecount += 1;
                if (elsecount == 1 &&
                    R != null &&
                    R.CanBeCasted() &&
                    !me.IsAttacking() &&
                    !R.IsChanneling &&
                    !R.IsInAbilityPhase &&
                    me.Mana >= rManacost &&
                    !inUltBall &&
                    distance >= me.GetAttackRange() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.AbilityToggler.Value.IsEnabled(R.Name)
                    )
                {
                    if (e.NetworkActivity == NetworkActivity.Move)
                    {
                        R.CastSkillShot(e);
                    }
                    else
                    {
                        R.UseAbility(e.Position);
                    }
                    await Await.Delay(GetAbilityDelay(me, R) + (int)Math.Floor(travelTime * 1000), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (vail != null &&
                    vail.Item.IsValid &&
                    vail.Item.CanBeCasted() &&
                    Config.ItemToggler.Value.IsEnabled(vail.Item.Name) &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e)
                    )
                {
                    vail.UseAbility(e.Position);
                    await Await.Delay(GetItemDelay(e), token);
                }
                if (orchid != null &&
                    orchid.Item.IsValid &&
                    orchid.Item.CanBeCasted() &&
                    (Config.silenceToHex.Value || !ExUnit.IsHexed(e)) &&
                    (Config.silenceToVortex.Value || !inVortex)

                    && me.CanCast() &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled("item_bloodthorn")
                    )
                {
                    orchid.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }
                if (nullifier != null &&
                    nullifier.Item.IsValid &&
                    nullifier.Item.CanBeCasted() &&
                    me.CanCast() &&
                    !ExUnit.IsHexed(e) &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(nullifier.Item.Name)
                    )
                {
                    nullifier.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }

                if (bloodthorn != null &&
                    bloodthorn.Item.IsValid &&
                    bloodthorn.Item.CanBeCasted() &&
                    (Config.silenceToVortex.Value || !inVortex) &&
                    (Config.silenceToHex.Value || !ExUnit.IsHexed(e)) &&
                    me.CanCast() &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled("item_bloodthorn")
                    )
                {
                    bloodthorn.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }
                if (elsecount == 2 &&
                    sheep != null &&
                    sheep.Item.IsValid &&
                    sheep.Item.CanBeCasted() &&
                    me.CanCast() &&
                    (checkTimeModif || !buff) &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    (Config.hexToSilence.Value || !ExUnit.IsSilenced(e)) &&
                    e.ClassId != ClassId.CDOTA_Unit_Hero_Tidehunter &&
                    Config.ItemToggler.Value.IsEnabled(sheep.Item.Name)
                    )
                {
                    sheep.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 3 &&
                    Q != null &&
                    Q.CanBeCasted() &&
                    Config.AbilityToggler.Value.IsEnabled(Q.Name) &&
                    !ExUnit.IsMagicImmune(e) &&
                    me.CanCast() &&
                    !R.IsInAbilityPhase &&
                    (W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name) || ExUnit.IsSilenced(e) || ExUnit.IsHexed(e)) &&
                    (!inOverload || inOverload && ExUnit.IsAttackImmune(e)) &&
                    distance <= Q.GetAbilityData("static_remnant_radius") + me.HullRadius
                    )
                {
                    Q.UseAbility();
                    await Await.Delay(GetAbilityDelay(me, Q) + 100, token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 4 &&
                    W != null &&
                    W.CanBeCasted() &&
                    (Config.fastVortex.Value || !R.IsInAbilityPhase && !inOverload) &&
                    (checkTimeModif || !buff) &&
                    (Config.vortexToSilence.Value || !ExUnit.IsSilenced(e)) &&
                    !me.IsAttacking() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.AbilityToggler.Value.IsEnabled(W.Name)
                    )
                {
                    W.UseAbility(e);
                    await Await.Delay(GetAbilityDelay(me, W) + 50, token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 5 &&
                    ExUnit.CanAttack(me) &&
                    !me.IsAttacking() &&
                    !ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow") &&
                    inOverload &&
                    !ExUnit.IsAttackImmune(e) &&
                    distance <= me.GetAttackRange() &&
                    !ExUnit.IsAttackImmune(e)
                    )
                {
                    me.Attack(e);
                    await Await.Delay(170, token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 6 &&
                    W != null &&
                    W.CanBeCasted() &&
                    (Config.fastVortex.Value || !inOverload) &&
                    me.AghanimState() &&
                    (checkTimeModif || !buff) &&
                    !me.IsAttacking() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.AbilityToggler.Value.IsEnabled(W.Name)
                    )
                {
                    W.UseAbility();
                    await Await.Delay(GetAbilityDelay(me, W), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 7 &&
                    atos != null &&
                    atos.Item.IsValid &&
                    atos.Item.CanBeCasted() &&
                    me.CanCast() &&
                    (checkTimeModif || !buff || !ExUnit.IsHexed(e)) &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(atos.Item.Name)
                    )
                {
                    atos.UseAbility(e);
                    await Await.Delay(GetItemDelay(e) + 100, token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 8 &&
                    ethereal != null &&
                    ethereal.Item.IsValid &&
                    ethereal.Item.CanBeCasted() &&
                    me.CanCast() &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(ethereal.Item.Name)
                    )
                {
                    if (Config.debuff.Value)
                    {
                        var speed = ethereal.Item.GetAbilityData("projectile_speed");
                        var time  = e.Distance2D(me) / speed;
                        ethereal.UseAbility(e);
                        await Await.Delay((int)(time * 1000.0f + Game.Ping) + 30, token);
                    }
                    else
                    {
                        ethereal.UseAbility(e);
                        await Await.Delay(GetItemDelay(e), token);
                    }
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 9 &&
                    dagon != null &&
                    dagon.IsValid &&
                    dagon.CanBeCasted() &&
                    Config.ItemToggler.Value.IsEnabled("item_dagon_5") &&
                    me.CanCast() &&
                    (ethereal == null ||
                     ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow") ||
                     ethereal.Item.Cooldown < 17) &&
                    !ExUnit.IsLinkensProtected(e) &&
                    !ExUnit.IsMagicImmune(e)
                    )
                {
                    dagon.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 10 &&
                    urn != null &&
                    urn.Item.IsValid && urn.Item.CanBeCasted() && urn.Item.CurrentCharges > 0 &&
                    distance <= urn.Item.GetCastRange() &&
                    Config.ItemToggler.Value.IsEnabled(urn.Item.Name)
                    )
                {
                    urn.UseAbility(e);
                    await Await.Delay(GetItemDelay(e), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 11 &&
                    bkb != null &&
                    bkb.Item.IsValid &&
                    bkb.Item.CanBeCasted() &&
                    enemies &&
                    Config.ItemToggler.Value.IsEnabled(bkb.Item.Name)
                    )
                {
                    bkb.UseAbility();
                    await Await.Delay(GetItemDelay(me), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 12 &&
                    lotus != null &&
                    lotus.Item.IsValid &&
                    lotus.Item.CanBeCasted() &&
                    enemies &&
                    Config.ItemToggler.Value.IsEnabled(lotus.Item.Name)
                    )
                {
                    lotus.UseAbility(me);
                    await Await.Delay(GetItemDelay(me), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 13 &&
                    shiva != null &&
                    shiva.Item.IsValid &&
                    shiva.Item.CanBeCasted() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(shiva.Item.Name) &&
                    distance <= 600
                    )
                {
                    shiva.UseAbility();
                    await Await.Delay(GetItemDelay(me), token);
                }
                else
                {
                    elsecount += 1;
                }
                if (elsecount == 14 &&
                    mjollnir != null &&
                    mjollnir.Item.IsValid &&
                    mjollnir.Item.CanBeCasted() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(mjollnir.Item.Name) &&
                    me.Distance2D(e) <= 600
                    )
                {
                    mjollnir.UseAbility(me);
                    await Await.Delay(GetItemDelay(me), token);
                }
            }
            else
            {
                if (Q != null &&
                    Q.CanBeCasted() &&
                    !inOverload &&
                    (W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name)) &&
                    distance <= Q.GetAbilityData("static_remnant_radius") + me.HullRadius &&
                    Config.AbilityToggler.Value.IsEnabled(Q.Name) &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e)
                    )
                {
                    Q.UseAbility();
                    await Await.Delay(GetAbilityDelay(me, Q) + 200, token);
                }

                if (shiva != null &&
                    shiva.Item.IsValid &&
                    shiva.Item.CanBeCasted() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.ItemToggler.Value.IsEnabled(shiva.Item.Name) &&
                    distance <= 600
                    )
                {
                    shiva.UseAbility();
                    await Await.Delay(GetItemDelay(me), token);
                }
                if (W != null &&
                    W.CanBeCasted() &&
                    !inOverload &&
                    me.AghanimState() &&
                    (checkTimeModif || !buff) &&
                    !me.IsAttacking() &&
                    me.CanCast() &&
                    !ExUnit.IsMagicImmune(e) &&
                    Config.AbilityToggler.Value.IsEnabled(W.Name)
                    )
                {
                    W.UseAbility();
                    await Await.Delay(GetAbilityDelay(me, W), token);
                }
            }
            Vector3 start = e.NetworkActivity == NetworkActivity.Move ? new Vector3((float)((R.GetCastDelay(me, me, true) + 0.3) * Math.Cos(e.RotationRad) * e.MovementSpeed + e.Position.X),
                                                                                    (float)((R.GetCastDelay(me, me, true) + 0.3) * Math.Sin(e.RotationRad) * e.MovementSpeed + e.NetworkPosition.Y), e.NetworkPosition.Z) : e.NetworkPosition;

            if (R != null &&
                R.CanBeCasted() &&
                !inUltBall &&
                Q.Cooldown <= 3 &&
                !R.IsInAbilityPhase &&
                !R.IsChanneling &&
                !me.IsAttacking() &&
                (W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name)) &&
                !ExUnit.IsChanneling(me) &&
                (Config.AutoOverload.Value &&
                 buff ||
                 !buff) &&
                me.Position.Distance2D(start) <= me.GetAttackRange() &&
                !ExUnit.IsMagicImmune(e) &&
                (Config.savemanamode.Value &&
                 me.AttackBackswing() > 0.3 - me.TurnTime(e.NetworkPosition) &&
                 !cooldown ||
                 !Config.savemanamode.Value) &&
                Config.AbilityToggler.Value.IsEnabled(R.Name)
                )
            {
                float   angle = e.FindAngleBetween(me.Position, true);
                Vector3 pos   = new Vector3((float)(me.Position.X - 15 * Math.Cos(angle)),
                                            (float)(me.Position.Y - 15 * Math.Sin(angle)), me.Position.Z);
                if (!inOverload)
                {
                    R.UseAbility(pos);
                    await Await.Delay(GetAbilityDelay(me, R) + 100, token);
                }
            }
            if (!ExUnit.IsAttackImmune(e) && !ExUnit.IsDisarmed(me) && !ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow"))
            {
                float   angle = e.FindAngleBetween(me.Position, true);
                Vector3 pos   = new Vector3((float)(me.Position.X + 300 * Math.Cos(angle)),
                                            (float)(me.Position.Y + 300 * Math.Sin(angle)), me.Position.Z);
                if (me.Distance2D(e) <= 250 && e.GetTurnTime(me) * 1000 < 35 && cooldown && !me.IsAttacking())
                {
                    me.Move(pos);
                    await Await.Delay((int)(me.SecondsPerAttack * 100), token);
                }
                if (me.Distance2D(e) <= 250 && !cooldown && !me.IsAttacking() && ExUnit.CanAttack(me))
                {
                    me.Attack(e);
                    await Await.Delay((int)(me.SecondsPerAttack * 100), token);
                }
                if (me.Distance2D(e) >= 250 && !cooldown && ExUnit.CanAttack(me))
                {
                    if (Orbwalker.OrbwalkTo(e))
                    {
                        return;
                    }
                }
            }
            await Await.Delay(10, token);
        }