Exemplo n.º 1
0
 private bool ShouldWait()
 {
     return
         (ObjectManager.Get <Obj_AI_Minion>()
          .Any(
              minion =>
              minion.IsValidTarget() && minion.Team != GameObjectTeam.Neutral &&
              InAutoAttackRange(minion) &&
              HealthPrediction.LaneClearHealthPrediction(
                  minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay) <=
              DamageLib.CalcPhysicalMinionDmg(
                  Player.BaseAttackDamage + Player.FlatPhysicalDamageMod, minion, true) - 1 +
              Math.Max(0, GetAutoAttackPassiveDamage(minion) - 10)));
 }
Exemplo n.º 2
0
            public Obj_AI_Base GetTarget()
            {
                Obj_AI_Base result = null;

                float[] r = { float.MaxValue };

                if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
                    !_config.Item("PriorizeFarm").GetValue <bool>())
                {
                    var target = SimpleTs.GetTarget(-1, SimpleTs.DamageType.Physical);
                    if (target != null)
                    {
                        return(target);
                    }
                }

                /*Killable Minion*/
                if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
                    ActiveMode == OrbwalkingMode.LastHit)
                {
                    foreach (var minion in
                             ObjectManager.Get <Obj_AI_Minion>()
                             .Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion)))
                    {
                        var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
                                1000 * (int)Player.Distance(minion) / (int)GetMyProjectileSpeed();
                        var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);

                        if (minion.Team != GameObjectTeam.Neutral && predHealth > 0 &&
                            predHealth <=
                            DamageLib.CalcPhysicalMinionDmg(
                                Player.BaseAttackDamage + Player.FlatPhysicalDamageMod, minion, true) - 1 +
                            Math.Max(0, GetAutoAttackPassiveDamage(minion) - 10))
                        {
                            //Game.PrintChat("Current Health: " + minion.Health + " Predicted Health:" + (DamageLib.CalcPhysicalMinionDmg(Player.BaseAttackDamage + Player.FlatPhysicalDamageMod, minion, true) - 1 + Orbwalking.GetPassiveDamage(minion)));
                            return(minion);
                        }
                    }
                }

                //Forced target
                if (_forcedTarget != null && _forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
                {
                    return(_forcedTarget);
                }

                /*Champions*/
                if (ActiveMode != OrbwalkingMode.LastHit)
                {
                    var target = SimpleTs.GetTarget(-1, SimpleTs.DamageType.Physical);
                    if (target != null)
                    {
                        return(target);
                    }
                }

                /*Jungle minions*/
                if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
                {
                    foreach (var mob in
                             ObjectManager.Get <Obj_AI_Minion>()
                             .Where(
                                 mob =>
                                 mob.IsValidTarget() && InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
                             .Where(mob => mob.MaxHealth >= r[0] || Math.Abs(r[0] - float.MaxValue) < float.Epsilon))
                    {
                        result = mob;
                        r[0]   = mob.MaxHealth;
                    }
                }

                if (result != null)
                {
                    return(result);
                }

                /*Lane Clear minions*/
                r[0] = float.MaxValue;
                if (ActiveMode == OrbwalkingMode.LaneClear)
                {
                    if (!ShouldWait())
                    {
                        if (_prevMinion != null && _prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
                        {
                            var predHealth = HealthPrediction.LaneClearHealthPrediction(
                                _prevMinion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
                            if (predHealth >=
                                2 *
                                DamageLib.CalcPhysicalMinionDmg(
                                    Player.BaseAttackDamage + Player.FlatPhysicalDamageMod, _prevMinion, true) - 1 +
                                Math.Max(0, GetAutoAttackPassiveDamage(_prevMinion) - 10) ||
                                Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
                            {
                                return(_prevMinion);
                            }
                        }

                        foreach (var minion in
                                 ObjectManager.Get <Obj_AI_Minion>()
                                 .Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion)))
                        {
                            var predHealth = HealthPrediction.LaneClearHealthPrediction(
                                minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
                            if (predHealth >=
                                2 *
                                DamageLib.CalcPhysicalMinionDmg(
                                    Player.BaseAttackDamage + Player.FlatPhysicalDamageMod, minion, true) - 1 +
                                Math.Max(0, GetAutoAttackPassiveDamage(minion) - 10) ||
                                Math.Abs(predHealth - minion.Health) < float.Epsilon)
                            {
                                if (minion.Health >= r[0] || Math.Abs(r[0] - float.MaxValue) < float.Epsilon)
                                {
                                    result      = minion;
                                    r[0]        = minion.Health;
                                    _prevMinion = minion;
                                }
                            }
                        }
                    }
                }

                /*turrets*/
                if (ActiveMode == OrbwalkingMode.LaneClear)
                {
                    foreach (var turret in
                             ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
                    {
                        return(turret);
                    }
                }

                return(result);
            }