コード例 #1
0
ファイル: Skillshot.cs プロジェクト: Dekryptor/Port-1
        public Skillshot(DetectionType detectionType, SpellData spellData, int startT, Vector2 start, Vector2 end, Obj_AI_Base unit)
        {
            DetectionType   = detectionType;
            SpellData       = spellData;
            StartTick       = startT;
            Start           = start;
            End             = end;
            MissilePosition = start;
            Direction       = (end - start).Normalized();

            Unit = unit;

            switch (spellData.Type)
            {
            case SkillShotType.SkillshotCircle:
                Circle = new Geometry.Circle(CollisionEnd, spellData.Radius);
                break;

            case SkillShotType.SkillshotLine:
                Rectangle = new Geometry.Rectangle(Start, CollisionEnd, spellData.Radius);
                break;

            case SkillShotType.SkillshotMissileLine:
                Rectangle = new Geometry.Rectangle(Start, CollisionEnd, spellData.Radius);
                break;

            case SkillShotType.SkillshotCone:
                Sector = new Geometry.Sector(
                    start, CollisionEnd - start, spellData.Radius * (float)Math.PI / 180, spellData.Range);
                break;

            case SkillShotType.SkillshotRing:
                Ring = new Geometry.Ring(CollisionEnd, spellData.Radius, spellData.RingRadius);
                break;

            case SkillShotType.SkillshotArc:
                Arc = new Geometry.Arc(start, end,
                                       EvadeManager.SkillShotsExtraRadius + (int)ObjectManager.Player.BoundingRadius);
                break;
            }

            UpdatePolygon();
        }
コード例 #2
0
        //private static void OnGapcloser(AIHeroClient target, GapcloserArgs Args)
        //{
        //    if (E.IsReady() && target != null && target.IsValidTarget(E.Range))
        //    {
        //        switch (Args.Type)
        //        {
        //            case SpellType.Melee:
        //                if (target.IsValidTarget(target.AttackRange + target.BoundingRadius + 100))
        //                {
        //                    var ePred = E.GetPrediction(target);
        //                    E.Cast(ePred.UnitPosition);
        //                }
        //                break;
        //            case SpellType.Dash:
        //            case SpellType.SkillShot:
        //            case SpellType.Targeted:
        //                {
        //                    var ePred = E.GetPrediction(target);
        //                    E.Cast(ePred.UnitPosition);
        //                }
        //                break;
        //        }
        //    }
        //}

        private static void QLogic(AIHeroClient target, bool UseQ1 = false)// SFX Challenger MissFortune QLogic (im so lazy, kappa)
        {
            if (target != null)
            {
                if (target.IsValidTarget(Q.Range))
                {
                    Q.CastOnUnit(target);
                }
                else if (UseQ1 && target.IsValidTarget(Q2.Range) && target.DistanceToPlayer() > Q.Range)
                {
                    var heroPositions = (from t in GameObjects.EnemyHeroes
                                         where t.IsValidTarget(Q2.Range)
                                         let prediction = Q.GetPrediction(t)
                                                          select new CPrediction.Position(t, prediction.UnitPosition)).Where(
                        t => t.UnitPosition.Distance(Me.Position) < Q2.Range).ToList();

                    if (heroPositions.Any())
                    {
                        var minions =
                            GameObjects.EnemyMinions.Where(x => x.IsValidTarget(Q2.Range) && (x.GetJungleType() != JungleType.Unknown || x.IsMinion()))
                            .ToList();

                        if (minions.Any(m => m.IsMoving) && !heroPositions.Any(h => h.Hero.HasBuff("missfortunepassive")))
                        {
                            return;
                        }

                        var outerMinions   = minions.Where(m => m.Distance(Me) > Q.Range).ToList();
                        var innerPositions = minions.Where(m => m.Distance(Me) < Q.Range).ToList();

                        foreach (var minion in innerPositions)
                        {
                            var lMinion  = minion;
                            var coneBuff = new Geometry.Sector(
                                minion.Position,
                                Me.Position.Extend(minion.Position, Me.Distance(minion) + Q.Range * 0.5f),
                                (float)(40 * Math.PI / 180), Q2.Range - Q.Range);
                            var coneNormal = new Geometry.Sector(
                                minion.Position,
                                Me.Position.Extend(minion.Position, Me.Distance(minion) + Q.Range * 0.5f),
                                (float)(60 * Math.PI / 180), Q2.Range - Q.Range);

                            foreach (var enemy in
                                     heroPositions.Where(
                                         m => m.UnitPosition.Distance(lMinion.Position) < Q2.Range - Q.Range))
                            {
                                if (coneBuff.IsInside(enemy.Hero) && enemy.Hero.HasBuff("missfortunepassive"))
                                {
                                    Q.CastOnUnit(minion);
                                    return;
                                }
                                if (coneNormal.IsInside(enemy.UnitPosition))
                                {
                                    var insideCone =
                                        outerMinions.Where(m => coneNormal.IsInside(m.Position)).ToList();

                                    if (!insideCone.Any() ||
                                        enemy.UnitPosition.Distance(minion.Position) <
                                        insideCone.Select(
                                            m => m.Position.Distance(minion.Position) - m.BoundingRadius)
                                        .DefaultIfEmpty(float.MaxValue)
                                        .Min())
                                    {
                                        Q.CastOnUnit(minion);
                                        return;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
コード例 #3
0
ファイル: MF.cs プロジェクト: ahmed98khaled/SimpleAIO
        private static void CastQ1()
        {
            var target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);

            if (target != null)
            {
                Q.CastOnUnit(target);
            }
            else if (1 == 1)
            {
                target = TargetSelector.GetTarget(Q1.Range, DamageType.Physical);
                if (target != null)
                {
                    var heroPositions = (from t in GameObjects.EnemyHeroes
                                         where t.IsValidTarget(Q1.Range)
                                         let prediction = Q.GetPrediction(t)
                                                          select new Position(t, prediction.UnitPosition)).Where(
                        t => t.UnitPosition.Distance(GameObjects.Player.Position) < Q1.Range).ToList();
                    if (heroPositions.Any())
                    {
                        var minions = GameObjects.GetMinions(
                            Q1.Range, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.None);

                        if (minions.Any(m => m.IsMoving) && !heroPositions.Any(h => HasPassiveDebuff(h.Hero)))
                        {
                            return;
                        }

                        var outerMinions   = minions.Where(m => m.Distance(GameObjects.Player) > Q.Range).ToList();
                        var innerPositions = minions.Where(m => m.Distance(GameObjects.Player) < Q.Range).ToList();
                        foreach (var minion in innerPositions)
                        {
                            var lMinion  = minion;
                            var coneBuff = new Geometry.Sector(minion.Position,
                                                               GameObjects.Player.Position.Extend(minion.Position, GameObjects.Player.Distance(minion) + Q.Range * 0.5f),
                                                               (float)(40 * Math.PI / 180), Q1.Range - Q.Range);

                            var coneNormal = new Geometry.Sector(minion.Position,
                                                                 GameObjects.Player.Position.Extend(minion.Position, GameObjects.Player.Distance(minion) + Q.Range * 0.5f),
                                                                 (float)(60 * Math.PI / 180), Q1.Range - Q.Range);

                            foreach (
                                var enemy in
                                heroPositions.Where(
                                    m => m.UnitPosition.Distance(lMinion.Position) < Q1.Range - Q.Range))
                            {
                                if (coneBuff.IsInside(enemy.Hero) && HasPassiveDebuff(enemy.Hero))
                                {
                                    Q.CastOnUnit(minion);
                                    return;
                                }

                                if (coneNormal.IsInside(enemy.UnitPosition))
                                {
                                    var insideCone =
                                        outerMinions.Where(m => coneNormal.IsInside(m.Position)).ToList();
                                    if (!insideCone.Any() ||
                                        enemy.UnitPosition.Distance(minion.Position) <
                                        insideCone.Select(
                                            m => m.Position.Distance(minion.Position) - m.BoundingRadius)
                                        .DefaultIfEmpty(float.MaxValue)
                                        .Min())
                                    {
                                        Q.CastOnUnit(minion);
                                        return;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
コード例 #4
0
ファイル: Drawings.cs プロジェクト: wade1990/PortAIO
        /// <summary>
        ///     Loads the range drawings.
        /// </summary>
        public static void Initialize()
        {
            if (GameObjects.Player.IsDead)
            {
                return;
            }

            Drawing.OnDraw += delegate
            {
                /// <summary>
                ///     Loads the Passive Target drawing.
                /// </summary>
                if (MissFortune.PassiveTarget.IsValidTarget() &&
                    Vars.Menu["drawings"]["p"].GetValue <MenuBool>().Value)
                {
                    Render.Circle.DrawCircle(
                        MissFortune.PassiveTarget.Position,
                        MissFortune.PassiveTarget.BoundingRadius,
                        Color.LightGreen,
                        1);
                }

                /// <summary>
                ///     Loads the Q Cone drawings.
                /// </summary>
                if (Vars.Q.IsReady() && Vars.Menu["drawings"]["qc"].GetValue <MenuBool>().Value)
                {
                    foreach (var obj in
                             ObjectManager.Get <Obj_AI_Base>()
                             .Where(m => !(m is Obj_AI_Turret) && m.IsValidTarget(Vars.Q.Range)))
                    {
                        var polygon = new Geometry.Sector(
                            (Vector2)obj.ServerPosition,
                            (Vector2)
                            obj.ServerPosition.Extend(
                                GameObjects.Player.ServerPosition,
                                -(Vars.Q2.Range - Vars.Q.Range)),
                            40f * (float)Math.PI / 180f,
                            Vars.Q2.Range - Vars.Q.Range - 50f);
                        var target =
                            GameObjects.EnemyHeroes.FirstOrDefault(
                                t =>
                                !Invulnerable.Check(t) && t.IsValidTarget(Vars.Q2.Range) &&
                                (t.NetworkId == MissFortune.PassiveTarget?.NetworkId ||
                                 Targets.Minions.All(m => polygon.IsOutside((Vector2)m.ServerPosition))));
                        if (target != null)
                        {
                            polygon.Draw(
                                !polygon.IsOutside((Vector2)target.ServerPosition) &&
                                !polygon.IsOutside(
                                    (Vector2)
                                    Movement.GetPrediction(
                                        target,
                                        GameObjects.Player.Distance(target) / Vars.Q.Speed + Vars.Q.Delay)
                                    .UnitPosition)
                                        ? Color.Green
                                        : Color.Red);
                        }
                    }
                }
            };
        }