Example #1
0
        public static void Init(TechiesCrappahilationPaid main)
        {
            var me = main.Me;

            UpdateManager.CreateUpdate(500, () =>
            {
                var enemies = EntityManager.GetEntities <Hero>().Where(x =>
                                                                       x.IsValid && x.Team != me.Team && !x.IsIllusion && IsHeroOrDangerUnit(x));
                foreach (var enemy in enemies)
                {
                    if (Targets.Contains(enemy))
                    {
                        continue;
                    }
                    Targets.Add(enemy);
                    main.MenuManager.Targets.AddValue(enemy.HeroId, true);
                    foreach (var bombManagerRemoteMine in main.Updater.BombManager.RemoteMines)
                    {
                        bombManagerRemoteMine.Stacker.UpdateDetonateDict();
                    }
                }

                foreach (var enemy in Targets.ToList().Where(enemy => enemy is null || !enemy.IsValid))
                {
                    Targets.Remove(enemy);
                }
            });
Example #2
0
        public PlantHelper(TechiesCrappahilationPaid main)
        {
            _main = main;

            _list = new List <Vector3>()
            {
                new Vector3(-4364, -3901, 384), new Vector3(-6591, -3075, 383), new Vector3(-3568, -6167, 376),
                new Vector3(-1389, -5230, 384), new Vector3(-2227, -2545, 256), new Vector3(-3308, -1431, 384),
                new Vector3(-906, -1483, 256), new Vector3(-588, -2026, 256), new Vector3(925, -2836, 384),
                new Vector3(1464, -4263, 384), new Vector3(2290, -4797, 383), new Vector3(1026, -5357, 384),
                new Vector3(3706, -3337, 256), new Vector3(5323, -5199, 255), new Vector3(5656, -3924, 256),
                new Vector3(5541, -2028, 256), new Vector3(3712, -2089, 256), new Vector3(4110, -1038, 376),
                new Vector3(2371, -1247, 256), new Vector3(3088, -887, 384), new Vector3(3401, 92, 384),
                new Vector3(3572, 962, 384), new Vector3(5125, -138, 381), new Vector3(5554, 1263, 384),
                new Vector3(1009, 2236, 384), new Vector3(-272, 1821, 384), new Vector3(-1735, 3676, 384),
                new Vector3(1501, 4175, 383), new Vector3(456, 5074, 384), new Vector3(-1223, 4849, 384),
                new Vector3(-951, 3809, 384), new Vector3(-2560, 3747, 255), new Vector3(-3624, 3730, 255),
                new Vector3(-3016, 3654, 128), new Vector3(-4059, 1919, 256), new Vector3(-2384, 1800, 159),
                new Vector3(-1710, 1152, 128), new Vector3(-2068, 505, 255), new Vector3(-2841, 296, 384),
                new Vector3(-2077, -75, 256), new Vector3(1139, 1169, 256), new Vector3(1621, 77, 256),
                new Vector3(1409, 117, 256), new Vector3(2389, -1841, 128), new Vector3(-4593, 715, 384),
                new Vector3(-4326, 102, 384), new Vector3(-5299, 379, 384), new Vector3(-5187, -1619, 384),
                new Vector3(-5454, 2247, 255), new Vector3(-5873, 3921, 256), new Vector3(-5696, 4473, 256),
                new Vector3(-5332, 5005, 256), new Vector3(-6565, 5236, 256), new Vector3(-6829, 3761, 256),
                new Vector3(-5930, 2071, 256), new Vector3(-2602, 5720, 256),
                new Vector3(-1185, 5668, 256), new Vector3(2382, -3767, 384), new Vector3(-843, -3988, 384),
                new Vector3(-2534, -3585, 256), new Vector3(-2185, -4082, 256), new Vector3(-1547, -3293, 256),
                new Vector3(-1058, -2581, 256), new Vector3(5119, -3360, 256),
                new Vector3(6821, -3270, 256)
            };

            var enable = main.MenuManager.GoodPositions.CreateSwitcher("Show good position for planting", false);

            _range = main.MenuManager.GoodPositions.CreateSlider("Range ", 425, 25, 425);

            _range.ValueChanged += (sender, args) => { Draw(); };

            /*if (enable)
             * {
             *  Draw();
             * }*/

            enable.ValueChanged += (sender, args) =>
            {
                if (args.Value)
                {
                    Draw();
                }
                else
                {
                    var index = 0;
                    foreach (var pos in _list)
                    {
                        ParticleManager.RemoveParticle($"{index++}_pos_helper");
                    }
                }
            };
        }
Example #3
0
        public StackInfo(TechiesCrappahilationPaid main)
        {
            _main = main;
            // inputManager.MouseClick += MouseClick;
            InputManager.MouseKeyUp += MouseClick;
            if (main.MenuManager.DrawStacks)
            {
                RendererManager.Draw += RenderManagerOnDraw;
            }

            main.MenuManager.DrawStacks.ValueChanged += (sender, args) =>
            {
                if (main.MenuManager.DrawStacks)
                {
                    RendererManager.Draw += RenderManagerOnDraw;
                }
                else
                {
                    RendererManager.Draw -= RenderManagerOnDraw;
                }
            };
            ModifierManager.ModifierAdded += (sender) =>
            {
                var bomb = main.Updater.BombManager.RemoteMines.FirstOrDefault(x => x.Owner == sender.Modifier.Owner);
                if (bomb != null)
                {
                    if (sender.Modifier.Name == "modifier_truesight")
                    {
                        bomb.UnderTrueSight = true;
                    }
                }
            };

            ModifierManager.ModifierRemoved += (sender) =>
            {
                var bomb = main.Updater.BombManager.RemoteMines.FirstOrDefault(x => x.Owner == sender.Modifier.Owner);
                if (bomb != null)
                {
                    if (sender.Modifier.Name == "modifier_truesight")
                    {
                        bomb.UnderTrueSight = false;
                    }
                }
            };
        }
Example #4
0
        public ViewManager(TechiesCrappahilationPaid main)
        {
            Main = main;

            InterfaceType = Main.MenuManager.DamagePanel.CreateSwitcher("Damage drawing");
            // new StringList("Movable Panel", "[not implemented] Top panel"));
            dict = new Dictionary <AbilityId, bool>
            {
                { AbilityId.techies_remote_mines, true },
                { AbilityId.techies_suicide, true },
                { AbilityId.techies_land_mines, true }
            };
            AbilityToggle = Main.MenuManager.DamagePanel.CreateAbilityToggler("Show damage counter", dict);

            AbilityToggle.ValueChanged += (sender, args) => { EnabledList = GetEnabledAbilities(); };
            ShowDamageType              = Main.MenuManager.DamagePanel.
                                          CreateSelector("Bomb damage draw type", new [] { "Only for current hp", "Only for max hp", "For current & max hp" });
            // new StringList());

            PositionX = Main.MenuManager.DamagePanel.CreateSlider("Extra Position X",
                                                                  0, -1000, 4000);
            PositionY = Main.MenuManager.DamagePanel.CreateSlider("Extra Position Y",
                                                                  0, -1000, 4000);

            if (InterfaceType.Value)
            {
                ChangeView(new ViewOnMovablePanel(this));
            }
            else
            {
                ChangeView(new ViewOnTopPanel(this));
            }
            InterfaceType.ValueChanged += (sender, args) =>
            {
                if (args.Value)
                {
                    ChangeView(new ViewOnMovablePanel(this));
                }
                else
                {
                    ChangeView(new ViewOnTopPanel(this));
                }
            };
        }
Example #5
0
        public Updater(TechiesCrappahilationPaid main)
        {
            _main = main;

            DamageChecker = new DamageChecker(this);

            DamageChecker.OnAghanimStatusChanging += OnChange;

            BombManager = new BombManager(this);

            BombDamageManager = new BombDamageManager(this);

            UpdateManager.CreateUpdate(500, () =>
            {
                Eul        = O9K.Core.Managers.Entity.EntityManager9.GetAbility <EulsScepterOfDivinity>(EntityManager.LocalHero.Handle);
                ForceStaff = O9K.Core.Managers.Entity.EntityManager9.GetAbility <ForceStaff>(EntityManager.LocalHero.Handle);
                Hex        = O9K.Core.Managers.Entity.EntityManager9.GetAbility <ScytheOfVyse>(EntityManager.LocalHero.Handle);
            });
        }
Example #6
0
 protected ViewBombCountBase(ViewManager main)
 {
     Main                    = main.Main;
     ViewManager             = main;
     ViewManager.EnabledList = ViewManager.GetEnabledAbilities();
 }
Example #7
0
        public SuicideDamage(TechiesCrappahilationPaid main)
        {
            _main = main;
            var suicide = main.MenuManager.VisualSubMenu.CreateMenu("Suicide");

            ShowSuicideDamage = suicide.CreateSwitcher("Show suicide damage on heroes", true);
            SuicideType       = suicide.CreateSwitcher("Suicide Draw type" /*, new StringList("text", "icon")*/);
            var settings = suicide.CreateMenu("Settings");

            PositionX = settings.CreateSlider("extra position x", 0, -100, 100);
            PositionY = settings.CreateSlider("extra position y", 0, -100, 100);
            TextSize  = settings.CreateSlider("text size", 13, 5, 25);

            PlayerPositions = new Dictionary <Hero, Vector2>();

            RendererManager.Draw += () =>
            {
                foreach (var enemy in TargetManager.Targets)
                {
                    if (enemy != null && enemy.IsValid)
                    {
                        if (PlayerPositions.ContainsKey(enemy))
                        {
                            PlayerPositions[enemy] = CustomHUDInfo.GetHpBarPosition(enemy);
                        }
                        else
                        {
                            PlayerPositions.Add(enemy, CustomHUDInfo.GetHpBarPosition(enemy));
                        }
                    }
                }
            };

            RendererManager.Draw += () =>
            {
                if (!ShowSuicideDamage.Value)
                {
                    return;
                }
                foreach (var g in PlayerPositions.ToList())
                {
                    var enemy = g.Key;
                    if (!_main.Updater.BombDamageManager.DamageDictionary.ContainsKey(enemy.HeroId) ||
                        !enemy.IsVisible || !enemy.IsAlive)
                    {
                        continue;
                    }
                    var pos = g.Value;
//                    var w2s = Drawing.WorldToScreen(pos);
                    if (pos.IsZero)
                    {
                        continue;
                    }
                    var drawPos = pos;
                    // if (SuicideType.Value.SelectedIndex == 0)
                    if (SuicideType.Value)
                    {
                        var damage = Math
                                     .Round(_main.Updater.BombDamageManager.DamageDictionary[enemy.HeroId].HealthAfterSuicide, 1)
                                     .ToString(CultureInfo.InvariantCulture);
                        var size = RendererManager.MeasureText(damage, TextSize);
                        drawPos.X -= size.X + 5;
                        RendererManager.DrawFilledRectangle(
                            new RectangleF(drawPos.X - 1 + PositionX, drawPos.Y + PositionY, size.X, size.Y),
                            Color.Black,
                            Color.Black, 1);
                        RendererManager.DrawText(damage, drawPos + new Vector2(PositionX, PositionY), Color.White,
                                                 TextSize);
                    }
                    else
                    {
                        var willDie = _main.Updater.BombDamageManager.DamageDictionary[enemy.HeroId].HeroWillDieSuicide;
                        var rect    = new RectangleF(drawPos.X - 26 + PositionX, drawPos.Y + PositionY, TextSize * 2 - 2,
                                                     TextSize * 2 - 2);
                        RendererManager.DrawTexture($"{AbilityId.techies_suicide}_icon", rect);
                        var clr = willDie ? Color.LimeGreen : Color.Red;
                        RendererManager.DrawFilledRectangle(rect,
                                                            new SharpDX.Color((float)clr.R, clr.G, clr.B, 35),
                                                            willDie ? Color.LimeGreen : Color.Red, 0.5f);
                    }
                }
            };
        }
Example #8
0
        public static void Init(TechiesCrappahilationPaid main)
        {
            _main = main;
            var autoPlanting             = main.MenuManager.AutoPlanting;
            var remoteMinePlantCorrector =
                autoPlanting.CreateSwitcher("Help to plant mines in one place", true);
            var enableRemoteMines =
                autoPlanting.CreateToggleKey("Auto remote mine on last cast");
            var enablePoximityMines =
                autoPlanting.CreateSwitcher("Auto proximity mines on base", false);

            MinesAutoMovingToStun   = autoPlanting.CreateSwitcher("Move proximity mines on closest stun position", false);
            RangeForMinesAutoMoving = autoPlanting.CreateSlider("Range for auto moving", 1500, 700, 2000);
            var sub  = UpdateManager.CreateUpdate(500, enableRemoteMines, Callback);
            var sub2 = UpdateManager.CreateUpdate(500, enablePoximityMines, AutoProximityMinesCallBack);

            enableRemoteMines.ValueChanged += (sender, args) =>
            {
                sub.IsEnabled = enableRemoteMines;
                if (!enableRemoteMines)
                {
                    Effect?.Dispose();
                }
            };
            enablePoximityMines.ValueChanged += (sender, args) =>
            {
//                var landMinesOnBase =
//                    _main.Updater.BombManager.LandMines.Where(x => Math.Abs(x.Owner.Position.Z - 384f) < 1);
//                var sb = new StringBuilder();
//                foreach (var landMine in landMinesOnBase.Select(x => x.Owner))
//                {
//                    var pos = landMine.Position;
//                    var x = $"{pos.X}f".Replace(",", ".");
//                    var y = $"{pos.Y}f".Replace(",", ".");
//                    var z = $"{pos.Z}f".Replace(",", ".");
//                    sb.Append($"new Vector3({x},{y},{z}),");
//                }
//
//                Console.WriteLine(sb);

                sub2.IsEnabled = args.Value;
            };
            OrderManager.OrderAdding += args =>
            {
                if (args.IsCustom)
                {
                    return;
                }
                if (enableRemoteMines)
                {
                    var ability = args.Order.Ability;
                    var pos     = args.Order.Position;
                    if (ability == null || ability.Id != AbilityId.techies_remote_mines || pos.IsZero)
                    {
                        return;
                    }
                    LastPosition = pos;
                    Effect?.Dispose();
                    Effect = ParticleManager.CreateParticle("materials/ensage_ui/particles/range_display_mod.vpcf", LastPosition);
                    Effect.SetControlPoint(1, new Vector3(50, 255, 0));
                    Effect.SetControlPoint(2, new Vector3(0, 255, 255));
                }

                if (remoteMinePlantCorrector)
                {
                    var ability = args.Order.Ability;
                    var pos     = args.Order.Position;
                    if (ability == null ||
                        (ability.Id != AbilityId.techies_remote_mines && ability.Id != AbilityId.techies_land_mines &&
                         ability.Id != AbilityId.techies_stasis_trap) || pos.IsZero)
                    {
                        return;
                    }
                    var closest = main.Updater.BombManager.FullBombList.Where(x => x.Owner.IsInRange(pos, 200))
                                  .OrderBy(x => pos.Distance2D(x.Owner.Position)).FirstOrDefault();
                    if (closest != null)
                    {
                        args.Process = false;
                        ability.Cast(closest.Owner.Position);
                    }
                }

                // if (enableRemoteMines)
                // {
                //     var ability = args.Ability;
                //     var pos = args.TargetPosition;
                //     if (ability == null || ability.Id != AbilityId.techies_land_mines || pos.IsZero) return;
                //     LastPosition2 = pos;
                //     Effect2?.Dispose();
                //     Effect2 = new ParticleEffect("materials/ensage_ui/particles/range_display_mod.vpcf", LastPosition2);
                //     Effect2.SetControlPoint(1, new Vector3(50, 255, 0));
                //     Effect2.SetControlPoint(2, new Vector3(255, 0, 255));
                // }
            };
        }