public void InitializeComponent()
        {
            // Initialize texture references
            MasterMind.TextureLoader.Load(Resources.CooldownTracker, out _overlayRef);

            // Initialize menu
            Menu = MasterMind.Menu.AddSubMenu("Cooldown Tracker", longTitle: "Spell Cooldown Tracker");

            Menu.AddGroupLabel("Information");
            Menu.AddLabel("A spell cooldown tracker helps you in various ways ingame.");
            Menu.AddLabel("It lets you visually see the remaining time the spells are on cooldown.");
            Menu.AddLabel(string.Format("You can enable cooldown tracking for both, {0} and {1}.",
                MasterMind.IsSpectatorMode ? "blue" : "allies", MasterMind.IsSpectatorMode ? "red team" : "enemies"));
            Menu.AddSeparator();

            TrackAllies = Menu.Add("allies", new CheckBox(string.Format("Track {0}", MasterMind.IsSpectatorMode ? "blue team" : "allies")));
            TrackEnemies = Menu.Add("enemies", new CheckBox(string.Format("Track {0}", MasterMind.IsSpectatorMode ? "red team" : "enemies")));
            DrawText = Menu.Add("cooldownText", new CheckBox("Draw cooldown time below spell indicator"));

            // Initialize properties
            OverlaySprite = new EloBuddy.SDK.Rendering.Sprite(() => OverlayTextre);
            SpellCooldownText = new Text(string.Empty, new System.Drawing.Font(FontFamily.GenericSansSerif, 8, FontStyle.Regular))
            {
                Color = Color.GhostWhite
            };

            AlliedTeam = GameObjectTeam.Order;
            if (!MasterMind.IsSpectatorMode)
            {
                AlliedTeam = Player.Instance.Team;
            }

            // Listen to required events
            Drawing.OnEndScene += OnDraw;
        }

 //abstract stuff
 protected Camp(byte campID,Vector3 pos, GameObjectTeam team)
 {
     campId = campID;
     campPosition = pos;
     side = team;
     State = JungleCampState.Unknown;
 }

        public static bool IsInFountain(Vector3 position, GameObjectTeam team)
        {
            float fountainRange = 1050;

            if (Game.MapId == GameMapId.SummonersRift)
            {
                Vector3 vec3 = (team == GameObjectTeam.Order) ? new Vector3(363, 426, 182) : new Vector3(14340, 14390, 172);
                return position.IsInRange(vec3, fountainRange);
            }
            return false;
        }

        public Mobs(
                int respawnTime,
                Vector3 position,
                string[] mobNames,
                GameMapId MapID,
                GameObjectTeam team)
        {
            this.RespawnTime = respawnTime;
            this.Position = position;
            this.MobNames = mobNames;
            this.MapID = MapID;
            this.Team = team;

            this.ObjectsDead = new List<string>();
            this.ObjectsAlive = new List<string>();
        }

 public Gromp(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Gromp(1)
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = -50;
     bonusPrio = -20;
     onRespawn();
     worthSmiting = true;
 }

 public Senitels(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Blue(1),
         get_SRU_BlueMini(2),
         get_SRU_BlueMini(3,true),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(300);
     useOverTime = false;
     onRespawn();
 }

        public static int CountEnemies(Vector3 from, float Range, GameObjectTeam team)
        {
            int Counter = 0;
            List<Obj_AI_Hero> Enemies = null;
            Enemies = ObjectHandler.Get<Obj_AI_Hero>().Where(t => t.IsEnemy && !t.IsDead).ToList();

            foreach (Obj_AI_Hero hero in Enemies)
            {
                if (from.Distance(hero.Position) < Range)
                {
                    Counter++;
                }
            }

            return Counter;
        }

 public RedBrambleback(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Red(1),
         get_SRU_RedMini(2),
         get_SRU_RedMini(3),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(300);
     useOverTime = false;
     bonusPrioLowLvl = -1;
     onRespawn();
 }

 public Dragon(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Dragon(1)
     };
     SpawnTime = TimeSpan.FromSeconds(150);
     RespawnTimer = TimeSpan.FromSeconds(360);
     bonusPrioLowLvl = -5;
     bonusPrio += 5;
     onRespawn();
     worthSmiting = false;
     isDrag = true;
 }

        public bool IsValidTeam(GameObjectTeam team)
        {
            if (team == GameObjectTeam.Unknown)
                return true;

            switch (TeamDetect)
            {
                case DetectionTeam.AllyTeam:
                    return team == Utils.PlayerTeam();
                case DetectionTeam.EnemyTeam:
                    return team != Utils.PlayerTeam();
                case DetectionTeam.AnyTeam:
                    return true;
            }

            return false;
        }

        public static int CountMinions(Vector3 from, float Range, GameObjectTeam team)
        {
            int Counter = 0;
            List<Obj_AI_Minion> Minions = null;

            Minions = GetMinions(ENEMY_TEAM);

            foreach (Obj_AI_Minion minion in Minions)
            {
                if (from.Distance(minion.Position) < Range && !minion.IsDead)
                {
                    Counter++;
                }
            }

            return Counter;
        }

 public Raptors(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Razorbeak(1),
         get_SRU_RazorbeakMini(2),
         get_SRU_RazorbeakMini(3),
         get_SRU_RazorbeakMini(4)
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = -5;
     onRespawn();
     worthSmiting = false;
 }

 public MurkWolfs(byte campID, Vector3 pos, GameObjectTeam team)
     : base(campID, pos, team)
 {
     campId = campID;
     side = team;
     Minions = new List<JungleMinion>
     {
         get_SRU_Murkwofl(1),
         get_SRU_MurkwoflMini(2),
         get_SRU_MurkwoflMini(3),
     };
     SpawnTime = TimeSpan.FromSeconds(115);
     RespawnTimer = TimeSpan.FromSeconds(100);
     bonusPrioLowLvl = 3;
     onRespawn();
     worthSmiting = false;
     useOverTime = true;
 }

 public Camp(string name,
     float spawnTime,
     int respawnTimer,
     Vector3 position,
     List<Mob> mobs,
     Utility.Map.MapType mapType,
     GameObjectTeam team,
     Color colour,
     Timers timer,
     bool isRanged = false,
     bool isDead = false,
     int state = 0,
     int respawnTime = 0,
     int lastChangeOnState = 0,
     bool shouldping = true,
     int lastPing = 0)
 {
     Name = name;
     IsDead = isDead;
     SpawnTime = spawnTime;
     RespawnTimer = respawnTimer;
     Position = position;
     ScreenPosition = Drawing.WorldToScreen(Position);
     MinimapPosition = Drawing.WorldToMinimap(Position);
     Mobs = mobs;
     MapType = mapType;
     Team = team;
     Colour = colour;
     IsRanged = isRanged;
     State = state;
     RespawnTime = respawnTime;
     LastChangeOnState = lastChangeOnState;
     Timer = timer;
     ShouldPing = shouldping;
     LastPing = lastPing;
 }

 public static IEnumerable<Obj_AI_Turret> GetTurrets(GameObjectTeam team, Lane lane)
 {
     switch (team)
     {
         case GameObjectTeam.Order:
         {
             switch (lane)
             {
                 case Lane.Base:
                 {
                     return
                         GameObjects.Turrets.Where(
                             turret =>
                                 orderBase.Any(
                                     orderBaseTurretPosition =>
                                         orderBaseTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Bot:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderBot.Any(
                                 orderBotTurretPosition => orderBotTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Mid:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderMid.Any(
                                 orderMidPosition => orderMidPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Top:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             orderTop.Any(
                                 orderTopTurretPosition => orderTopTurretPosition.Distance(turret.Position) < 250));
                 }
             }
             break;
         }
         case GameObjectTeam.Chaos:
         {
             switch (lane)
             {
                 case Lane.Base:
                 {
                     return
                         GameObjects.Turrets.Where(
                             turret =>
                                 chaosBase.Any(
                                     chaosBaseTurretPosition =>
                                         chaosBaseTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Bot:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosBot.Any(
                                 chaosBotTurretPosition => chaosBotTurretPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Mid:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosMid.Any(
                                 chaosMidPosition => chaosMidPosition.Distance(turret.Position) < 250));
                 }
                 case Lane.Top:
                 {
                     return GameObjects.Turrets.Where(
                         turret =>
                             chaosTop.Any(
                                 chaosTopTurretPosition => chaosTopTurretPosition.Distance(turret.Position) < 250));
                 }
             }
             break;
         }
         default:
             return GameObjects.AllyTurrets;
     }
     return GameObjects.AllyTurrets;
 }

 public Camp(float spawnTime,
     float respawnTime,
     Vector3 position,
     List<Mob> mobs,
     bool isBig,
     Utility.Map.MapType mapType,
     GameObjectTeam team)
 {
     SpawnTime = spawnTime;
     RespawnTime = respawnTime;
     Position = position;
     MinimapPosition = Drawing.WorldToMinimap(Position);
     Mobs = mobs;
     IsBig = isBig;
     MapType = mapType;
     Team = team;
 }

 /// <summary>
 /// Returns a polygon containing the lane itself.
 /// </summary>
 /// <param name="team">The team.</param>
 /// <param name="lane">The lane.</param>
 /// <returns>A polygon containing the lane itself.</returns>
 public static Geometry.Polygon GetLanePolygon(GameObjectTeam team, Lane lane)
 {
     switch (team)
     {
         case GameObjectTeam.Order:
         {
             return _teamOrderLaneZones.FirstOrDefault(entry => entry.Key == lane).Value;
         }
         case GameObjectTeam.Chaos:
         {
             return _teamChaosLaneZones.FirstOrDefault(entry => entry.Key == lane).Value;
         }
         case GameObjectTeam.Neutral:
         {
             return _teamNeutralLaneZones.FirstOrDefault(entry => entry.Key == lane).Value;
         }
         default:
         {
             return null;
         }
     }
 }

 public JungleCamp(String name, GameObjectTeam team, int campId, int spawnTime, int respawnTime,
     Utility.Map.MapType mapType, Vector3 mapPosition, Vector3 minimapPosition, JungleMob[] creeps)
 {
     Name = name;
     Team = team;
     CampId = campId;
     SpawnTime = spawnTime;
     RespawnTime = respawnTime;
     MapType = mapType;
     MapPosition = mapPosition;
     MinimapPosition = minimapPosition;
     Creeps = creeps;
     NextRespawnTime = 0;
     Called = false;
 }

 public Relic(string name, String objectName, GameObjectTeam team, Obj_AI_Minion obj, int spawnTime,
     int respawnTime, Vector3 mapPosition, Vector3 minimapPosition)
 {
     Name = name;
     ObjectName = objectName;
     Team = team;
     Obj = obj;
     SpawnTime = spawnTime;
     RespawnTime = respawnTime;
     Locked = false;
     MapPosition = mapPosition;
     MinimapPosition = minimapPosition;
     MapType = Utility.Map.MapType.CrystalScar;
     NextRespawnTime = 0;
     Called = false;
 }

 public static Geometry.Polygon GetLanePolygonExtendedToFarthestMinion(GameObjectTeam laneZoneTeam, Lane lane,
     GameObjectTeam minionTeam, int maxFieldDistance = 1000)
 {
     var farthestTurret = Turrets.GetTurretsPosition(laneZoneTeam, lane).Last();
     var mostdamaged = Minions.GetMostDamagedMinion(minionTeam, lane);
     var farthestMinion = mostdamaged != null
         ? mostdamaged
         : Minions.GetMinionsInLane(minionTeam, lane)
             .OrderBy(m => m.Distance(farthestTurret))
             .FirstOrDefault();
     if (farthestMinion != null)
     {
         return
             new Geometry.Rectangle(farthestMinion.Position.ToVector2(),
                 farthestMinion.Position.ToVector2().Extend(farthestTurret, maxFieldDistance), 700).ToPolygon();
     }
     return GetLanePolygon(laneZoneTeam, lane);
 }