Esempio n. 1
0
 public void CastE()
 {
     if (!SpellManager.E.Ready)
     {
         return;
     }
     if (!Rpos.Equals(new Vector3()))
     {
         if (target.Distance(Rpos) < SpellManager.E.Range)
         {
             SpellManager.E.Cast();
         }
     }
     if (!Wpos.Equals(new Vector3()))
     {
         if (target.Distance(Wpos) < SpellManager.E.Range)
         {
             SpellManager.E.Cast();
         }
     }
     if (MyHero.Distance(target) < SpellManager.E.Range)
     {
         SpellManager.E.Cast();
     }
 }
Esempio n. 2
0
        public void DoCombo()
        {
            var globalrange = GeneralMenu.RootM["combo"]["forcer"].As <MenuBool>().Enabled&& GeneralMenu.RootM["combo"]["useR"].As <MenuBool>().Enabled&& SpellManager.R.Ready && this.IsR1() ? SpellManager.R.Range - 5 : 1500;

            if (target == null || !target.IsValid)
            {
                return;
            }
            var Wcastpos = new Vector3();

            if (!Rpos.Equals(new Vector3()))
            {
                switch (GeneralMenu.RootM["combo"]["rlogic"].As <MenuList>().Value)
                {
                case 0:
                    Wcastpos = (target.ServerPosition + (target.ServerPosition - Rpos).Normalized() * 450);
                    break;

                case 1:
                    Wcastpos = (MyHero.ServerPosition + (SpellManager.R.GetPrediction(target).CastPosition - Rpos).Normalized() * SpellManager.W.Range).To2D().Perpendicular().To3D();
                    break;

                case 2:
                    Wcastpos = Game.CursorPos;
                    break;
                }
            }
            if (MyHero.Distance(target) < globalrange)
            {
                if (MyHero.Distance(target) < SpellManager.R.Range &&
                    GeneralMenu.RootM["combo"]["useR"].As <MenuBool>().Enabled&& !GeneralMenu.RootM["combo"]["blacklist"]["use" + target.ChampionName.ToLower()].As <MenuBool>().Enabled)
                {
                    this.CastR(target);
                }


                if (target.HasBuff("zedrtargetmark"))
                {
                    if (GeneralMenu.RootM["combo"]["useW"].As <MenuBool>().Enabled&& MyHero.Distance(target) < SpellManager.W.Range)
                    {
                        this.CastW(Wcastpos);
                    }
                }
                else
                {
                    if (GeneralMenu.RootM["combo"]["useW"].As <MenuBool>().Enabled&& MyHero.Distance(target) < SpellManager.W.Range && this.IsW1())
                    {
                        this.CastW(target.ServerPosition);
                    }

                    else if (MyHero.Distance(target) > SpellManager.W.Range && target.IsValidTarget(SpellManager.W.Range + SpellManager.Q.Range / 2) &&
                             GeneralMenu.RootM["combo"]["useW"].As <MenuBool>().Enabled)
                    {
                        var Wposition = MyHero.ServerPosition.Extend(target.ServerPosition, 700f);
                        this.CastW(Wposition);
                        if (GeneralMenu.RootM["combo"]["secondw"].As <MenuBool>().Enabled)
                        {
                            this.CastW2();
                        }
                    }
                }

                if (MyHero.Distance(target) < SpellManager.Q.Range && GeneralMenu.RootM["combo"]["useQ"].As <MenuBool>().Enabled)
                {
                    if (!Wpos.Equals(new Vector3()) && MyHero.SpellBook.GetSpell(SpellSlot.W).Name == "ZedW2")
                    {
                        this.CastQ(target);
                    }
                    else if (!SpellManager.W.Ready || MyHero.SpellBook.GetSpell(SpellSlot.W).Name != "ZedW2" || Wpos.Equals(new Vector3()))
                    {
                        this.CastQ(target);
                    }
                }

                if (GeneralMenu.RootM["combo"]["useE"].As <MenuBool>().Enabled)
                {
                    this.CastE();
                }

                if (SpellManager.W.Ready && GeneralMenu.RootM["combo"]["wgap"].As <MenuBool>().Enabled&&
                    target.IsValidTarget(1400) && !target.IsValidTarget(850)
                    )
                {
                    var Wposition = MyHero.ServerPosition.Extend(target.ServerPosition, 700f);
                    SpellManager.W.Cast(Wposition);
                }

                if (SpellManager.IsIgnite)
                {
                    if (GlobalKeys.ComboKey.Active)
                    {
                        switch (GeneralMenu.RootM["combo"]["useI"].As <MenuList>().Value)
                        {
                        case 0:
                            foreach (var tar in GameObjects.EnemyHeroes.Where(a => a.IsValidTarget(1200) && !a.IsDead))
                            {
                                var dmgI   = (50 + ((MyHero.Level) * 20));
                                var health = tar.Health;
                                if (health < dmgI && MyHero.Distance(tar) < 600)
                                {
                                    if (SpellManager.Ignite.Ready)
                                    {
                                        SpellManager.Ignite.CastOnUnit(tar);
                                    }
                                }
                            }

                            break;

                        case 1:

                            foreach (var tar in GameObjects.EnemyHeroes.Where(a => a.IsValidTarget(1200) && !a.IsDead))
                            {
                                var dmgI   = (50 + ((MyHero.Level) * 20)) * 1.3;
                                var qdmg   = MyHero.GetSpellDamage(tar, SpellSlot.Q);
                                var edmg   = MyHero.GetSpellDamage(tar, SpellSlot.E);
                                var health = tar.Health;
                                var tt     = dmgI + qdmg + edmg;
                                if (health < tt && MyHero.Distance(tar) < 600)
                                {
                                    if (SpellManager.Ignite.Ready)
                                    {
                                        SpellManager.Ignite.CastOnUnit(tar);
                                    }
                                }
                            }
                            break;

                        case 2:

                            break;
                        }
                    }
                }
            }
        }
Esempio n. 3
0
        public void DoOneShotCombo(Obj_AI_Hero unit)
        {
            if (unit == null || !unit.IsValid || unit.IsDead || unit.Type != MyHero.Type || !unit.IsEnemy)
            {
                return;
            }
            if (!Rpos.Equals(new Vector3()))
            {
                ShadowPosOneShotCombo = (target.ServerPosition + (target.ServerPosition - Rpos).Normalized() * 450);
            }
            double dmgQ = MyHero.GetSpellDamage(unit, SpellSlot.Q);
            double dmgW = MyHero.GetSpellDamage(unit, SpellSlot.W);
            double dmgE = MyHero.GetSpellDamage(unit, SpellSlot.E);
            double dmgR = MyHero.TotalAttackDamage + ((dmgQ + dmgW + dmgE) * 0.25 + (dmgQ + dmgW + dmgE));

            totaldamage = dmgQ + dmgW + dmgE + dmgR;
            if (SpellManager.IsIgnite)
            {
                if (SpellManager.Ignite.Ready)
                {
                    var dmgI = (50 + ((MyHero.Level) * 20));
                    totaldamage += dmgI;
                }
            }
            //   Console.WriteLine(RootM["killsteal"]["oneshot"]["oto"]["use" + unit.ChampionName.ToLower()].As<MenuBool>().Enabled);
            if (totaldamage > unit.Health && MyHero.Mana > (MyHero.SpellBook.GetSpell(SpellSlot.Q).Cost + MyHero.SpellBook.GetSpell(SpellSlot.W).Cost) +
                MyHero.SpellBook.GetSpell(SpellSlot.E).Cost + MyHero.SpellBook.GetSpell(SpellSlot.R).Cost&&
                RootM["killsteal"]["oneshot"]["oto"].As <MenuBool>().Enabled)
            {
                if (SpellManager.Q.Ready && SpellManager.W.Ready && SpellManager.E.Ready && SpellManager.R.Ready)
                {
                    if (true)
                    {
                        if (MyHero.Distance(unit) < SpellManager.R.Range)
                        {
                            CastR(unit);
                        }
                        if (MyHero.Distance(unit) < SpellManager.W.Range)
                        {
                            if (!Rpos.Equals(new Vector3()))
                            {
                                this.CastW(ShadowPosOneShotCombo);
                            }
                        }
                        if (!Wpos.Equals(new Vector3()))
                        {
                            if (MyHero.Distance(unit) < SpellManager.Q.Range)
                            {
                                this.CastQ(unit);
                            }
                        }
                        if (!SpellManager.Q.Ready && !SpellManager.W.Ready)
                        {
                            SpellManager.E.Cast();
                        }
                        if (SpellManager.IsIgnite && SpellManager.Ignite.Ready)
                        {
                            foreach (var tar in GameObjects.EnemyHeroes.Where(a => a.IsValidTarget(1200) && !a.IsDead))
                            {
                                var dmgI   = (50 + ((MyHero.Level) * 20));
                                var health = tar.Health;
                                if (health < dmgI && MyHero.Distance(tar) < 600)
                                {
                                    SpellManager.Ignite.CastOnUnit(tar);
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 4
0
        public void DrawSpells()
        {
            #region Draw Spells

            if (GeneralMenu.RootM["draw"]["disable"].As <MenuBool>().Enabled)
            {
                return;
            }
            if (GeneralMenu.RootM["draw"]["damage"].As <MenuBool>().Enabled)
            {
                DamageIndicator.Draw(true, false);
            }
            if (GeneralMenu.RootM["draw"]["targetcal"].As <MenuBool>().Enabled)
            {
                DamageIndicator.Draw(false, true);
            }
            if (GeneralMenu.RootM["draw"]["drawS"]["qdraw"].As <MenuBool>().Enabled&& SpellManager.Q.Ready)
            {
                Render.Circle(MyHero.Position, SpellManager.Q.Range, 50, Color.Aquamarine);
            }
            if (GeneralMenu.RootM["draw"]["drawS"]["wdraw"].As <MenuBool>().Enabled&& SpellManager.W.Ready)
            {
                Render.Circle(MyHero.Position, SpellManager.W.Range, 50, Color.Cornsilk);
            }
            if (GeneralMenu.RootM["draw"]["drawS"]["edraw"].As <MenuBool>().Enabled&& SpellManager.E.Ready)
            {
                Render.Circle(MyHero.Position, SpellManager.E.Range, 50, Color.LightGreen);
            }
            if (GeneralMenu.RootM["draw"]["drawS"]["rdraw"].As <MenuBool>().Enabled&& SpellManager.R.Ready)
            {
                Render.Circle(MyHero.Position, SpellManager.R.Range, 50, Color.Brown);
            }

            if (!Wpos.Equals(new Vector3()) && GeneralMenu.RootM["draw"]["drawshadowW"]["enable"].As <MenuBool>().Enabled)
            {
                Render.Circle(Wpos, 100, 50, Color.DarkRed);
            }
            if (!Rpos.Equals(new Vector3()) && GeneralMenu.RootM["draw"]["drawshadowR"]["enable"].As <MenuBool>().Enabled)
            {
                Render.Circle(Rpos, 100, 50, Color.DarkRed);
            }
            if (GeneralMenu.RootM["misc"]["turretdive"]["Drawturret"].As <MenuBool>().Enabled)
            {
                foreach (var turret in GameObjects.AllGameObjects.Where(a => a.IsTurret))
                {
                    Render.Circle(turret.ServerPosition, 950, 50, Color.White);
                }
            }

            if (GeneralMenu.RootM["draw"]["drawshadowW"]["timer"].As <MenuBool>().Enabled)
            {
                if (!Wpos.Equals(new Vector3()))
                {
                    ;
                    var pos = Wpos.ToScreenPosition();
                    Render.Text(pos, Color.White, "Shadow Duration :" + Math.Round(StartTime - Game.ClockTime) + "s");
                }
            }
            if (GeneralMenu.RootM["draw"]["drawshadowR"]["timer"].As <MenuBool>().Enabled)
            {
                if (!Rpos.Equals(new Vector3()))
                {
                    ;
                    var pos = Rpos.ToScreenPosition();
                    Render.Text(pos, Color.White, "Shadow Duration :" + Math.Round(StartTimeR - Game.ClockTime) + "s");
                }
            }
            var drawpos = "Default";
            if (GeneralMenu.RootM["draw"]["combomode"].As <MenuBool>().Enabled)
            {
                switch (GeneralMenu.RootM["combo"]["rlogic"].As <MenuList>().Value)
                {
                case 0:
                    drawpos = "Current Combo Mode: Line";
                    break;

                case 1:
                    drawpos = "Current Combo Mode: Rectangle";
                    break;

                case 2:
                    drawpos = "Current Combo Mode: Mouse Position";
                    break;
                }
                var pos = MyHero.FloatingHealthBarPosition;
                pos.X += 43;
                pos.Y += 24;
                Render.Text(pos, Color.White, drawpos);
            }
            #endregion
        }