Exemple #1
0
        public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
        {
            if (spell.Info.SpellName.Contains("_trap"))
            {
                return(false);
            }

            var sortedEvadeSpells = EvadeSpells.OrderBy(s => s.Dangerlevel);

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

            if (ObjectCache.MenuCache.Cache["CalculateWindupDelay"].Enabled)
            {
                var extraWindupDelay = Evade.LastWindupTime - Environment.TickCount;
                if (extraWindupDelay > 0)
                {
                    return(false);
                }
            }

            foreach (var evadeSpell in sortedEvadeSpells)
            {
                var processSpell = true;

                if (!Evade.EvadeSpellMenu[evadeSpell.CharName + evadeSpell.Name + "EvadeSpellSettings"][evadeSpell.Name + "UseEvadeSpell"].Enabled ||
                    GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() || !MyHero.SpellBook.CanUseSpell(evadeSpell.SpellKey) ||
                    evadeSpell.CheckSpellName && MyHero.SpellBook.GetSpell(evadeSpell.SpellKey).Name != evadeSpell.SpellName)
                {
                    continue;
                }

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

                var finalEvadeTime = spellHitTime - evadeTime;

                if (checkSpell)
                {
                    var mode = Evade.EvadeSpellMenu[evadeSpell.CharName + evadeSpell.Name + "EvadeSpellSettings"][evadeSpell.Name + "EvadeSpellMode"].As <MenuList>().Value;

                    switch (mode)
                    {
                    case 0: continue;

                    case 1:
                        if (spellActivationTime < finalEvadeTime)
                        {
                            continue;
                        }
                        break;
                    }
                }
                else
                {
                    if (evadeSpell.SpellDelay <= 50 && evadeSpell.EvadeType != EvadeType.Dash)
                    {
                        var path = MyHero.Path;
                        if (path.Length > 0)
                        {
                            var movePos = path[path.Length - 1].To2D();
                            var posInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.MyHeroCache.MoveSpeed, 0, 0);

                            if (GetSpellDangerLevel(evadeSpell) > posInfo.PosDangerLevel)
                            {
                                continue;
                            }
                        }
                    }
                }

                if (evadeSpell.EvadeType != EvadeType.Dash && spellHitTime > evadeSpell.SpellDelay + 100 + Game.Ping + ObjectCache.MenuCache.Cache["ExtraPingBuffer"].As <MenuSlider>().Value)
                {
                    processSpell = false;

                    if (checkSpell == false)
                    {
                        continue;
                    }
                }

                if (evadeSpell.IsSpecial)
                {
                    if (evadeSpell.UseSpellFunc == null)
                    {
                        continue;
                    }
                    if (evadeSpell.UseSpellFunc(evadeSpell, processSpell))
                    {
                        return(true);
                    }
                }
                else
                {
                    switch (evadeSpell.EvadeType)
                    {
                    case EvadeType.Blink:
                        if (evadeSpell.CastType == CastType.Position)
                        {
                            var posInfo = EvadeHelper.GetBestPositionBlink();
                            if (posInfo != null)
                            {
                                if (processSpell)
                                {
                                    MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, posInfo.Position.To3D());
                                }
                                //CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
                                //DelayAction.Add(50, () => myHero.IssueOrder(OrderType.MoveTo, posInfo.position.To3D()));
                                return(true);
                            }
                        }
                        else if (evadeSpell.CastType == CastType.Target)
                        {
                            var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
                            if (posInfo != null && posInfo.Target != null && posInfo.PosDangerLevel == 0)
                            {
                                if (processSpell)
                                {
                                    MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, posInfo.Target);
                                }
                                //CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
                                //DelayAction.Add(50, () => myHero.IssueOrder(OrderType.MoveTo, posInfo.position.To3D()));
                                return(true);
                            }
                        }
                        break;

                    case EvadeType.Dash:
                        if (evadeSpell.CastType == CastType.Position)
                        {
                            var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
                            if (posInfo != null && CompareEvadeOption(posInfo, checkSpell))
                            {
                                if (evadeSpell.IsReversed)
                                {
                                    var dir   = (posInfo.Position - ObjectCache.MyHeroCache.ServerPos2D).Normalized();
                                    var range = ObjectCache.MyHeroCache.ServerPos2D.Distance(posInfo.Position);
                                    var pos   = ObjectCache.MyHeroCache.ServerPos2D - dir * range;

                                    posInfo.Position = pos;
                                }

                                if (processSpell)
                                {
                                    MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, posInfo.Position.To3D());
                                }

                                return(true);
                            }
                        }
                        else if (evadeSpell.CastType == CastType.Target)
                        {
                            var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
                            if (posInfo != null && posInfo.Target != null && posInfo.PosDangerLevel == 0)
                            {
                                if (processSpell)
                                {
                                    MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, posInfo.Target);
                                }

                                return(true);
                            }
                        }
                        break;

                    case EvadeType.WindWall:
                        if (spell.HasProjectile() || evadeSpell.SpellName == "FioraW")
                        {
                            var dir = (spell.StartPos - ObjectCache.MyHeroCache.ServerPos2D).Normalized();
                            var pos = ObjectCache.MyHeroCache.ServerPos2D + dir * 100;

                            if (processSpell)
                            {
                                MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, pos.To3D());
                            }

                            return(true);
                        }
                        break;

                    case EvadeType.SpellShield:
                        if (evadeSpell.IsItem)
                        {
                            if (processSpell)
                            {
                                MyHero.SpellBook.CastSpell(evadeSpell.SpellKey);
                            }
                            //CastEvadeSpell(() => myHero.SpellBook.CastSpell(evadeSpell.spellKey), processSpell);
                            return(true);
                        }

                        switch (evadeSpell.CastType)
                        {
                        case CastType.Target:
                            if (processSpell)
                            {
                                MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, MyHero);
                            }
                            // CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), processSpell);
                            return(true);

                        case CastType.Self:
                            if (processSpell)
                            {
                                MyHero.SpellBook.CastSpell(evadeSpell.SpellKey);
                            }
                            //CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
                            return(true);
                        }

                        break;

                    case EvadeType.MovementSpeedBuff:
                        if (evadeSpell.IsItem)
                        {
                            var posInfo = EvadeHelper.GetBestPosition();
                            if (posInfo != null)
                            {
                                if (processSpell)
                                {
                                    MyHero.SpellBook.CastSpell(evadeSpell.SpellKey);
                                }
                                //CastEvadeSpell(() => myHero.SpellBook.CastSpell(evadeSpell.spellKey), processSpell);
                                DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.Position));
                                return(true);
                            }
                        }
                        else
                        {
                            switch (evadeSpell.CastType)
                            {
                            case CastType.Self:
                            {
                                var posInfo = EvadeHelper.GetBestPosition();
                                if (posInfo != null)
                                {
                                    if (processSpell)
                                    {
                                        MyHero.SpellBook.CastSpell(evadeSpell.SpellKey);
                                    }
                                    //CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
                                    DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.Position));
                                    return(true);
                                }
                                break;
                            }

                            case CastType.Position:
                            {
                                var posInfo = EvadeHelper.GetBestPosition();
                                if (posInfo != null)
                                {
                                    if (processSpell)
                                    {
                                        MyHero.SpellBook.CastSpell(evadeSpell.SpellKey, posInfo.Position.To3D());
                                    }
                                    //CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
                                    DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.Position));
                                    return(true);
                                }
                                break;
                            }

                            case CastType.Target: break;

                            default: throw new ArgumentOutOfRangeException();
                            }
                        }
                        break;
                    }
                }
            }

            return(false);
        }