C# Obj_AI_Minion类代码示例

 /// <summary>
 ///     Return the Attacking turret.
 /// </summary>
 /// <param name="minion">
 ///     The minion.
 /// </param>
 /// <returns>
 ///     The <see cref="bool" />
 /// </returns>
 public static Obj_AI_Base GetAggroTurret(Obj_AI_Minion minion)
 {
     var activeTurret =
         ActiveAttacks.Values.FirstOrDefault(
             m => (m.Source is Obj_AI_Turret) && m.Target.NetworkId == minion.NetworkId);
     return activeTurret?.Source;
 }

 public static void Farm(Obj_AI_Minion minion)
 {
     if (Q.IsReady() && Q.GetDamage(minion) < minion.Health)
     {
         Q.Cast(minion);
     }
 }

 public bool CastSpell(Obj_AI_Minion target)
 {
     if (!CanUseSpell(target))
         return false;
     ObjectManager.Player.Spellbook.CastSpell(Slot, target);
     return true;
 }

 public static bool IsImportant(Obj_AI_Minion minion)
 {
     return minion.IsValidTarget()
         && (minion.Name.ToLower().Contains("baron")
         || minion.Name.ToLower().Contains("dragon")
         || minion.Name.ToLower().Contains("herald"));
 }

 public static void Farm(Obj_AI_Minion minion)
 {
     if (Q.IsReady())
     {
         Q.Cast();
     }
 }

        public static void Farm(Obj_AI_Minion minion)
        {
            Q.SetSkillshot(0.26f, 50f, 1700f, true, SkillshotType.SkillshotLine);

            if (Player.Level < 6)
            {
                if (Player.GetAutoAttackDamage(minion) > minion.Health && Player.Distance(minion.Position) < Player.AttackRange)
                {
                    Player.IssueOrder(GameObjectOrder.AutoAttack, minion);
                }

                if (E.IsReady() && CountMinions(Player.Position, 500, ENEMY_TEAM) > 3)
                {
                    E.Cast(minion);
                }
            }

            if (W.IsReady() &&
                W.GetDamage(minion) > minion.Health &&
                W.IsInRange(minion) &&
                Player.Mana > 50)
            {
                W.Cast(minion);
            }

            if (Player.Level >= 6 && Player.CountEnemiesInRange(1000) == 0 && Player.Mana > 150)
            {
                if (Q.IsReady() && Player.ManaPercent > 20)
                {
                    Q.Cast(minion.Position);
                }
                else if (Q.IsReady() && Q.GetDamage(minion) > minion.Health && Q.GetPrediction(minion).Hitchance > HitChance.Low)
                {
                    Q.Cast(minion.Position);
                }
                else
                {
                    Q.Cast(minion.Position);
                }

                if (R.IsReady() && CountMinions(minion.Position, 500,ENEMY_TEAM) > 3)
                {
                    R.Cast();
                }
                if (W.IsReady() &&W.IsInRange(minion))
                {
                    W.Cast(minion);
                }
                if (E.IsReady() && E.IsInRange(minion))
                {
                    E.Cast(minion);
                }
            }

            //if (W.IsReady() && CountMinions(Player.Position, W.Range, ENEMY_TEAM) > 2)
            //{
            //    W.Cast(minion.Position);
            //}
        }

 public static bool CanCloneAttack(Obj_AI_Minion clone)
 {
     if (clone != null)
     {
         return Utils.GameTimeTickCount >= LastAATick + (clone.AttackDelay - clone.AttackCastDelay) * 1000;
     }
     return false;
 }

 public override float getDPS(Obj_AI_Minion minion)
 {
     float dps = 0;
     dps += (float)player.GetAutoAttackDamage(minion) * player.AttackSpeedMod;
     dps += 30;
     dpsFix = dps;
     return dps;
 }

 private void Orbwalking_OnAttack(AttackableUnit unit, AttackableUnit target)
 {
     if (unit.IsMe && target is Obj_AI_Minion)
     {
         LastAttackedminiMinion = (Obj_AI_Minion) target;
         LastAttackedminiMinionTime = Utils.GameTimeTickCount;
     }
 }

 public static bool CanCloneAttack(Obj_AI_Minion ghost)
 {
     if (ghost != null)
     {
         return Utils.GameTimeTickCount >= LastAATick + (ghost.AttackDelay - ghost.AttackCastDelay) * 1000;
     }
     return false;
 }

        /// <summary>
        ///     This function will check if the given target is killable
        /// </summary>
        /// <param name="target">Must be a OBJAIMinion</param>
        /// <param name="range">Must be a float value where to check the max range</param>
        /// <param name="key">Must be a Spellslot key for assign the damage</param>
        /// <returns></returns>
        public static bool IsKillableMinion(Obj_AI_Minion target, float range, SpellSlot key)
        {
            var x = target;
            if (x.IsValidTarget(range) && x.TotalShieldHealth() + 5 <= Player.Instance.GetSpellDamage(x, key))
            {
                return true;
            }

            return false;
        }

 public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
 {
     if (JungleOrbwalker.CanAttack())
     {
         UseW(minion);
         UseE(minion);
         UseR(minion);
     }
     JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 150).To3D());
 }

 public Vector3 AvgPos(Obj_AI_Minion[] objects)
 {
     double x = 0, y = 0;
     foreach (Obj_AI_Minion obj in objects)
     {
         x += obj.Position.X;
         y += obj.Position.Y;
     }
     return new Vector2((float) (x/objects.Count()), (float) (y/objects.Count())).To3DWorld();
 }

        public static void DragonSteal(Obj_AI_Minion dragon)
        {
            var time = (int)(ObjectManager.Player.Spellbook.GetSpell(SpellSlot.R).SData.SpellTotalTime * 1000) - 100 + Game.Ping / 2;

            HealthPrediction.GetHealthPrediction(dragon, time, (int) Spells.R.Delay);

            if (b)
            {
                
            }
        }

 public bool HasBuff(Obj_AI_Minion jungleBigMob)
 {
     foreach (JungleMob jungleMob in JungleMobs)
     {
         if (jungleBigMob.SkinName.Contains(jungleMob.Name))
         {
             return jungleMob.Buff;
         }
     }
     return false;
 }