コード例 #1
0
        public static void UseEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return;
            }

            //int posDangerlevel = EvadeHelper.CheckPosDangerLevel(ObjectCache.myHeroCache.serverPos2D, 0);

            if (EvadeUtils.TickCount - lastSpellEvadeCommand.timestamp < 1000)
            {
                return;
            }

            foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
            {
                Spell spell = entry.Value;

                if (ShouldActivateEvadeSpell(spell))
                {
                    if (ActivateEvadeSpell(spell))
                    {
                        Evade.SetAllUndodgeable();
                        return;
                    }
                }
            }
        }
コード例 #2
0
        public static bool PreferEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return(false);
            }

            return(SpellDetector.spells.Select(entry => entry.Value).Where(spell => ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius)).Any(spell => ActivateEvadeSpell(spell, true)));
        }
コード例 #3
0
        public static bool PreferEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return(false);
            }

            var   extraDelayBuffer = Evade.menu.Item("ExtraPingBuffer").GetValue <Slider>().Value;
            float fastEvadeTime    = Evade.menu.Item("SpellActivationTime").GetValue <Slider>().Value + Game.Ping + extraDelayBuffer;

            foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
            {
                Spell spell = entry.Value;

                if (!EvadeHelper.InSkillShot(spell, myHero.ServerPosition.To2D(), myHero.BoundingRadius))
                {
                    continue;
                }

                float rEvadeTime, rSpellHitTime = 0;
                spell.CanHeroEvade(myHero, out rEvadeTime, out rSpellHitTime);

                float finalEvadeTime = (rSpellHitTime - rEvadeTime);

                if (finalEvadeTime < fastEvadeTime)
                {
                    foreach (var evadeSpell in evadeSpells)
                    {
                        if (Evade.menu.SubMenu("EvadeSpells").SubMenu(evadeSpell.charName + evadeSpell.name + "EvadeSpellSettings")
                            .Item(evadeSpell.name + "UseEvadeSpell").GetValue <bool>() == false ||
                            GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() ||
                            (evadeSpell.isItem == false && !(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready)) ||
                            (evadeSpell.isItem == true && !(Items.CanUseItem((int)evadeSpell.itemID))) ||
                            (evadeSpell.checkSpellName == true && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
                        {
                            continue; //can't use spell right now
                        }

                        return(true);
                    }
                }
            }

            return(false);
        }
コード例 #4
0
        public static void UseEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return;
            }

            //int posDangerlevel = EvadeHelper.CheckPosDangerLevel(ObjectCache.myHeroCache.serverPos2D, 0);

            if (EvadeUtils.TickCount - lastSpellEvadeCommand.timestamp < 1000)
            {
                return;
            }

            if (SpellDetector.spells.Select(entry => entry.Value).Where(ShouldActivateEvadeSpell).Any(spell => ActivateEvadeSpell(spell)))
            {
                Evade.SetAllUndodgeable();
                return;
            }
        }
コード例 #5
0
        public static bool PreferEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return(false);
            }

            foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
            {
                Spell spell = entry.Value;

                if (!ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
                {
                    continue;
                }

                if (ActivateEvadeSpell(spell, true))
                {
                    return(true);
                }
            }

            return(false);
        }
コード例 #6
0
        public static void UseEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return;
            }

            //int posDangerlevel = EvadeHelper.CheckPosDangerLevel(myHero.ServerPosition.To2D(), 0);

            if (Evade.GetTickCount() - lastSpellEvadeCommand.timestamp < 1000)
            {
                return;
            }

            foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
            {
                Spell spell = entry.Value;

                if (ShouldActivateEvadeSpell(spell))
                {
                    foreach (var evadeSpell in evadeSpells)
                    {
                        if (Evade.menu.SubMenu("EvadeSpells").SubMenu(evadeSpell.charName + evadeSpell.name + "EvadeSpellSettings")
                            .Item(evadeSpell.name + "UseEvadeSpell").GetValue <bool>() == false ||
                            GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() ||
                            (evadeSpell.isItem == false && !(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready)) ||
                            (evadeSpell.isItem == true && !(Items.CanUseItem((int)evadeSpell.itemID))) ||
                            (evadeSpell.checkSpellName == true && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
                        {
                            continue; //can't use spell right now
                        }

                        if (evadeSpell.evadeType == EvadeType.Blink)
                        {
                            if (evadeSpell.castType == CastType.Position)
                            {
                                var posInfo = EvadeHelper.GetBestPositionBlink();
                                if (posInfo != null)
                                {
                                    EvadeCommand.CastSpell(evadeSpell, posInfo.position);
                                    //Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                                }
                            }
                            else if (evadeSpell.castType == CastType.Target)
                            {
                                var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
                                if (posInfo != null)
                                {
                                    EvadeCommand.CastSpell(evadeSpell, posInfo.position);
                                    //Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                                }
                            }
                        }
                        else if (evadeSpell.evadeType == EvadeType.Dash)
                        {
                            if (evadeSpell.castType == CastType.Position)
                            {
                                var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
                                if (posInfo != null)
                                {
                                    if (evadeSpell.isReversed)
                                    {
                                        var dir   = (posInfo.position - myHero.ServerPosition.To2D()).Normalized();
                                        var range = myHero.ServerPosition.To2D().Distance(posInfo.position);
                                        var pos   = myHero.ServerPosition.To2D() - dir * range;

                                        posInfo.position = pos;
                                    }

                                    EvadeCommand.CastSpell(evadeSpell, posInfo.position);
                                    //Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                                }
                            }
                            else if (evadeSpell.castType == CastType.Target)
                            {
                                var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
                                if (posInfo != null)
                                {
                                    EvadeCommand.CastSpell(evadeSpell, posInfo.position);
                                    //Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                                }
                            }
                        }
                        else if (evadeSpell.evadeType == EvadeType.SpellShield)
                        {
                            if (evadeSpell.isItem)
                            {
                                Items.UseItem((int)evadeSpell.itemID);
                            }
                            else
                            {
                                EvadeCommand.CastSpell(evadeSpell);
                            }
                        }

                        return;
                    }
                }
            }
        }