Exemple #1
0
        private static bool ShouldActivateEvadeSpell(Spell spell)
        {
            if (ezEvade.LastPosInfo == null)
            {
                return(false);
            }

            if (ConfigValue.DodgeSkillShots.GetBool())
            {
                if (ezEvade.LastPosInfo.UndodgeableSpells.Contains(spell.SpellId) &&
                    GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.BoundingRadius))
                {
                    return(true);
                }
            }
            else
            {
                if (GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.BoundingRadius))
                {
                    return(true);
                }
            }


            /*float activationTime = Evade.menu.SubMenu("MiscSettings").SubMenu("EvadeSpellMisc").Item("EvadeSpellActivationTime")
             *  .Cast<Slider>().CurrentValue + ObjectCache.gamePing;
             *
             * if (spell.spellHitTime != float.MinValue && activationTime > spell.spellHitTime - spell.evadeTime)
             * {
             *  return true;
             * }*/

            return(false);
        }
Exemple #2
0
        public static void UseEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return;
            }

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

            if (EvadeUtils.TickCount - LastSpellEvadeCommand.Timestamp < 1000)
            {
                return;
            }
            //ConsoleDebug.WriteLineColor("Dodging Skill Shots by Evade Spell", ConsoleColor.Green);
            foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
            {
                Spell spell = entry.Value;

                if (ShouldActivateEvadeSpell(spell))
                {
                    if (ActivateEvadeSpell(spell))
                    {
                        ezEvade.SetAllUndodgeable();
                        return;
                    }
                }
            }
        }
        private static void CheckSpellCollision()
        {
            if (!ConfigValue.CheckSpellCollision.GetBool())
            {
                return;
            }

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

                var collisionObject = spell.CheckSpellCollision();

                if (collisionObject != null)
                {
                    spell.PredictedEndPos = spell.GetSpellProjection(collisionObject.ServerPosition.To2D());

                    if (spell.CurrentSpellPosition.Distance(collisionObject.ServerPosition)
                        < collisionObject.BoundingRadius + spell.Radius)
                    {
                        Core.DelayAction(() => DeleteSpell(entry.Key), 1);
                    }
                }
            }
        }
        public static List <int> GetSpellList()
        {
            List <int> spellList = new List <int>();

            foreach (KeyValuePair <int, Spell> entry in Spells)
            {
                Spell spell = entry.Value;
                spellList.Add(spell.SpellId);
            }

            return(spellList);
        }
Exemple #5
0
        public static bool InSkillShot(this Vector2 position, Spell spell, float radius, bool predictCollision = true)
        {
            if (spell.SpellType == SpellType.Line)
            {
                Vector2 spellPos    = spell.CurrentSpellPosition;
                Vector2 spellEndPos = predictCollision ? spell.GetSpellEndPosition() : spell.EndPos;

                //spellPos = spellPos - spell.direction * radius; //leave some space at back of spell
                //spellEndPos = spellEndPos + spell.direction * radius; //leave some space at the front of spell

                /*if (spell.info.projectileSpeed == float.MaxValue
                 *  && Evade.GetTickCount - spell.startTime > spell.info.spellDelay)
                 * {
                 *  return false;
                 * }*/

                var projection = position.ProjectOn(spellPos, spellEndPos);

                /*if (projection.SegmentPoint.Distance(spellEndPos) < 100) //Check Skillshot endpoints
                 * {
                 *  //unfinished
                 * }*/

                return(projection.IsOnSegment && projection.SegmentPoint.Distance(position) <= spell.Radius + radius);
            }
            else if (spell.SpellType == SpellType.Circular)
            {
                if (spell.Info.SpellName == "VeigarEventHorizon")
                {
                    return(position.Distance(spell.EndPos) <= spell.Radius + radius - GameData.HeroInfo.BoundingRadius &&
                           position.Distance(spell.EndPos) >= spell.Radius + radius - GameData.HeroInfo.BoundingRadius - 125);
                }

                return(position.Distance(spell.EndPos) <= spell.Radius + radius - GameData.HeroInfo.BoundingRadius);
            }
            else if (spell.SpellType == SpellType.Arc)
            {
                if (position.IsLeftOfLineSegment(spell.StartPos, spell.EndPos))
                {
                    return(false);
                }

                var spellRange = spell.StartPos.Distance(spell.EndPos);
                var midPoint   = spell.StartPos + spell.Direction * (spellRange / 2);

                return(position.Distance(midPoint) <= spell.Radius + radius - GameData.HeroInfo.BoundingRadius);
            }
            else if (spell.SpellType == SpellType.Cone)
            {
            }
            return(false);
        }
        public static bool CanHeroWalkIntoSpell(Spell spell)
        {
            if (ConfigValue.AdvancedSpellDetection.GetBool())
            {
                Vector2 heroPos   = MyHero.Position.To2D();
                var     extraDist = MyHero.Distance(GameData.HeroInfo.ServerPos2D);

                if (spell.SpellType == SpellType.Line)
                {
                    var walkRadius = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
                                     GameData.HeroInfo.BoundingRadius + spell.Info.Radius + extraDist + 10;
                    var spellPos    = spell.CurrentSpellPosition;
                    var spellEndPos = spell.GetSpellEndPosition();

                    var projection = heroPos.ProjectOn(spellPos, spellEndPos);

                    return(projection.SegmentPoint.Distance(heroPos) <= walkRadius);
                }
                else if (spell.SpellType == SpellType.Circular)
                {
                    var walkRadius = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
                                     GameData.HeroInfo.BoundingRadius + spell.Info.Radius + extraDist + 10;

                    if (heroPos.Distance(spell.EndPos) < walkRadius)
                    {
                        return(true);
                    }
                }
                else if (spell.SpellType == SpellType.Arc)
                {
                    var spellRange = spell.StartPos.Distance(spell.EndPos);
                    var midPoint   = spell.StartPos + spell.Direction * (spellRange / 2);
                    var arcRadius  = spell.Info.Radius * (1 + spellRange / 100);

                    var walkRadius = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
                                     GameData.HeroInfo.BoundingRadius + arcRadius + extraDist + 10;

                    if (heroPos.Distance(midPoint) < walkRadius)
                    {
                        return(true);
                    }
                }

                return(false);
            }


            return(true);
        }
        private void SpellMissile_OnCreate(GameObject obj, EventArgs args)
        {
            MissileClient missile;

            if (obj.IsMissileClient(out missile))
            {
                return;
            }

            SpellData spellData;

            if (missile.IsValidEvadeSpell(out spellData))
            {
                if (missile.IsInRange(spellData))
                {
                    var hero = missile.SpellCaster;

                    if (!hero.IsVisible && ConfigValue.DodgeFowSpells.GetBool())
                    {
                        CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
                        return;
                    }

                    if (spellData.UsePackets)
                    {
                        CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
                        return;
                    }

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

                        var dir = (missile.EndPosition.To2D() - missile.StartPosition.To2D()).Normalized();

                        if (spell.Info.MissileName == missile.SData.Name &&
                            spell.HeroId == missile.SpellCaster.NetworkId &&
                            dir.AngleBetween(spell.Direction) < 10)
                        {
                            if (spell.Info.IsThreeWay == false &&
                                spell.Info.IsSpecial == false)
                            {
                                spell.SpellObject = obj;
                            }
                        }
                    }
                }
            }
        }
Exemple #8
0
        public static int CheckPosDangerLevel(this Vector2 pos, float extraBuffer)
        {
            var dangerlevel = 0;

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

                if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
                {
                    dangerlevel += (int)spell.Dangerlevel;
                }
            }
            return(dangerlevel);
        }
Exemple #9
0
        public static bool HasExtraAvoidDistance(this Vector2 pos, float extraBuffer)
        {
            foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
            {
                Spell spell = entry.Value;

                if (spell.SpellType == SpellType.Line)
                {
                    if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Exemple #10
0
        public static bool CheckDangerousPos(this Vector2 pos, float extraBuffer, bool checkOnlyDangerous = false)
        {
            foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
            {
                Spell spell = entry.Value;

                if (checkOnlyDangerous && (int)spell.Dangerlevel < (int)SpellDangerLevel.High)
                {
                    continue;
                }

                if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
                {
                    return(true);
                }
            }
            return(false);
        }
Exemple #11
0
        public static float GetLowestEvadeTime(out Spell lowestSpell)
        {
            float lowest = float.MaxValue;

            lowestSpell = null;

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

                if (spell.SpellHitTime != float.MinValue)
                {
                    //ConsoleDebug.WriteLine("spellhittime: " + spell.spellHitTime);
                    lowest      = Math.Min(lowest, (spell.SpellHitTime - spell.EvadeTime));
                    lowestSpell = spell;
                }
            }

            return(lowest);
        }
Exemple #12
0
        //public static int CreateTestSpell(SpellPoint spell, SpellData data)
        //{
        //    if (spell.StartPosition.Distance(MyHero.Position) < data.Range + ConfigValue.ExtraDetectionRange.GetInt())
        //    {
        //        Vector2 startPosition = spell.StartPosition.To2D();
        //        Vector2 endPosition = spell.EndPosition.To2D();
        //        Vector2 direction = (endPosition - startPosition).Normalized();
        //        float endTick = 0;

        //        if (data.FixedRange) //for diana q
        //        {
        //            if (endPosition.Distance(startPosition) > data.Range)
        //            {
        //                endPosition = startPosition + direction*data.Range;
        //            }
        //        }
        //        if (data.SpellType == SpellType.Line)
        //        {
        //            endTick = data.SpellDelay + (data.Range/data.ProjectileSpeed)*1000;
        //            endPosition = startPosition + direction*data.Range;

        //            if (data.UseEndPosition)
        //            {
        //                var range = endPosition.Distance(startPosition);
        //                endTick = data.SpellDelay + (range/data.ProjectileSpeed)*1000;
        //            }
        //        }
        //        else if (data.SpellType == SpellType.Circular)
        //        {
        //            endTick = data.SpellDelay;

        //            if (data.ProjectileSpeed == 0)
        //            {
        //                endPosition = startPosition;
        //            }
        //            else if (data.ProjectileSpeed > 0)
        //            {
        //                if (data.SpellType == SpellType.Line &&
        //                    data.HasEndExplosion &&
        //                    data.UseEndPosition == false)
        //                {
        //                    endPosition = startPosition + direction*data.Range;
        //                }

        //                endTick = endTick + 1000*startPosition.Distance(endPosition)/data.ProjectileSpeed;
        //            }
        //        }
        //        else if (data.SpellType == SpellType.Arc)
        //        {
        //            endTick = endTick + 1000*startPosition.Distance(endPosition)/data.ProjectileSpeed;
        //        }
        //        else if (data.SpellType == SpellType.Cone)
        //        {
        //            return 0;
        //        }
        //        else
        //        {
        //            return 0;
        //        }
        //        Spell newSpell = new Spell();
        //        newSpell.StartTime = EvadeUtils.TickCount;
        //        newSpell.EndTime = EvadeUtils.TickCount + endTick;
        //        newSpell.StartPos = startPosition;
        //        newSpell.EndPos = endPosition;
        //        newSpell.Height = spell.EndPosition.Z + data.ExtraDrawHeight;
        //        newSpell.Direction = direction;
        //        newSpell.HeroId = 0;
        //        newSpell.Info = data;
        //        newSpell.SpellType = data.SpellType;
        //        newSpell.Radius = data.Radius > 0 ? data.Radius : newSpell.GetSpellRadius();
        //        int spellId = CreateSpell(newSpell);
        //        Core.DelayAction(() => DeleteSpell(spellId), (int) (endTick + data.ExtraEndTime));
        //        return spellId;
        //    }
        //    return 0;
        //}

        private static int CreateSpell(Spell newSpell, bool processSpell = true)
        {
            //Debug.DrawTopLeft(newSpell);
            int spellId = _spellIdCount++;

            newSpell.SpellId = spellId;

            newSpell.UpdateSpellInfo();
            DetectedSpells.Add(spellId, newSpell);

            if (processSpell)
            {
                CheckSpellCollision();
                AddDetectedSpells();
            }
            if (OnCreateSpell != null)
            {
                OnCreateSpell.Invoke(newSpell);
            }
            return(spellId);
        }
Exemple #13
0
        public static Spell GetMostDangerousSpell(bool hasProjectile = false)
        {
            int   maxDanger      = 0;
            Spell maxDangerSpell = null;

            foreach (Spell spell in Spells.Values)
            {
                if (!hasProjectile || (spell.Info.ProjectileSpeed > 0 && spell.Info.ProjectileSpeed != float.MaxValue))
                {
                    var dangerlevel = spell.Dangerlevel;

                    if ((int)dangerlevel > maxDanger)
                    {
                        maxDanger      = (int)dangerlevel;
                        maxDangerSpell = spell;
                    }
                }
            }

            return(maxDangerSpell);
        }
Exemple #14
0
        public static bool PreferEvadeSpell()
        {
            if (!Situation.ShouldUseEvadeSpell())
            {
                return(false);
            }

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

                if (!GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.BoundingRadius))
                {
                    continue;
                }

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

            return(false);
        }
Exemple #15
0
        private void CheckSpellEndTime()
        {
            foreach (KeyValuePair <int, Spell> entry in DetectedSpells)
            {
                Spell spell = entry.Value;

                foreach (var hero in EntityManager.Heroes.Enemies)
                {
                    if (hero.IsDead && spell.HeroId == hero.NetworkId)
                    {
                        if (spell.SpellObject == null)
                        {
                            Core.DelayAction(() => DeleteSpell(entry.Key), 1);
                        }
                    }
                }

                if (spell.EndTime + spell.Info.ExtraEndTime < EvadeUtils.TickCount ||
                    CanHeroWalkIntoSpell(spell) == false)
                {
                    Core.DelayAction(() => DeleteSpell(entry.Key), 1);
                }
            }
        }
Exemple #16
0
        public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
        {
            var sortedEvadeSpells = EvadeSpells.OrderBy(s => s.Dangerlevel);

            var   extraDelayBuffer    = Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
            float spellActivationTime = ConfigValue.SpellActivationTime.GetInt() + Game.Ping + extraDelayBuffer;

            if (ConfigValue.CalculateWindupDelay.GetBool())
            {
                var extraWindupDelay = ezEvade.LastWindupTime - EvadeUtils.TickCount;
                if (extraWindupDelay > 0)
                {
                    return(false);
                }
            }

            foreach (var evadeSpell in sortedEvadeSpells)
            {
                var processSpell = true;
                if (!Config.Properties.GetEvadeSpell(evadeSpell.Name).Use ||
                    ((int)GetSpellDangerLevel(evadeSpell) > (int)spell.GetSpellDangerLevel()) ||
                    (!evadeSpell.IsItem && MyHero.Spellbook.CanUseSpell(evadeSpell.SpellKey) != SpellState.Ready) ||
                    (evadeSpell.IsItem && !(Items.CanUseItem((int)evadeSpell.ItemId))) ||
                    (evadeSpell.CheckSpellName &&
                     MyHero.Spellbook.GetSpell(evadeSpell.SpellKey).Name != evadeSpell.SpellName))
                {
                    continue; //can't use spell right now
                }


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

                float finalEvadeTime = (spellHitTime - evadeTime);

                if (checkSpell)
                {
                    var mode = Config.Properties.GetEvadeSpell(evadeSpell.Name).SpellMode;

                    switch (mode)
                    {
                    case SpellModes.Undodgeable:
                        continue;

                    case SpellModes.ActivationTime:
                        if (spellActivationTime < finalEvadeTime)
                        {
                            continue;
                        }
                        break;
                    }
                }
                else
                {
                    //if (ObjectCache.menuCache.cache[evadeSpell.name + "LastResort"].Cast<CheckBox>().CurrentValue)
                    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, GameData.HeroInfo.MoveSpeed, 0, 0);

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

                if (evadeSpell.EvadeType != EvadeType.Dash && spellHitTime > evadeSpell.SpellDelay + 100 + Game.Ping +
                    Config.Properties.GetInt(ConfigValue.ExtraPingBuffer))
                {
                    processSpell = false;

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

                if (evadeSpell.IsSpecial)
                {
                    if (evadeSpell.UseSpellFunc != null)
                    {
                        if (evadeSpell.UseSpellFunc(evadeSpell, processSpell))
                        {
                            return(true);
                        }
                    }
                    continue;
                }

                if (evadeSpell.EvadeType == EvadeType.Blink)
                {
                    if (evadeSpell.CastType == CastType.Position)
                    {
                        var posInfo = EvadeHelper.GetBestPositionBlink();
                        if (posInfo != null)
                        {
                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.Position), processSpell);
                            //DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.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)
                        {
                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.Target), processSpell);
                            //DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                            return(true);
                        }
                    }
                }
                else if (evadeSpell.EvadeType == 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 - GameData.HeroInfo.ServerPos2D).Normalized();
                                var range = GameData.HeroInfo.ServerPos2D.Distance(posInfo.Position);
                                var pos   = GameData.HeroInfo.ServerPos2D - dir * range;

                                posInfo.Position = pos;
                            }

                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.Position), processSpell);
                            //DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.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)
                        {
                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.Target), processSpell);
                            //DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
                            return(true);
                        }
                    }
                }
                else if (evadeSpell.EvadeType == EvadeType.WindWall)
                {
                    if (spell.HasProjectile() || evadeSpell.SpellName == "FioraW") //TODO: temp fix, don't have fiora :'(
                    {
                        var dir = (spell.StartPos - GameData.HeroInfo.ServerPos2D).Normalized();
                        var pos = GameData.HeroInfo.ServerPos2D + dir * 100;

                        CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, pos), processSpell);
                        return(true);
                    }
                }
                else if (evadeSpell.EvadeType == EvadeType.SpellShield)
                {
                    if (evadeSpell.IsItem)
                    {
                        CastEvadeSpell(() => Items.UseItem((int)evadeSpell.ItemId), processSpell);
                        return(true);
                    }
                    else
                    {
                        if (evadeSpell.CastType == CastType.Target)
                        {
                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, MyHero), processSpell);
                            return(true);
                        }
                        else if (evadeSpell.CastType == CastType.Self)
                        {
                            CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
                            return(true);
                        }
                    }
                }
                else if (evadeSpell.EvadeType == EvadeType.MovementSpeedBuff)
                {
                }
            }

            return(false);
        }
Exemple #17
0
        private static void AddDetectedSpells()
        {
            bool spellAdded = false;

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

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

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

                var extraDelay = Game.Ping + Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);

                if (spell.SpellHitTime - extraDelay < 1500 && CanHeroWalkIntoSpell(spell))
                //if(true)
                {
                    Spell newSpell = spell;
                    int   spellId  = spell.SpellId;

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

                    //var spellFlyTime = Evade.GetTickCount - spell.startTime;
                    if (spellHitTime < ConfigValue.SpellDetectionTime.GetInt())
                    {
                        continue;
                    }

                    if (EvadeUtils.TickCount - spell.StartTime < ConfigValue.ReactionTime.GetInt())
                    {
                        continue;
                    }

                    var dodgeInterval = ConfigValue.DodgeInterval.GetInt();
                    if (ezEvade.LastPosInfo != null && dodgeInterval > 0)
                    {
                        var timeElapsed = EvadeUtils.TickCount - ezEvade.LastPosInfo.Timestamp;

                        if (dodgeInterval > timeElapsed)
                        {
                            //var delay = dodgeInterval - timeElapsed;
                            //DelayAction.Add((int)delay, () => SpellDetector_OnProcessDetectedSpells());
                            continue;
                        }
                    }

                    if (!Spells.ContainsKey(spell.SpellId))
                    {
                        if (Config.Properties.GetSpell(newSpell.Info.SpellName).Dodge&& !(ezEvade.IsDodgeDangerousEnabled() && (int)newSpell.Dangerlevel < (int)SpellDangerLevel.High))
                        {
                            if (newSpell.SpellType == SpellType.Circular &&
                                !ConfigValue.DodgeCircularSpells.GetBool())
                            {
                                //return spellID;
                                continue;
                            }

                            Spells.Add(spellId, newSpell);

                            spellAdded = true;
                        }
                    }

                    if (ConfigValue.CheckSpellCollision.GetBool() && spell.PredictedEndPos != Vector2.Zero)
                    {
                        spellAdded = false;
                    }
                }
            }

            if (spellAdded && OnProcessDetectedSpells != null)
            {
                OnProcessDetectedSpells();
            }
        }
Exemple #18
0
        public static void CreateSpellData(
            Obj_AI_Base hero,
            Vector3 spellStartPos,
            Vector3 spellEndPos,
            SpellData spellData,
            GameObject obj         = null,
            float extraEndTick     = 0.0f,
            bool processSpell      = true,
            SpellType spellType    = SpellType.None,
            bool checkEndExplosion = true,
            float spellRadius      = 0)
        {
            if (checkEndExplosion && spellData.HasEndExplosion)
            {
                CreateSpellData(hero, spellStartPos, spellEndPos,
                                spellData, obj, extraEndTick, false,
                                spellData.SpellType, false);

                CreateSpellData(hero, spellStartPos, spellEndPos,
                                spellData, obj, extraEndTick, true,
                                SpellType.Circular, false);

                return;
            }
            if (spellStartPos.Distance(MyHero.Position) < spellData.Range + ConfigValue.ExtraDetectionRange.GetInt())
            {
                Vector2 startPosition = spellStartPos.To2D();
                Vector2 endPosition   = spellEndPos.To2D();
                Vector2 direction     = (endPosition - startPosition).Normalized();
                float   endTick       = 0;

                if (spellType == SpellType.None)
                {
                    spellType = spellData.SpellType;
                }

                if (spellData.FixedRange) //for diana q
                {
                    if (endPosition.Distance(startPosition) > spellData.Range)
                    {
                        endPosition = startPosition + direction * spellData.Range;
                    }
                }
                if (spellType == SpellType.Line)
                {
                    endTick     = spellData.SpellDelay + (spellData.Range / spellData.ProjectileSpeed) * 1000;
                    endPosition = startPosition + direction * spellData.Range;

                    if (spellData.UseEndPosition)
                    {
                        var range = spellEndPos.To2D().Distance(spellStartPos.To2D());
                        endTick     = spellData.SpellDelay + (range / spellData.ProjectileSpeed) * 1000;
                        endPosition = spellEndPos.To2D();
                    }

                    if (obj != null)
                    {
                        endTick -= spellData.SpellDelay;
                    }
                }
                else if (spellType == SpellType.Circular)
                {
                    endTick = spellData.SpellDelay;

                    if (spellData.ProjectileSpeed == 0)
                    {
                        endPosition = hero.ServerPosition.To2D();
                    }
                    else if (spellData.ProjectileSpeed > 0)
                    {
                        if (spellData.SpellType == SpellType.Line &&
                            spellData.HasEndExplosion &&
                            spellData.UseEndPosition == false)
                        {
                            endPosition = startPosition + direction * spellData.Range;
                        }

                        endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.ProjectileSpeed;
                    }
                }
                else if (spellType == SpellType.Arc)
                {
                    endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.ProjectileSpeed;

                    if (obj != null)
                    {
                        endTick -= spellData.SpellDelay;
                    }
                }
                else if (spellType == SpellType.Cone)
                {
                    return;
                }
                else
                {
                    return;
                }
                endTick += extraEndTick;
                Spell newSpell = new Spell();
                newSpell.StartTime = EvadeUtils.TickCount;
                newSpell.EndTime   = EvadeUtils.TickCount + endTick;
                newSpell.StartPos  = startPosition;
                newSpell.EndPos    = endPosition;
                newSpell.Height    = spellEndPos.Z + spellData.ExtraDrawHeight;
                newSpell.Direction = direction;
                newSpell.HeroId    = hero.NetworkId;
                newSpell.Info      = spellData;
                newSpell.SpellType = spellType;
                newSpell.Radius    = spellRadius > 0 ? spellRadius : newSpell.GetSpellRadius();
                if (obj != null)
                {
                    newSpell.SpellObject  = obj;
                    newSpell.ProjectileId = obj.NetworkId;
                }
                int spellId = CreateSpell(newSpell, processSpell);
                Core.DelayAction(() => DeleteSpell(spellId), (int)(endTick + spellData.ExtraEndTime));
            }
        }
Exemple #19
0
        private void Drawing_OnDraw(EventArgs args)
        {
            if (ConfigValue.DrawEvadePosition.GetBool())
            {
                //Render.Circle.DrawCircle(myHero.Position.ExtendDir(dir, 500), 65, Color.Red, 10);

                /*foreach (var point in myHero.Path)
                 * {
                 *  Render.Circle.DrawCircle(point, 65, Color.Red, 10);
                 * }*/

                if (ezEvade.LastPosInfo != null)
                {
                    var pos = ezEvade.LastPosInfo.Position; //Evade.lastEvadeCommand.targetPosition;
                    Render.Circle.DrawCircle(new Vector3(pos.X, pos.Y, MyHero.Position.Z), 65, Color.Red, 10);
                }
            }
            //DrawPlayerPath();
            DrawEvadeStatus();

            if (!ConfigValue.DrawSkillShots.GetBool())
            {
                return;
            }

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

                var width = 0;
                switch (spell.Dangerlevel)
                {
                case SpellDangerLevel.Low:
                    width = ConfigValue.LowDangerDrawWidth.GetInt();
                    break;

                case SpellDangerLevel.Normal:
                    width = ConfigValue.NormalDangerDrawWidth.GetInt();
                    break;

                case SpellDangerLevel.High:
                    width = ConfigValue.HighDangerDrawWidth.GetInt();
                    break;

                case SpellDangerLevel.Extreme:
                    width = ConfigValue.ExtremeDangerDrawWidth.GetInt();
                    break;
                }
                if (Config.Properties.GetSpell(spell.Info.SpellName).Draw)
                {
                    if (spell.SpellType == SpellType.Line)
                    {
                        Vector2 spellPos    = spell.CurrentSpellPosition;
                        Vector2 spellEndPos = spell.GetSpellEndPosition();

                        DrawLineRectangle(spellPos, spellEndPos, (int)spell.Radius, width, GetSpellColor(spell.Dangerlevel));

                        /*foreach (var hero in ObjectManager.Get<AIHeroClient>())
                         * {
                         *  Render.Circle.DrawCircle(new Vector3(hero.ServerPosition.X, hero.ServerPosition.Y, myHero.Position.Z), (int)spell.radius, Color.Red, 5);
                         * }*/

                        if (ConfigValue.DrawSpellPosition.GetBool() && spell.SpellObject != null)
                        {
                            //spellPos = SpellDetector.GetCurrentSpellPosition(spell, true, ObjectCache.gamePing);

                            /*if (true)
                             * {
                             *  var spellPos2 = spell.startPos + spell.direction * spell.info.projectileSpeed * (Evade.GetTickCount - spell.startTime - spell.info.spellDelay) / 1000 + spell.direction * spell.info.projectileSpeed * ((float)ObjectCache.gamePing / 1000);
                             *  Render.Circle.DrawCircle(new Vector3(spellPos2.X, spellPos2.Y, myHero.Position.Z), (int)spell.radius, Color.Red, 8);
                             * }*/

                            /*if (spell.spellObject != null && spell.spellObject.IsValid && spell.spellObject.IsVisible &&
                             *    spell.spellObject.Position.To2D().Distance(ObjectCache.myHeroCache.serverPos2D) < spell.info.range + 1000)*/

                            Render.Circle.DrawCircle(new Vector3(spellPos.X, spellPos.Y, MyHero.Position.Z), (int)spell.Radius, GetSpellColor(spell.Dangerlevel), width);
                        }
                    }
                    else if (spell.SpellType == SpellType.Circular)
                    {
                        Render.Circle.DrawCircle(new Vector3(spell.EndPos.X, spell.EndPos.Y, spell.Height), (int)spell.Radius, GetSpellColor(spell.Dangerlevel), width);

                        if (spell.Info.SpellName == "VeigarEventHorizon")
                        {
                            Render.Circle.DrawCircle(new Vector3(spell.EndPos.X, spell.EndPos.Y, spell.Height), (int)spell.Radius - 125, GetSpellColor(spell.Dangerlevel), width);
                        }
                    }
                    else if (spell.SpellType == SpellType.Arc)
                    {
                        /*var spellRange = spell.startPos.Distance(spell.endPos);
                         * var midPoint = spell.startPos + spell.direction * (spellRange / 2);
                         *
                         * Render.Circle.DrawCircle(new Vector3(midPoint.X, midPoint.Y, myHero.Position.Z), (int)spell.radius, spellDrawingConfig.Color, spellDrawingWidth);
                         *
                         * Drawing.DrawLine(Drawing.WorldToScreen(spell.startPos.To3D()),
                         *               Drawing.WorldToScreen(spell.endPos.To3D()),
                         *               spellDrawingWidth, spellDrawingConfig.Color);*/
                    }
                    else if (spell.SpellType == SpellType.Cone)
                    {
                    }
                }
            }
        }