Example #1
0
        public override async Task ExecuteAsync(CancellationToken token)
        {
            try
            {
                var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;

                if (Config.TargetItem.Value.SelectedValue.Contains("Lock") && Context.TargetSelector.IsActive &&
                    (!CanExecute || EnemyHero == null || !EnemyHero.IsValid || !EnemyHero.IsAlive))
                {
                    EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
                }
                else if (Config.TargetItem.Value.SelectedValue.Contains("Default") && Context.TargetSelector.IsActive)
                {
                    EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
                }

                var Silenced = UnitExtensions.IsSilenced(base.Owner);

                if (EnemyHero != null)
                {
                    if (this.BlinkDagger != null &&
                        (this.BlinkDagger.CanBeCasted &&
                         base.Owner.Distance2D(EnemyHero) <= 1200 + sliderValue &&
                         !(base.Owner.Distance2D(EnemyHero) <= 400) &&
                         this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name)))
                    {
                        var l        = (this.Owner.Distance2D(EnemyHero) - sliderValue) / sliderValue;
                        var posA     = this.Owner.Position;
                        var posB     = EnemyHero.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);

                        this.BlinkDagger.UseAbility(position);
                        await Await.Delay(BlinkDagger.GetCastDelay(position), token);
                    }

                    if (!Silenced)
                    {
                        if (this.Config.AbilityToggler.Value.IsEnabled(this.Blast.Name) && this.Blast.CanBeCasted() && this.Blast.CanHit(EnemyHero))
                        {
                            this.Blast.UseAbility(EnemyHero);
                            await Await.Delay(this.GetAbilityDelay(base.Owner, Blast), token);
                        }
                    }

                    if (this.Basher != null &&
                        base.Owner.IsAttacking() &&
                        this.Basher.CanBeCasted &&
                        this.Basher.CanHit(EnemyHero) &&
                        this.Config.ItemToggler.Value.IsEnabled(Basher.ToString()))
                    {
                        this.Basher.UseAbility(EnemyHero);
                        await Await.Delay(Basher.GetCastDelay(EnemyHero), token);
                    }

                    if (this.Mjollnir != null &&
                        base.Owner.IsAttacking() &&
                        this.Mjollnir.CanBeCasted &&
                        this.Config.ItemToggler.Value.IsEnabled(Mjollnir.ToString()))
                    {
                        this.Mjollnir.UseAbility(base.Owner);
                        await Await.Delay(Mjollnir.GetCastDelay(Owner), token);
                    }

                    if (!UnitExtensions.IsMagicImmune(EnemyHero) &&
                        !EnemyHero.IsInvulnerable() &&
                        !UnitExtensions.HasModifier(EnemyHero, "modifier_winter_wyvern_winters_curse"))
                    {
                        if (this.BloodThorn != null &&
                            this.BloodThorn.CanBeCasted &&
                            this.BloodThorn.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.ToString()))
                        {
                            this.BloodThorn.UseAbility(EnemyHero);
                            await Await.Delay(BloodThorn.GetCastDelay(EnemyHero), token);
                        }

                        if (this.Medalion1 != null &&
                            this.Medalion1.CanBeCasted &&
                            this.Medalion1.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled(this.Medalion1.ToString()))
                        {
                            this.Medalion1.UseAbility(EnemyHero);
                            await Await.Delay(Medalion1.GetCastDelay(EnemyHero), token);
                        }

                        if (this.Medallion2 != null &&
                            this.Medallion2.CanBeCasted &&
                            this.Medallion2.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled(this.Medallion2.ToString()))
                        {
                            this.Medallion2.UseAbility(EnemyHero);
                            await Await.Delay(Medallion2.GetCastDelay(EnemyHero), token);
                        }



                        if (this.DiffBlade != null &&
                            this.DiffBlade.CanBeCasted &&
                            this.DiffBlade.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled("item_diffusal_blade_2"))
                        {
                            this.DiffBlade.UseAbility(EnemyHero);
                            await Await.Delay(DiffBlade.GetCastDelay(EnemyHero), token);
                        }

                        if (this.Orchid != null &&
                            this.Orchid.CanBeCasted &&
                            this.Orchid.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled(Orchid.ToString()))
                        {
                            this.Orchid.UseAbility(EnemyHero);
                            await Await.Delay(Orchid.GetCastDelay(EnemyHero), token);
                        }

                        if (this.Heaven != null &&
                            base.Owner.IsAttacking() &&
                            this.Heaven.CanBeCasted &&
                            this.Heaven.CanHit(EnemyHero) &&
                            this.Config.ItemToggler.Value.IsEnabled(Heaven.ToString()))
                        {
                            this.Heaven.UseAbility(EnemyHero);
                            await Await.Delay(Heaven.GetCastDelay(EnemyHero), token);
                        }
                    }

                    if (EnemyHero != null && (EnemyHero.IsInvulnerable() || UnitExtensions.IsAttackImmune(EnemyHero)))
                    {
                        Orbwalker.Move(Game.MousePosition);
                    }
                    else if (EnemyHero != null)
                    {
                        Orbwalker.OrbwalkTo(EnemyHero);
                    }
                }
                else
                {
                    Orbwalker.Move(Game.MousePosition);
                }
            }
            catch (TaskCanceledException)
            {
                // canceled
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }
Example #2
0
    void InitSwaps()
    {
        Angry.setPosition(new Position(Level.Excluded, Circle.Green));
        Blessing.setPosition(new Position(Level.Excluded, Circle.Purple));
        Child.setPosition(new Position(Level.Excluded, Circle.Red));
        Curse.setPosition(new Position(Level.Excluded, Circle.Cyan));
        Heaven.setPosition(new Position(Level.Tertiary, Circle.GreenPurpleRed));
        Happiness.setPosition(new Position(Level.Tertiary, Circle.GreenRedCyan));
        Dragon.setPosition(new Position(Level.Tertiary, Circle.RedCyanPurple));
        Dream.setPosition(new Position(Level.Secondary, Circle.CyanRed));
        Energy.setPosition(new Position(Level.Secondary, Circle.GreenRed));
        Female.setPosition(new Position(Level.Secondary, Circle.CyanPurple));
        Force.setPosition(new Position(Level.Quaternary, Circle.GreenRedCyanPurple));
        Forest.setPosition(new Position(Level.Excluded, Circle.Purple));
        Friend.setPosition(new Position(Level.Secondary, Circle.GreenPurple));
        Hate.setPosition(new Position(Level.Secondary, Circle.GreenPurple));
        Hope.setPosition(new Position(Level.Excluded, Circle.Green));
        Kindness.setPosition(new Position(Level.Tertiary, Circle.CyanPurpleGreen));
        Longevity.setPosition(new Position(Level.Secondary, Circle.CyanPurple));
        Love.setPosition(new Position(Level.Secondary, Circle.CyanPurple));
        Loyal.setPosition(new Position(Level.Secondary, Circle.GreenRed));
        Spirit.setPosition(new Position(Level.Secondary, Circle.CyanRed));
        Male.setPosition(new Position(Level.Quaternary, Circle.GreenRedCyanPurple));
        Mountain.setPosition(new Position(Level.Secondary, Circle.GreenRed));
        Night.setPosition(new Position(Level.Excluded, Circle.Red));
        Pure.setPosition(new Position(Level.Secondary, Circle.GreenPurple));
        Heart.setPosition(new Position(Level.Secondary, Circle.CyanRed));
        River.setPosition(new Position(Level.Excluded, Circle.Cyan));
        Emotion.setPosition(new Position(Level.Excluded, Circle.Cyan));
        Soul.setPosition(new Position(Level.Excluded, Circle.Purple));
        Urgency.setPosition(new Position(Level.Excluded, Circle.Red));
        Wind.setPosition(new Position(Level.Excluded, Circle.Green));

        Debug.LogFormat("[Dragon Energy #{0}] Before swapping, the displayed words are:", _moduleId);
        for (int i = 0; i < displayed.Length; i++)
        {
            Debug.LogFormat("[Dragon Energy #{0}] {1} = {2}", _moduleId, displayed[i].getWord(), displayed[i].getPosition().getCircle().ToReadable());
        }

        char[] letters    = info.GetSerialNumberLetters().ToArray();
        int    vowelCount = 0;

        foreach (char letter in letters)
        {
            if (letter == 'A' || letter == 'E' || letter == 'I' || letter == 'O' || letter == 'U')
            {
                vowelCount++;
            }
        }

        if (info.GetBatteryCount() > 10 && (info.GetSerialNumberNumbers().ToArray()[info.GetSerialNumberNumbers().ToArray().Length - 1] == 5 || info.GetSerialNumberNumbers().ToArray()[info.GetSerialNumberNumbers().ToArray().Length - 1] == 7))
        {
            Swaps(1);
        }
        else if (info.GetPortPlateCount() > info.GetBatteryHolderCount() && (modules.Contains("Morse War") || modules.Contains("Double Color")))
        {
            Swaps(2);
        }
        else if ((info.IsIndicatorOn(Indicator.SIG) && info.IsIndicatorOn(Indicator.FRK)) || (info.GetOffIndicators().Count() == 3))
        {
            Swaps(3);
        }
        else if (info.GetModuleNames().Count() > 8)
        {
            Swaps(4);
        }
        else if (vowelCount >= 2)
        {
            Swaps(5);
        }
        else if (info.GetSolvedModuleNames().Count() == 0)
        {
            Swaps(6);
            dependsOnSolvedModules = true;
        }
        else
        {
            Swaps(7);
        }

        Debug.LogFormat("[Dragon Energy #{0}] After swapping, the displayed words are:", _moduleId);
        for (int i = 0; i < displayed.Length; i++)
        {
            Debug.LogFormat("[Dragon Energy #{0}] {1} = {2}", _moduleId, displayed[i].getWord(), displayed[i].getPosition().getCircle().ToReadable());
        }
    }