private static void Game_OnGameLoad(EventArgs args)
        {
            Player = ObjectManager.Player;
            if (ObjectManager.Player.BaseSkinName != Champion) return;

            Q = new Spell(SpellSlot.Q, 770);
            W = new Spell(SpellSlot.W, 525);
            E = new Spell(SpellSlot.E, 800);
            R = new Spell(SpellSlot.R, 650);

            IgniteSlot = Player.GetSpellSlot("SummonerDot");

            Q.SetSkillshot(0.25f, 70f, 1450f, false, SkillshotType.SkillshotLine);
            E.SetSkillshot(0.5f, 175f, int.MaxValue, false, SkillshotType.SkillshotCircle);

            SpellList.Add(Q);
            SpellList.Add(W);
            SpellList.Add(E);
            SpellList.Add(R);

            Config = new Menu(Champion, "StonedJarvan", true);


            var targetSelectorMenu = new Menu("Target Selector", "Target Selector");
            TargetSelector.AddToMenu(targetSelectorMenu);
            Config.AddSubMenu(targetSelectorMenu);

            Config.AddSubMenu(new Menu("Orbwalking", "Orbwalking"));
            Orbwalker = new Orbwalking.Orbwalker(Config.SubMenu("Orbwalking"));

            Config.AddSubMenu(new Menu("Combo", "Combo"));
            Config.SubMenu("Combo").AddItem(new MenuItem("UseQCombo", "Use Q")).SetValue(true);
            Config.SubMenu("Combo").AddItem(new MenuItem("UseWCombo", "Use W")).SetValue(true);
            Config.SubMenu("Combo").AddItem(new MenuItem("UseECombo", "Use E")).SetValue(true);
            Config.SubMenu("Combo").AddItem(new MenuItem("UseEQCombo", "Use EQ")).SetValue(true);
            Config.SubMenu("Combo").AddItem(new MenuItem("UseRCombo", "Use R")).SetValue(true);
            Config.SubMenu("Combo").AddItem(new MenuItem("ActiveCombo", "Combo!").SetValue(new KeyBind(32, KeyBindType.Press)));

            Config.AddSubMenu(new Menu("Drawings", "Drawings"));
            Config.SubMenu("Drawings").AddItem(new MenuItem("DrawQ", "Draw Q")).SetValue(true);
            Config.SubMenu("Drawings").AddItem(new MenuItem("DrawW", "Draw W")).SetValue(true);
            Config.SubMenu("Drawings").AddItem(new MenuItem("DrawE", "Draw E")).SetValue(true);
            Config.SubMenu("Drawings").AddItem(new MenuItem("DrawR", "Draw R")).SetValue(true);
            Config.SubMenu("Drawings").AddItem(new MenuItem("CircleLag", "Lag Free Circles").SetValue(true));
            Config.SubMenu("Drawings").AddItem(new MenuItem("CircleThickness", "Circles Thickness").SetValue(new Slider(1, 10, 1)));

            Config.AddSubMenu(new Menu("Misc", "Misc"));
            Config.SubMenu("Misc").AddItem(new MenuItem("EQmouse", "EQ To Mouse").SetValue(new KeyBind("G".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Misc").AddItem(new MenuItem("Ignite", "Use Ignite").SetValue(true));

            Config.AddToMainMenu();

            Game.OnGameUpdate += OnGameUpdate;
            Drawing.OnDraw += OnDraw;

            //Obj_AI_Hero.OnCreate += OnCreateObj;
            //Obj_AI_Hero.OnDelete += OnDeleteObj;

            Game.PrintChat("<font color='#FF00BF'>Stoned Jarvan Loaded By</font> <font color='#FF0000'>The</font><font color='#FFFF00'>Kush</font><font color='#40FF00'>Style</font>");
        }

        public static void Init()
        {
            slot1 = _Player.Spellbook.GetSpell(SpellSlot.Summoner1);
            slot2 = _Player.Spellbook.GetSpell(SpellSlot.Summoner2);

            var smiteNames = new[]
            {
                "s5_summonersmiteplayerganker", "itemsmiteaoe", "s5_summonersmitequick",
                "s5_summonersmiteduel", "summonersmite"
            };
            if (smiteNames.Contains("smite"))
            {
                smite = new Spell.Targeted(SpellSlot.Summoner1, (uint) 560f);
                smiteSlot = SpellSlot.Summoner1;
            }
            if (smiteNames.Contains("smite"))
            {
                smite = new Spell.Targeted(SpellSlot.Summoner2, (uint) 560f);
                smiteSlot = SpellSlot.Summoner2;
            }
            Smiterino = Program.Menu.AddSubMenu("Auto Smite", "Smite");
            Smiterino.AddGroupLabel("Auto Smite Settings");
            Smiterino.AddSeparator();
            Smiterino.Add("smiteActive", new CheckBox("Smite Active"));
            Smiterino.Add("drawHp", new CheckBox("Draw HP Bar on Minions"));
            Smiterino.Add("autoSmite", new KeyBind("AutoSmite Active HotKey", true, KeyBind.BindTypes.PressToggle, 'N'));
            Game.OnUpdate += OnUpdate;
            Drawing.OnDraw += OnDraw;
        }

 public Dispell(string champName, string buff, SpellSlot slot, int offset = 0)
 {
     ChampionName = champName;
     BuffName = buff;
     Slot = slot;
     Offset = offset;
 }

 private bool CanUse(SpellSlot sum)
 {
     if (sum != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(sum) == SpellState.Ready)
         return true;
     else
         return false;
 }

 public static float DamageBySpell(Obj_AI_Base Enemy, SpellSlot Slot)
 {
     float Damage = 0f;
     switch (Slot)
     {
         case SpellSlot.Q:
             if (Q.IsReady())
             {
                 Damage += new float[] { 80, 115, 150, 185, 220}[Player.GetSpell(Slot).Level -1] + (0.8f * me.FlatMagicDamageMod);
             }
             break;
         case SpellSlot.W:
             if (W.IsReady())
             {
                 Damage += new float[] { 70, 115, 160, 205, 250 }[Player.GetSpell(Slot).Level - 1] + (0.85f * me.FlatMagicDamageMod);
             }
             break;
         case SpellSlot.R:
             if (R.IsReady())
             {
                 Damage += new float[] { 150, 275, 400 }[Player.GetSpell(Slot).Level - 1] + (0.65f * me.FlatMagicDamageMod);
             }
             break;
     }
     return Player.Instance.CalculateDamageOnUnit(Enemy, DamageType.Magical, Damage);
 }

        public static void OnGameLoad(EventArgs args)
        {
            Menu = MainMenu.AddMenu("Mastery Emote Spammer", "masteryemotespammermenu");
            Menu.AddLabel("Made by imsosharp, ported by ThugDoge");
            StringList(Menu, "mode", "Mode", new []{ "MASTERY", "LAUGH" }, 0);
            StringList(Menu, "chatdisrespectmode", "Chat Disrespect Mode", new[] { "DISABLED", "CHAMPION NAME", "SUMMONER NAME" }, 0);
            Menu.Add("onkill", new CheckBox("After Kill"));
            Menu.Add("onassist", new CheckBox("After Assist"));
            Menu.Add("ondeath", new CheckBox("After Death", false));
            Menu.Add("neardead", new CheckBox("Near Dead Bodies"));
            Menu.Add("ondodgedskillshot", new CheckBox("After you dodge a skillshot"));
            Menu.Add("afterignite", new CheckBox("Dubstep Ignite"));
            Menu.Add("afterflash", new CheckBox("Challenger Flash", false));
            Menu.Add("afterq", new CheckBox("After Q", false));
            Menu.Add("afterw", new CheckBox("After W", false));
            Menu.Add("aftere", new CheckBox("After E", false));
            Menu.Add("afterr", new CheckBox("After R", false));

            Random = new Random();
            FlashSlot = ObjectManager.Player.GetSpellSlotFromName("SummonerFlash");
            IgniteSlot = ObjectManager.Player.GetSpellSlotFromName("SummonerDot");
            Game.OnUpdate += OnUpdate;
            Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;

            //init chat disrespekter
            foreach (var en in ObjectManager.Get<AIHeroClient>().Where(h => h.IsEnemy))
            {
                DeathsHistory.Add(en.NetworkId, en.Deaths);
            }
        }

        public static void UseSmite()
        {
            var minion3 =
                MinionManager.GetMinions(Player.ServerPosition, 200, MinionTypes.All, MinionTeam.NotAlly,
                    MinionOrderTypes.MaxHealth).FirstOrDefault();
            if (minion3 != null)
            {
                foreach (var name in buffS)
                {
                    if ((minion3 != null && buffS.Any(n => n.ToLower() == minion3.Name.ToLower())) || (minion3 != null && buffS.Any(n => n.ToLower() == minion3.BaseSkinName.ToLower())) || (minion3 != null && buffS.Any(n => n.ToLower() == minion3.SkinName.ToLower())))
                    {
                        var damageQ = 250 + 150 * ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).Level;
                        smiteSlot = Player.GetSpellSlot("SummonerSmite");
                        if (SmiteDmg() > minion3.Health && minion3.IsValidTarget(780)) Player.SummonerSpellbook.CastSpell(smiteSlot, minion3);
                        if (Q.IsReady() && minion3.Distance(Player) <= 140 && damageQ > minion3.Health)
                        {
                            Q.CastOnUnit(minion3 ,true);//Packet.C2S.Cast.Encoded(new Packet.C2S.Cast.Struct(minion.NetworkId, (SpellSlot)64)).Send(PacketChannel.C2S);
                        }
                        if(minionz.Distance(Player) < 200 && SmiteDmg() > minion3.Health)
                        {
                            Player.SummonerSpellbook.CastSpell(smiteSlot, minion3);
                        }

                    }
                }
            }
        }

 public SpecialSpell(Champion _hero, SpellSlot slot, bool defaultvalue, int delay)
 {
     Slot = slot;
     Hero = _hero;
     DefaultValue = defaultvalue;
     Delay = delay;
 }

 public DangerousSpell(Champion hero, SpellSlot slot, bool defaultvalue = true, int delay = 0)
 {
     Slot = slot;
     Hero = hero;
     DefaultValue = defaultvalue;
     Delay = delay;
 }

 public TargetSpellData(string champ, string spellname, SpellSlot slot, int delay = 0)
 {
     ChampionName = champ;
     Name = spellname;
     Spellslot = slot;
     Delay = delay;
 }

        public GameInfo()
        {
            NextItemPrice = 350;
            if (ObjectManager.Player.Team == GameObjectTeam.Chaos)
            {
                SpawnPoint = new Vector3(14232f, 14354, 171.97f);
                SpawnPointEnemy = new Vector3(415.33f, 453.38f, 182.66f);
            }
            else
            {
                SpawnPoint = new Vector3(415.33f, 453.38f, 182.66f);
                SpawnPointEnemy = new Vector3(14232f, 14354, 171.97f);
            }
            GameState = State.Positioning;
            SetMonsterList();
            CurrentMonster = 1;

            var last =
                MonsterList.OrderBy(temp => temp.Position.Distance(ObjectManager.Player.Position)).FirstOrDefault();
            if (!ObjectManager.Player.InFountain() && last != null && ObjectManager.Player.Level > 1)
            {
                CurrentMonster = last.Index;
            }
            else
            {
                CurrentMonster = 1;
            }
            Ignite = Program.player.GetSpellSlot("summonerdot");
            Barrier = Program.player.GetSpellSlot("summonerbarrier");
            Heal = Program.player.GetSpellSlot("summonerheal");

            Console.WriteLine("AutoJungle Loaded");
        }

        public static void Load()
        {
            try
            {
                slot1 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner1);
                slot2 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner2);

                //Soon riot will introduce multiple heals, mark my words.
                var healNames = new[] { "summonerheal" };

                if (healNames.Contains(slot1.Name))
                {
                    healSpell = new Spell(SpellSlot.Summoner1, 550f);
                    summonerHeal = SpellSlot.Summoner1;
                }
                else if (healNames.Contains(slot2.Name))
                {
                    healSpell = new Spell(SpellSlot.Summoner2, 550f);
                    summonerHeal = SpellSlot.Summoner2;
                }
                else
                {
                    Console.WriteLine("You don't have heal faggot");
                    return;
                }

                Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;
                Game.OnUpdate += OnUpdate;
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: '{0}'", e);
            }
        }

 public TwitchW(SpellSlot slot)
     : base(slot)
 {
     SetSkillshot(0.25f, 275f, 1400f, false, SkillshotType.SkillshotCircle);
     Orbwalking.AfterAttack += Orbwalking_AfterAttack;
     HarassEnabled = false;
 }

 public DangerousSpells(string spellName, string championName, SpellSlot spellSlot, SkillType type)
 {
     SpellName = spellName;
     ChampionName = championName;
     SpellSlot = spellSlot;
     Type = type;
 }

        public static void OnLoad(EventArgs args)
        {
            if (ObjectManager.Player.CharData.BaseSkinName != "Vi")
            {
                return;
            }

            Notifications.AddNotification("ElVi by jQuery v1.0.0.1", 5000);
            _ignite = Player.GetSpellSlot("summonerdot");
            _flash = Player.GetSpellSlot("SummonerFlash");


            Spells[ElVi.Spells.Q].SetSkillshot(
                Spells[ElVi.Spells.Q].Instance.SData.SpellCastTime, Spells[ElVi.Spells.Q].Instance.SData.LineWidth,
                Spells[ElVi.Spells.Q].Instance.SData.MissileSpeed, false, SkillshotType.SkillshotLine);
            Spells[ElVi.Spells.Q].SetCharged("ViQ", "ViQ", 100, 860, 1f);
            Spells[ElVi.Spells.E].SetSkillshot(
                Spells[ElVi.Spells.E].Instance.SData.SpellCastTime, Spells[ElVi.Spells.E].Instance.SData.LineWidth,
                Spells[ElVi.Spells.E].Instance.SData.MissileSpeed, false, SkillshotType.SkillshotLine);
            Spells[ElVi.Spells.R].SetTargetted(0.15f, 1500f);

            ElViMenu.Initialize();
            Game.OnUpdate += OnUpdate;
            Drawing.OnDraw += Drawings.Drawing_OnDraw;
            Orbwalking.AfterAttack += OrbwalkingAfterAttack;
            AntiGapcloser.OnEnemyGapcloser += AntiGapcloser_OnEnemyGapcloser;
            Interrupter2.OnInterruptableTarget += Interrupter2_OnInterruptableTarget;
        }

        private static float UltimateDamage(AIHeroClient enemy, SpellSlot slot)
        {
            const float damage = 0f;

            if (!slot.IsReady() || ObjectManager.Player.Spellbook.GetSpell(slot).State != SpellState.NotLearned)
            {
                return 0f;
            }

            if (Utilities.UltimateKey() == "Q")
            {
                return
                    (float)
                        ObjectManager.Player.CalcDamage(enemy, DamageType.Magical, RQ[Spells.R.Level - 1] + .60*
                                                                                          ObjectManager.Player
                                                                                              .FlatMagicDamageMod);
            }
            if (Utilities.UltimateKey() == "W")
            {
                return
                    (float)
                        ObjectManager.Player.CalcDamage(enemy, DamageType.Magical,
                            RW[Spells.R.Level - 1] + .90*ObjectManager.Player.FlatMagicDamageMod);
            }
            if (Utilities.UltimateKey() == "E")
            {
                return
                    (float)
                        ObjectManager.Player.CalcDamage(enemy, DamageType.Magical, RQ[Spells.R.Level - 1] + .60 *
                                                                                          ObjectManager.Player
                                                                                              .FlatMagicDamageMod);
            }

            return damage;
        }

        public static void Load()
        {
            try
            {
                slot1 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner1);
                slot2 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner2);

                //Soon riot will introduce multiple ignote, mark my words.
                var igniteNames = new[] { "summonerdot" };

                if (igniteNames.Contains(slot1.Name))
                {
                    igniteSpell = new Spell(SpellSlot.Summoner1);
                    summonerDot = SpellSlot.Summoner1;
                }
                else if (igniteNames.Contains(slot2.Name))
                {
                    igniteSpell = new Spell(SpellSlot.Summoner2);
                    summonerDot = SpellSlot.Summoner2;
                }
                else
                {
                    Console.WriteLine("You don't have ignite faggot");
                    return;
                }

                Game.OnUpdate += OnUpdate;
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: '{0}'", e);
            }
        }

        public static void Load()
        {
            try
            {
                slot1 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner1);
                slot2 = Entry.Player.Spellbook.GetSpell(SpellSlot.Summoner2);

                //Soon riot will introduce multiple heals, mark my words.
                var barrierNames = new[] { "summonerbarrier" };

                if (barrierNames.Contains(slot1.Name))
                {
                    barrierSpell = new Spell(SpellSlot.Summoner1);
                    summonerBarrier = SpellSlot.Summoner1;
                }
                else if (barrierNames.Contains(slot2.Name))
                {
                    barrierSpell = new Spell(SpellSlot.Summoner2);
                    summonerBarrier = SpellSlot.Summoner2;
                }
                else
                {
                    Console.WriteLine("You don't have barrier faggot");
                    return;
                }

                Game.PrintChat("<font color='#CC0000'>Sorry!</font> Barrier is not supported yet");
                //Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;
                //DamagePrediction.OnTargettedSpellWillKill += DamagePrediction_OnTargettedSpellWillKill;
            }
            catch (Exception e)
            {
                Console.WriteLine("An error occurred: '{0}'", e);
            }
        }

 public static void OnGameLoad(EventArgs args)
 {
     Menu = new Menu("Mastery Emote Spammer", "masteryemotespammermenu", true);
     Menu.AddItem(new MenuItem("mode", "Mode").SetValue(new StringList(new[] { "MASTERY", "LAUGH" })));
     Menu.AddItem(new MenuItem("onkill", "After Kill").SetValue(true));
     Menu.AddItem(new MenuItem("onassist", "After Assist").SetValue(true));
     Menu.AddItem(new MenuItem("ondeath", "After Death").SetValue(false));
     Menu.AddItem(new MenuItem("neardead", "Near Dead Bodies").SetValue(true));
     Menu.AddItem(new MenuItem("ondodgedskillshot", "After you dodge a skillshot").SetValue(true));
     Menu.AddItem(new MenuItem("afterignite", "Dubstep Ignite").SetValue(true));
     Menu.AddItem(new MenuItem("afterflash", "Challenger Flash").SetValue(false));
     Menu.AddItem(new MenuItem("afterq", "After Q").SetValue(false));
     Menu.AddItem(new MenuItem("afterw", "After W").SetValue(false));
     Menu.AddItem(new MenuItem("aftere", "After E").SetValue(false));
     Menu.AddItem(new MenuItem("afterr", "After R").SetValue(false));
     Menu.AddItem(new MenuItem("usepackets", "PACKET CASTING? (GARENA FIX)").SetValue(false));
     Menu.AddItem(new MenuItem("guccimode", "Are you THE GUCCI?").SetValue(false));
     Menu.AddToMainMenu();
     Random = new Random();
     FlashSlot = ObjectManager.Player.GetSpellSlot("SummonerFlash");
     IgniteSlot = ObjectManager.Player.GetSpellSlot("SummonerDot");
     Game.OnUpdate += OnUpdate;
     Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;
     
     //init chat disrespekter
     foreach (var en in ObjectManager.Get<Obj_AI_Hero>().Where(h => h.IsEnemy))
     {
         DeathsHistory.Add(en.NetworkId, en.Deaths);
     }
 }

        public static float GetSpellDamage(Obj_AI_Base enemy, SpellSlot slot, bool IsAbility = true, bool IsAAOrTargetted = false)
        {
            float damage = new float();

            foreach (var dmg in SpellsDamage.Where(it => it.Spell.Slot == slot))
            {
                if (dmg.DamageType == DamageType.Magical)
                {
                    damage += Player.Instance.CalculateDamageOnUnit(enemy, dmg.DamageType, dmg.SpellDamageValue[dmg.Spell.Level] + dmg.SpellDamageModifier[dmg.Spell.Level] * Player.Instance.FlatMagicDamageMod, IsAbility, IsAAOrTargetted);
                    continue;
                }

                if (dmg.DamageType == DamageType.Physical)
                {
                    damage += Player.Instance.CalculateDamageOnUnit(enemy, dmg.DamageType, dmg.SpellDamageValue[dmg.Spell.Level] + dmg.SpellDamageModifier[dmg.Spell.Level] * Player.Instance.FlatPhysicalDamageMod, IsAbility, IsAAOrTargetted);
                    continue;
                }

                if (dmg.DamageType == DamageType.True)
                {
                    damage += Player.Instance.CalculateDamageOnUnit(enemy, dmg.DamageType, dmg.SpellDamageValue[dmg.Spell.Level] + dmg.SpellDamageModifier[dmg.Spell.Level] * Player.Instance.FlatPhysicalDamageMod, IsAbility, IsAAOrTargetted);
                    continue;
                }
            }

            return damage;
        }