Пример #1
0
        private static void DrawEvadeStatus()
        {
            if (!ObjectCache.MenuCache.Cache["ShowStatus"].Enabled)
            {
                return;
            }

            Render.WorldToScreen(ObjectManager.GetLocalPlayer().Position, out var heroPos);

            if (ObjectCache.MenuCache.Cache["DodgeSkillShots"].Enabled)
            {
                if (Evade.IsDodging)
                {
                    Render.Text("Evade: ON", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Red);
                }
                else
                {
                    if (ObjectCache.MenuCache.Cache["DodgeOnlyOnComboKeyEnabled"].Enabled && !ObjectCache.MenuCache.Cache["DodgeComboKey"].As <MenuKeyBind>().Enabled)
                    {
                        Render.Text("Evade: OFF", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Gray);
                    }
                    else
                    {
                        if (ObjectCache.MenuCache.Cache["DontDodgeKeyEnabled"].Enabled && ObjectCache.MenuCache.Cache["DontDodgeKey"].As <MenuKeyBind>().Enabled)
                        {
                            Render.Text("Evade: OFF", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Gray);
                        }
                        else if (Evade.IsDodgeDangerousEnabled())
                        {
                            Render.Text("Evade: ON", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Yellow);
                        }
                        else
                        {
                            Render.Text("Evade: ON", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Lime);
                        }
                    }
                }
            }
            else
            {
                if (ObjectCache.MenuCache.Cache["ActivateEvadeSpells"].As <MenuKeyBind>().Enabled)
                {
                    if (ObjectCache.MenuCache.Cache["DodgeOnlyOnComboKeyEnabled"].Enabled && !ObjectCache.MenuCache.Cache["DodgeComboKey"].As <MenuKeyBind>().Enabled)
                    {
                        Render.Text("Evade: OFF", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Gray);
                    }
                    else
                    {
                        Render.Text("Evade: Spell", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Evade.IsDodgeDangerousEnabled() ? Color.Yellow : Color.DeepSkyBlue);
                    }
                }
                else
                {
                    Render.Text("Evade: OFF", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Gray);
                }
            }
        }
Пример #2
0
        private void DrawEvadeStatus()
        {
            if (ConfigValue.DrawEvadeStatus.GetBool())
            {
                var heroPos   = Drawing.WorldToScreen(ObjectManager.Player.Position);
                var dimension = Drawing.GetTextEntent("Evade: ON", 12);

                if (ConfigValue.DodgeSkillShots.GetBool())
                {
                    if (Evade.IsDodging)
                    {
                        Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.Red, "Evade: ON");
                    }
                    else
                    {
                        if (Evade.IsDodgeDangerousEnabled())
                        {
                            Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.Yellow, "Evade: ON");
                        }
                        else
                        {
                            Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.White, "Evade: ON");
                        }
                    }
                }
                else
                {
                    if (ConfigValue.ActivateEvadeSpells.GetBool())
                    {
                        Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.Purple, "Evade: Spell");
                    }
                    else
                    {
                        Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.Gray, "Evade: OFF");
                    }
                }
            }
        }
Пример #3
0
        private static void AddDetectedSpells()
        {
            var spellAdded = false;

            foreach (var entry in DetectedSpells)
            {
                var spell = entry.Value;
                if (!spell.Info.SpellName.Contains("_trap"))
                {
                    EvadeHelper.FastEvadeMode = Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][spell.Info.SpellName + "FastEvade"].Enabled;
                }

                spell.CanHeroEvade(MyHero, out var evadeTime, out var spellHitTime);

                spell.SpellHitTime = spellHitTime;
                spell.EvadeTime = evadeTime;

                var extraDelay = ObjectCache.GamePing + ObjectCache.MenuCache.Cache["ExtraPingBuffer"].As<MenuSlider>().Value;

                if (!(spell.SpellHitTime - extraDelay < 1500) || !CanHeroWalkIntoSpell(spell))
                {
                    continue;
                }

                var newSpell = spell;
                var spellId = spell.SpellId;

                if (!DrawSpells.ContainsKey(spell.SpellId))
                {
                    DrawSpells.Add(spellId, newSpell);
                }

                if (spellHitTime < ObjectCache.MenuCache.Cache["SpellDetectionTime"].As<MenuSlider>().Value &&
                    !Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][spell.Info.SpellName + "FastEvade"].Enabled)
                {
                    continue;
                }

                if (Environment.TickCount - spell.StartTime < ObjectCache.MenuCache.Cache["ReactionTime"].As<MenuSlider>().Value &&
                    !Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][spell.Info.SpellName + "FastEvade"].Enabled)
                {
                    continue;
                }

                var dodgeInterval = ObjectCache.MenuCache.Cache["DodgeInterval"].As<MenuSlider>().Value;
                if (Evade.LastPosInfo != null && dodgeInterval > 0)
                {
                    var timeElapsed = Environment.TickCount - Evade.LastPosInfo.Timestamp;

                    if (dodgeInterval > timeElapsed && !Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][spell.Info.SpellName + "FastEvade"].Enabled)
                    {
                        continue;
                    }
                }

                if (!Spells.ContainsKey(spell.SpellId))
                {
                    if (!(Evade.IsDodgeDangerousEnabled() && newSpell.GetSpellDangerLevel() < 3) &&
                        Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][newSpell.Info.SpellName + "DodgeSpell"].Enabled)
                    {
                        if (newSpell.SpellType == SpellType.Circular && !ObjectCache.MenuCache.Cache["DodgeCircularSpells"].Enabled)
                        {
                            continue;
                        }

                        var healthThreshold = Evade.SpellMenu[spell.Info.CharName + spell.Info.SpellName + "Settings"][spell.Info.SpellName + "DodgeIgnoreHP"].As<MenuSlider>().Value;
                        if (MyHero.HealthPercent() <= healthThreshold)
                        {
                            Spells.Add(spellId, newSpell);
                            spellAdded = true;
                        }
                    }
                }

                if (ObjectCache.MenuCache.Cache["CheckSpellCollision"].Enabled && spell.PredictedEndPos != Vector2.Zero)
                {
                    spellAdded = false;
                }
            }

            if (spellAdded)
            {
                OnProcessDetectedSpells?.Invoke();
            }
        }