/// <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;
 }

 public override float getDPS(Obj_AI_Minion minion)
 {
     float dps = 0;
     if (Q.Level != 0)
         dps += Q.GetDamage(minion) / Qdata.Cooldown;
     if (E.Level != 0)
         dps += E.GetDamage(minion) / (Qdata.Cooldown-2);
     dps += (float)player.GetAutoAttackDamage(minion) * player.AttackSpeedMod;
     dpsFix = dps;
     return (dps == 0) ? 999 : dps;
 }

        protected override void LargeUpdate()
        {
            if (GameObject == null || GameObject.IsDead)
                GameObject = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(x => x.CampNumber > 0 && x.Name.Contains("Baron12.1.1") && x.IsVisible);

            if (CanBeDone() && ObjectiveCommons.HasAnyoneNashorBuff())
            {
                _respawnTime = (int)Game.Time + 7 * 60 - Tolerance;
                GameObject = null;
            }

            base.LargeUpdate();
        }

        public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
        {
            if (JungleOrbwalker.CanAttack())
            {
                UseE(minion);
                UseR(minion);
            }
            // shouldUseSafe();

            if (JungleClearer.focusedCamp.useSafe)
                JungleOrbwalker.attackMinion(minion, JungleClearer.focusedCamp.safePosition);
            else
                JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 100).To3D());
        }

        public Camp(int campId, string name, Vector2 position, int respawnTime)
        {
            _respawnDuration = respawnTime * 60 * 1000;
            _isMajor = IsMajorCamp(name);
            Name = name;
            Sprite = GetMapSprite(Name, position);
            RenderText = GetRenderText(position, _isMajor);
            RespawnTime = 0;

            foreach (var obj in ObjectManager.Get<Obj_AI_Minion>().Where(obj => obj.CampNumber == campId))
                CampObject = obj;

            Game.OnGameUpdate += Game_OnGameUpdate;
        }

 static Heal()
 {
     Game.OnUpdate += Game_OnGameUpdate;
     adCarry = ObjectManager.Get<Obj_AI_Base>().FirstOrDefault(x => x.IsMe);
     jungleMobs = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(x => x.IsValidTarget(Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) + 100) 
         && x.CharData.BaseSkinName.Contains("Dragon")
         || x.CharData.BaseSkinName.Contains("Baron")
         || x.CharData.BaseSkinName.Contains("SRU_Blue")
         || x.CharData.BaseSkinName.Contains("SRU_Red") && x.IsVisible && !x.IsDead);
     if (adCarry != null)
     {
         Console.Write(adCarry.CharData.BaseSkinName);
     }
 }