Beispiel #1
0
        private void Game_OnGameUpdate(EventArgs args)
        {
            if (GarenE)
            {
                orbwalker.SetMovement(false);
                if (orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.None)
                {
                    player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                }
            }
            else
            {
                orbwalker.SetMovement(true);
            }
            switch (orbwalker.ActiveMode)
            {
            case Orbwalking.OrbwalkingMode.Combo:
                Combo();
                break;

            case Orbwalking.OrbwalkingMode.Mixed:
                break;

            case Orbwalking.OrbwalkingMode.LaneClear:
                Clear();
                break;

            case Orbwalking.OrbwalkingMode.LastHit:
                break;

            default:
                break;
            }
            Jungle.CastSmite(config.Item("useSmite").GetValue <KeyBind>().Active);
        }
Beispiel #2
0
        private static void ComboEqr()
        {
            _player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
            var manacheck = _player.Mana > _player.Spellbook.GetSpell(SpellSlot.Q).ManaCost + _player.Spellbook.GetSpell(SpellSlot.E).ManaCost + _player.Spellbook.GetSpell(SpellSlot.R).ManaCost;
            var t         = SimpleTs.GetTarget(_q.Range + _r.Range, SimpleTs.DamageType.Magical);

            if (_e.IsReady() && _q.IsReady() && manacheck)
            {
                if (t != null && _player.Distance(t) > _q.Range)
                {
                    _e.Cast(t.ServerPosition, Packets());
                }
                _q.Cast(t.ServerPosition, Packets());
            }
            if (t != null && _config.Item("UseIgnite").GetValue <bool>() && _igniteSlot != SpellSlot.Unknown &&
                _player.SummonerSpellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                if (ComboDamage(t) > t.Health)
                {
                    _player.SummonerSpellbook.CastSpell(_igniteSlot, t);
                }
            }
            if (_r.IsReady() && !_haveulti && t != null)
            {
                _r.CastIfHitchanceEquals(t, HitChance.Immobile, Packets());
            }
            if (_w.IsReady())
            {
                if (t != null && t.Distance(_player.Position) < _w.Range)
                {
                    _w.Cast();
                }
            }
            UseItemes(t);
        }
Beispiel #3
0
        private static void Feederino()
        {
            if (Player.Team == GameObjectTeam.Order)
            {
                Player.IssueOrder(GameObjectOrder.MoveTo, PurpleSpawn);
            }

            if (Player.Team == GameObjectTeam.Chaos)
            {
                Player.IssueOrder(GameObjectOrder.MoveTo, BlueSpawn);
            }

            if (Menu.Item("useSkillsActive").GetValue <bool>())
            {
                FeedSpells();
            }

            if (Menu.Item("sayShitActive").GetValue <bool>())
            {
                SayShit();
            }

            if (Menu.Item("laughingActive").GetValue <bool>())
            {
                Laughing();
            }

            if (Menu.Item("buyItemsActive").GetValue <bool>())
            {
                BuyItems();
            }
        }
Beispiel #4
0
 private static void onUpdate(EventArgs args)
 {
     if (!menu.Item("en").GetValue <bool>())
     {
         return;
     }
     if ((((order && (movangle < 0f || movangle > 4.5)) || (!order && (movangle < 3.3 && movangle > 1.3))) && Math.Abs(me.Position.To2D().Distance(bas) - (radius - 40)) < 30) && lastmov < Game.Time && !waiting)
     {
         waiting = true;
         dest    = new Vector2(bas.X, bas.Y + radius).RotateAroundPoint(bas, GetAngleDegree(me.Position.To2D(), bas));
         me.IssueOrder(GameObjectOrder.MoveTo, dest.To3D(), false);
         timeto          = me.Position.To2D().Distance(tgt.To2D()) / me.MoveSpeed;
         predictedMana   = me.PARRegenRate * timeto;
         predictedHealth = me.HPRegenRate * timeto;
     }
     if (havetp && menu.Item("tp").GetValue <bool>() && me.Distance(tploc) < 100 && me.MaxHealth * (.6f) < me.Health && me.MaxMana * (.6f) < me.Mana)
     {
         me.Spellbook.CastSpell(teleport.Slot, Hud.SelectedUnit);
     }
     if (!waiting || (!(me.MaxMana < 1) && !(predictedMana + me.Mana > me.MaxMana * (.97f))) ||
         !(predictedHealth + me.Health > me.MaxHealth * (.97f)))
     {
         return;
     }
     waiting = false;
     me.IssueOrder(GameObjectOrder.MoveTo, tgt, false);
 }
Beispiel #5
0
 public void ActiveExploit(Obj_AI_Base target)
 {
     if (Config.Menu.GetBool("Exploit"))
     {
         if (target == null)
         {
             target = (Obj_AI_Base)Config.Orbwalker.GetTarget();
         }
         if (target.IsValidTarget())
         {
             if (Game.Time * 1000 >= Orbwalking.LastAATick + 1)
             {
                 Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
             }
             if (Game.Time * 1000 > Orbwalking.LastAATick + Player.AttackDelay * 1000 - 150f)
             {
                 Player.IssueOrder(GameObjectOrder.AttackUnit, target);
             }
         }
         else
         {
             Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
         }
     }
 }
Beispiel #6
0
        public static void Harass()
        {
            if (player.Mana / player.MaxMana * 100 < xMenu.Item("manamanager").GetValue <Slider>().Value)
            {
                return;
            }


            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            {
                if (target.IsValidTarget(Q.Range) && Q.IsReady() && xMenu.Item("hQ").GetValue <bool>() == true)
                {
                    Q.Cast(target, xMenu.Item("Packet").GetValue <bool>());
                }

                if (target.IsValidTarget(E.Range) && E.IsReady() && xMenu.Item("hE").GetValue <bool>() == true)
                {
                    E.Cast(target, xMenu.Item("Packet").GetValue <bool>());
                    CastE2();
                }
                if (target.IsValidTarget(550) && target.HasBuff("luxilluminatingfraulein"))
                {
                    player.IssueOrder(GameObjectOrder.AttackUnit, target);
                }
            }
        }
Beispiel #7
0
        public static void Orbwalk(Vector3 goalPosition, AttackableUnit target, bool useDelay = true)
        {
            try
            {
                if (target != null && target.IsValidTarget() && CanAttack() && IsAllowedToAttack())
                {
                    if (MyHero.IssueOrder(GameObjectOrder.AttackUnit, target))
                    {
                        _lastAATick = DeathWalker.now + Game.Ping / 2;
                    }
                }
                if (!CanMove() || !IsAllowedToMove())
                {
                    return;
                }

                /*if ( MyHero.IsMelee() && target != null &&
                 *  target.Position.Distance(MyHero.Position) < GetAutoAttackRange(MyHero, target)
                 *  && target is Obj_AI_Hero && MyHero.Distance(target.Position) < 300)
                 * {
                 *  _movementPrediction.Delay = MyHero.BasicAttack.SpellCastTime;
                 *  _movementPrediction.Speed = MyHero.BasicAttack.MissileSpeed;
                 *  MoveTo(_movementPrediction.GetPrediction((Obj_AI_Hero)target).UnitPosition, -1, useDelay);
                 * }
                 * else*/
                MoveTo(goalPosition, -1, useDelay);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
Beispiel #8
0
        public static void summonSolider(Vector3 posIn)
        {
            if (!W.IsReady())
            {
                return;
            }
            var pos = (posIn.Distance(Player.Position, true) < W.RangeSqr) ? posIn : Player.Position.Extend(posIn, W.Range);

            Obj_AI_Base tower = DeathWalker.EnemyTowers.Where(tur => tur != null && tur.IsValid && tur.IsEnemy && tur.Health > 0 && tur.Distance(Player, true) < 700 * 700).OrderBy(tur => pos.Distance(tur.Position)).FirstOrDefault();

            if (tower != null)
            {
                var rad = tower.BoundingRadius + 150;
                if (tower.Distance(pos, true) <= rad * rad)
                {
                    var bestPo =
                        tower.BBox.GetCorners()
                        .Where(corn => corn.Distance(Player.Position, true) < W.RangeSqr)
                        .OrderBy(cor => cor.Distance(pos, true))
                        .FirstOrDefault();
                    pos = tower.Position.To2D().Extend(bestPo.To2D(), tower.BoundingRadius + 300).To3D();
                }
            }
            W.Cast(pos);
            Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
        }
Beispiel #9
0
        public static void doJayceInj(Obj_AI_Hero target)
        {
            if (lockedTarg != null)
            {
                target = lockedTarg;
            }
            else
            {
                lockedTarg = target;
            }


            if (isHammer)
            {
                castIgnite(target);

                if (/*inMyTowerRange(posAfterHammer(target)) &&*/ E2.IsReady())
                {
                    E2.Cast(target);
                }

                //If not in flash range  Q to get in it
                if (Player.Distance(target) > 400 && targetInRange(target, 600f))
                {
                    Q2.Cast(target);
                }

                if (!E2.IsReady() && !Q2.IsReady())
                {
                    R2.Cast();
                }
                Obj_AI_Base tower = ObjectManager.Get <Obj_AI_Turret>().Where(tur => tur.IsAlly && tur.Health > 0).OrderBy(tur => Player.Distance(tur)).First();
                if (Player.Distance(getBestPosToHammer(target.ServerPosition)) < 400 && tower.Distance(target) < 1500)
                {
                    Player.Spellbook.CastSpell(Player.GetSpellSlot("SummonerFlash"), getBestPosToHammer(target.ServerPosition));
                }
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }
            else
            {
                if (E1.IsReady() && Q1.IsReady() && gotManaFor(true, false, true))
                {
                    PredictionOutput po = QEmp1.GetPrediction(target);
                    if (po.Hitchance >= HitChance.Low && Player.Distance(po.UnitPosition) < (QEmp1.Range + target.BoundingRadius))
                    {
                        castQon = po.CastPosition;
                    }

                    // QEmp1.CastIfHitchanceEquals(target, Prediction.HitChance.HighHitchance);
                }
                else if (Q1.IsReady() && gotManaFor(true))
                {
                    Q1.Cast(target.Position);
                }
                else if (W1.IsReady() && gotManaFor(false, true) && targetInRange(getClosestEnem(), 1000f))
                {
                    W1.Cast();
                }
            }
        }
Beispiel #10
0
        private static void Game_OnUpdate()
        {
            if (Player.GetSpell(SpellSlot.W).ToggleState == 2)
            {
                Player.IssueOrder(OrderType.MoveTo, Game.CursorPos);
            }

            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }

            Killsteal();

            Flee();

            switch (Orbwalker.Implementation.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

            case OrbwalkingMode.Laneclear:
                Laneclear();
                Jungleclear();
                break;
            }
        }
Beispiel #11
0
 public static void Orbwalk(Vector3 Pos, Obj_AI_Base Target)
 {
     if (Target != null && (CanAttack() || HaveCancled()) && IsAllowedToAttack())
     {
         DisableNextAttack = false;
         FireBeforeAttack(Target);
         if (!DisableNextAttack)
         {
             if (CurrentMode != Mode.Harass || !Target.IsMinion || Config.Item("OW_Harass_LastHit").GetValue <bool>())
             {
                 Player.IssueOrder(GameObjectOrder.AttackUnit, Target);
                 LastAttack = Environment.TickCount + Game.Ping / 2;
             }
         }
     }
     if (!CanMove() || !IsAllowedToMove())
     {
         return;
     }
     if (Player.IsMelee() && Target != null && InAutoAttackRange(Target) && Config.Item("OW_Misc_MeleePrediction").GetValue <bool>() && Target is Obj_AI_Hero && Game.CursorPos.Distance(Target.Position) < 300)
     {
         MovePrediction.Delay = Player.BasicAttack.SpellCastTime;
         MovePrediction.Speed = Player.BasicAttack.MissileSpeed;
         MoveTo(MovePrediction.GetPrediction(Target).UnitPosition);
     }
     else
     {
         MoveTo(Pos);
     }
 }
Beispiel #12
0
        private static void OnDraw(EventArgs args)
        {
            if (DoExploitState > 0)
            {
                Drawing.DrawText(Drawing.Width / 2 - 300, Drawing.Height / 2 - 300, System.Drawing.Color.Red,
                                 "Recall Exploit Active with state: {0}", DoExploitState.ToString());
            }

            if (closestminion == null)
            {
                return;
            }


            if (DoExploitState == 3)
            {
                Player.Spellbook.CastSpell(SpellSlot.Recall);
                Utility.DelayAction.Add(2,
                                        () => { ChampionSpellAction[Player.ChampionName][0].CallbackObject(closestminion); });

                DoExploitState = 4;
            }

            if (DoExploitState == 4)
            {
                Utility.DelayAction.Add(2,
                                        () => { Player.IssueOrder(GameObjectOrder.AttackUnit, closestminion); });
                Utility.DelayAction.Add(4,
                                        () => { ChampionSpellAction[Player.ChampionName][1].CallbackObject(closestminion); });
            }
        }
Beispiel #13
0
 public static void Orbwalk(Vector3 goalPosition, Obj_AI_Base target)
 {
     if (target != null && (CanAttack() || HaveCancled()) && IsAllowedToAttack())
     {
         _disableNextAttack = false;
         FireBeforeAttack(target);
         if (!_disableNextAttack)
         {
             if (CurrentMode != Mode.Harass || !target.IsMinion || Menu.Item("Harass_Lasthit").GetValue <bool>())
             {
                 MyHero.IssueOrder(GameObjectOrder.AttackUnit, target);
                 _lastAATick = Environment.TickCount + Game.Ping / 2;
             }
         }
     }
     if (!CanMove() || !IsAllowedToMove())
     {
         return;
     }
     if (MyHero.IsMelee() && target != null && target.Distance(MyHero) < GetAutoAttackRange(MyHero, target) &&
         Menu.Item("orb_Melee_Prediction").GetValue <bool>() && target is Obj_AI_Hero && Game.CursorPos.Distance(target.Position) < 300)
     {
         _movementPrediction.Delay = MyHero.BasicAttack.SpellCastTime;
         _movementPrediction.Speed = MyHero.BasicAttack.MissileSpeed;
         MoveTo(_movementPrediction.GetPrediction(target).UnitPosition);
     }
     else
     {
         MoveTo(goalPosition);
     }
 }
Beispiel #14
0
        private static void UltimateLock()
        {
            Obj_AI_Hero      target           = TargetSelector.GetTarget(_spells[SpellSlot.R].Range, TargetSelector.DamageType.Physical);
            PredictionOutput targetPrediction = _spells[SpellSlot.R].GetPrediction(target);

            Vector3 endPosition  = Vector3.Normalize(_player.ServerPosition - target.ServerPosition);
            Vector3 castPosition = targetPrediction.CastPosition;

            Vector3 fullPoint =
                new Vector2(
                    castPosition.X + endPosition.X * _spells[SpellSlot.R].Range * 0.98f,
                    castPosition.Y + endPosition.Y * _spells[SpellSlot.R].Range * 0.98f).To3D();
            Vector3 closestPoint =
                _player.ServerPosition.To2D().Closest(new List <Vector3> {
                castPosition, fullPoint
            }.To2D()).To3D();

            if (closestPoint.IsValid() && !closestPoint.IsWall() &&
                castPosition.Distance(closestPoint) > _spells[SpellSlot.E].Range)
            {
                _player.IssueOrder(GameObjectOrder.MoveTo, closestPoint);
            }
            else if (fullPoint.IsValid() && !fullPoint.IsWall() &&
                     castPosition.Distance(fullPoint) < _spells[SpellSlot.R].Range &&
                     castPosition.Distance(fullPoint) > 100)
            {
                _player.IssueOrder(GameObjectOrder.MoveTo, fullPoint);
            }
        }
Beispiel #15
0
        public static void doHarassHard(Obj_AI_Hero target)
        {
            Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            igniteIfKIllable(target);
            if (targetInRange(target, 125f) && !Player.IsChanneling)
            {
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }

            if (E.IsReady() && targetInRange(target, E.Range))
            {
                E.Cast(target);
            }

            if (W.IsReady() && targetInRange(target, W.Range) && targetHasCut(target) && targetBleeds(target) && !targetInRange(target, 80))
            {
                PredictionOutput po = W.GetPrediction(target);
                if (po.Hitchance == HitChance.High)
                {
                    W.Cast(po.CastPosition);
                }
            }

            castItemsFull(target);
        }
        private static void MoveTo(Vector3 position, float holdAreaRadius = 0, bool overrideTimer = false)
        {
            if ((Environment.TickCount - LastMoveCommandT < (80 + _config.Item("_worstorbwalker_miscellaneous_humanizerdelay").GetValue <Slider>().Value) && !overrideTimer))
            {
                return;
            }

            LastMoveCommandT = Environment.TickCount;

            if (Player.ServerPosition.Distance(position) < holdAreaRadius)
            {
                if (Player.Path.Count() > 1)
                {
                    Player.IssueOrder(GameObjectOrder.HoldPosition, Player.ServerPosition);
                }
                return;
            }

            Vector3 point = position;

            if (Player.ServerPosition.Distance(position) > 400)
            {
                point = Player.ServerPosition + 400 * (position.To2D() - Player.ServerPosition.To2D()).Normalized().To3D();
            }

            Player.IssueOrder(GameObjectOrder.MoveTo, point);
        }
Beispiel #17
0
        /// <summary>
        ///     Quick usage of moving a hero
        /// </summary>
        /// <param name="player">Hero Object</param>
        /// <param name="pVector3">Position to Move</param>
        /// <param name="holdAreaRadius">Hold Radius</param>
        public static void MoveTo(this Obj_AI_Hero @player, Vector3 pVector3, float holdAreaRadius = 0)
        {
            if (Environment.TickCount - _lastMoveCommandT < Delay)
            {
                return;
            }

            _lastMoveCommandT = Environment.TickCount;

            if (@player.ServerPosition.Distance(pVector3) < holdAreaRadius)
            {
                if (@player.Path.Count() <= 1)
                {
                    return;
                }

                @player.IssueOrder(GameObjectOrder.HoldPosition, @player.ServerPosition);

                return;
            }

            var point = @player.ServerPosition +
                        ((Random.NextFloat(0.6f, 1) + 0.2f) * MinDistance) *
                        (pVector3.To2D() - @player.ServerPosition.To2D()).Normalized().To3D();

            @player.IssueOrder(GameObjectOrder.MoveTo, point);
        }
Beispiel #18
0
    public static void Killsteal()
    {
        if (Environment.TickCount > KillstealTick + 1000)
        {
            CheckFlagKS = false;
        }


        foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(target => target.IsValidTarget(_r.Range)))
        {
            if (CheckFlagKS && target.HasBuff("dianamoonlight", true))
            {
                _r.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
                CheckFlagKS = false;
            }

            if (Player.GetAutoAttackDamage(target) * 2 > target.Health && Player.Distance(target) < 125)
            {
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
                return;
            }

            if (Config.Item("Killsteal-Use-Q").GetValue <bool>() && _q.IsReady() && _q.GetDamage(target) - 10 >= target.Health && Player.Distance(target) <= _q.Range - 10)
            {
                _q.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
            }
            else if (!Config.Item("Killsteal-Use-R").GetValue <bool>() || (Utility.UnderTurret(target, true) && (Player.Health / Player.MaxHealth < 0.6)))
            {
                return;
            }
            else if (_r.IsReady() && _r.GetDamage(target) - 10 >= target.Health && Player.Distance(target) <= _r.Range - 5)
            {
                _r.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
            }
            else if (!Config.Item("Killsteal-Use-Q").GetValue <bool>())
            {
                return;
            }
            else if (_q.IsReady() && _r.IsReady() && Player.Distance(target) <= _r.Range - 10)
            {
                if (_q.GetDamage(target) + _r.GetDamage(target) - 10 >= target.Health)
                {
                    _r.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
                    _q.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
                }
                else if (_q.GetDamage(target) + (_r.GetDamage(target) * 2) - 10 >= target.Health)
                {
                    _q.Cast(target, Config.Item("Packet Casting").GetValue <bool>());
                    CheckFlagKS   = true;
                    KillstealTick = Environment.TickCount;
                }
            }

            if (Config.Item("Killsteal-Use-Ignite").GetValue <bool>() && Ignite != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(Ignite) == SpellState.Ready && Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) - 10 >= target.Health)
            {
                Player.SummonerSpellbook.CastSpell(Ignite, target);
            }
        }
    }
Beispiel #19
0
 private void AfterAttack(AttackableUnit unit, AttackableUnit target)
 {
     if (unit.IsMe && Q.IsReady() && config.Item("useqAAA").GetValue <bool>() && !GarenE && target.IsEnemy && target is Obj_AI_Hero)
     {
         Q.Cast(config.Item("packets").GetValue <bool>());
         player.IssueOrder(GameObjectOrder.AutoAttack, target);
     }
 }
Beispiel #20
0
 private void beforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (args.Unit.IsMe && Q.IsReady() && orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && config.Item("useqLC").GetValue <bool>() && !(args.Target is Obj_AI_Hero) && (args.Target.Health > 700))
     {
         Q.Cast(config.Item("packets").GetValue <bool>());
         player.IssueOrder(GameObjectOrder.AutoAttack, args.Target);
     }
 }
Beispiel #21
0
        public static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (sender.Distance(Player) > 1400)
            {
                return;
            }
            var qss = ItemId.Quicksilver_Sash;

            if (Items.HasItem((int)ItemId.Mercurial_Scimitar))
            {
                qss = ItemId.Mercurial_Scimitar;
            }

            if (sender.IsValid <Obj_AI_Hero>() && sender.IsEnemy && args.Target == Player)
            {
                var sData = SpellDb.GetByName(args.SData.Name);
                if (sData != null && sData.ChampionName.ToLower() == "syndra" && sData.Spellslot == Utils.SpellSlot.R)
                {
                    Utility.DelayAction.Add(150, () => UseItem(qss));
                }
                if (args.SData.Name == "summonerdot" && sender.GetSpellDamage(Player, "summonerdot") < Player.Health + sender.GetAutoAttackDamage(Player))
                {
                    UseItem(qss);
                }
            }

            if (!Program.ActivatorMenu.Item("exploits").GetValue <bool>())
            {
                return;
            }

            if (sender.Name.ToLower() == "cassiopeia" && args.SData.Name.ToLower().Contains("petrifying") && Player.IsFacing(sender) && Player.ServerPosition.Distance(sender.ServerPosition) + Player.BoundingRadius <= 1000)
            {
                if (exploitEndTime < Environment.TickCount)
                {
                    exploitEndTime = Environment.TickCount + 1000;
                }
                Player.IssueOrder(GameObjectOrder.MoveTo, sender.ServerPosition.Extend(Player.ServerPosition, Player.ServerPosition.Distance(sender.ServerPosition) + 100));
            }

            if (sender.Name.ToLower() == "shaco" && args.SData.Name.ToLower().Contains("twoshiv") && !Player.IsFacing(sender) && args.Target.IsMe && !Player.IsFacing(sender))
            {
                if (exploitEndTime < Environment.TickCount)
                {
                    exploitEndTime = Environment.TickCount + 300;
                }
                Player.IssueOrder(GameObjectOrder.MoveTo, sender.ServerPosition.Extend(Player.ServerPosition, Player.ServerPosition.Distance(sender.ServerPosition) - 100));
            }

            if (sender.Name.ToLower() == "tryndamere" && args.SData.Name.ToLower().Contains("mockingshout") && !Player.IsFacing(sender) && Player.ServerPosition.Distance(sender.ServerPosition) + Player.BoundingRadius <= 900)
            {
                if (exploitEndTime < Environment.TickCount)
                {
                    exploitEndTime = Environment.TickCount + 800;
                }
                Player.IssueOrder(GameObjectOrder.MoveTo, sender.ServerPosition.Extend(Player.ServerPosition, Player.ServerPosition.Distance(sender.ServerPosition) - 100));
            }
        }
Beispiel #22
0
        public static void doJayceInj(Obj_AI_Hero target)
        {
            if (lockedTarg != null)
            {
                target = lockedTarg;
            }
            else
            {
                lockedTarg = target;
            }


            if (isHammer)
            {
                if (inMyTowerRange(posAfterHammer(target)) && E2.IsReady())
                {
                    E2.Cast(target);
                }

                //If not in flash range  Q to get in it
                if (Player.Distance(target) > 400 && targetInRange(target, 600f))
                {
                    Q2.Cast(target);
                }

                if (!E2.IsReady() && !Q2.IsReady())
                {
                    R2.Cast();
                }

                if (Player.Distance(getBestPosToHammer(target)) < 400)
                {
                    Player.SummonerSpellbook.CastSpell(Player.GetSpellSlot("SummonerFlash"), getBestPosToHammer(target));
                }
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }
            else
            {
                if (E1.IsReady() && Q1.IsReady() && gotManaFor(true, false, true))
                {
                    PredictionOutput po = QEmp1.GetPrediction(target);
                    if (po.Hitchance >= HitChance.Low && Player.Distance(po.CastPosition) < (QEmp1.Range + target.BoundingRadius))
                    {
                        castQon = po.CastPosition;
                    }

                    // QEmp1.CastIfHitchanceEquals(target, HitChance.High);
                }
                else if (Q1.IsReady() && gotManaFor(true))
                {
                    Q1.Cast(target.Position);
                }
                else if (W1.IsReady() && gotManaFor(false, true) && targetInRange(getClosestEnem(), 1000f))
                {
                    W1.Cast();
                }
            }
        }
Beispiel #23
0
 private void Obj_AI_Base_OnIssueOrder(Obj_AI_Base sender, GameObjectIssueOrderEventArgs args)
 {
     if (args.Order == GameObjectOrder.AttackUnit && Q.IsCharging)
     {
         Program.debug("BADDDD");
         Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
         args.Process = false;
     }
 }
Beispiel #24
0
        static void Escape(escapeModes mode)
        {
            switch (mode)
            {
            case escapeModes.TOMOUSE:     //Escaping to mouse
            {
                Vector3 cursorPos = Game.CursorPos;
                Vector3 pos       = V3E(player.Position, cursorPos, (float)-15);
                if (!IsPassWall(player.Position, cursorPos))             //Escaping to mouse pos
                {
                    Vector3 pass = V3E(player.Position, cursorPos, 100); //Point to move closer to the wall (could be better, i know, i'll improve it)
                    player.IssueOrder(GameObjectOrder.MoveTo, new Vector3(pass.X, pass.Y, 0));
                    SMouse.addMouseEvent(new Vector3(pass.X, pass.Y, 0), true, false);
                }
                else         //Escape through the wall (Flash fail)
                {
                    Vector3 jumpPred = V3E(pos, cursorPos, 700);
                    if (IsWall(jumpPred.To2D()) && IsPassWall(player.Position, jumpPred))          //Can't we jump over?
                    {
                        Vector3 pass = V3E(player.Position, jumpPred, 100);                        //Point to move closer to the wall (could be better, i know, i'll improve it)
                        player.IssueOrder(GameObjectOrder.MoveTo, new Vector3(pass.X, pass.Y, 0)); //Move closer to the wall
                        SMouse.addMouseEvent(new Vector3(pass.X, pass.Y, 0), true, false);
                        return;
                    }
                    else      //Yes! We can!
                    {         //Stand still
                        player.IssueOrder(GameObjectOrder.MoveTo, new Vector3(player.Position.X, player.Position.Y, 0));
                    }
                }
                if (!W.IsReady())
                {
                    return;            //Simple!
                }
                W.Cast(pos);           //Poof! W cast!
                SMouse.addMouseEvent(pos, false, CRB);
                Wmode = WModes.ESCAPE; //WMode
            }
            break;

            case escapeModes.FROMTURRET:
            {
                Vector3 WPos      = V3E(player.Position, TUnit_obj.Position, 40);                    //Positions
                Vector3 escapePos = V3E(player.Position, TUnit_obj.Position, -450);
                player.IssueOrder(GameObjectOrder.MoveTo, new Vector3(escapePos.X, escapePos.Y, 0)); //Move away
                if (!W.IsReady())
                {
                    return;          //Simple!
                }
                W.Cast(WPos);        //Cast W to move away
                SMouse.addMouseEvent(WPos, false, CRB);
                //TUnit_obj.isAggred = false;//Turrent isn't focusing us anymore
                Wmode = WModes.ESCAPE;        //???PROFIT
            }
            break;
            }
        }
Beispiel #25
0
        public static void Combo(Obj_AI_Hero targetHero) //Thanks Roach_ For helping me with combo
        {
            if (!targetHero.IsValidTarget())
            {
                return;
            }
            var enemyQBuffed = targetHero.HasBuff("BlindMonkQOne", true);
            var autoAttacks  = Config.Menu.Item("aaBetween").GetValue <Slider>().Value;
            var passiveCount = LeeUtility.BuffCount("blindmonkpassive_cosmetic");

            if (!enemyQBuffed && autoAttacks != 0 && passiveCount >= Math.Abs(autoAttacks - 2))
            {
                return;
            }
            if (LeeUtility.MenuParamBool("useQC") && Q.IsReady() && Q.Instance.Name == "BlindMonkQOne" && R.IsReady() &&
                Vector3.DistanceSquared(targetHero.ServerPosition, Player.ServerPosition) <= 375 * 375)
            {
                LeeUtility.CastQ(targetHero, QMode.Combo);
            }
            else if (LeeUtility.MenuParamBool("useQC") && enemyQBuffed && R.IsReady())
            {
                if (targetHero.Distance(Player) <= R.Range)
                {
                    R.Cast(targetHero, LeeUtility.MenuParamBool("packetCast"));
                    Utility.DelayAction.Add(750, () => Q.Cast(targetHero));
                }
                else
                {
                    Player.IssueOrder(GameObjectOrder.MoveTo, targetHero.ServerPosition);
                }
            }
            else
            {
                if (LeeUtility.MenuParamBool("useQC") && LeeUtility.CastQ(targetHero, QMode.Combo))
                {
                    var qPos = Q.GetPrediction(targetHero);
                    Utility.DelayAction.Add(
                        (int)(targetHero.Distance(qPos.UnitPosition) / Q.Speed * 1000) + 300 + Game.Ping, () => Q.Cast());
                }
                if (Vector3.DistanceSquared(targetHero.ServerPosition, Player.ServerPosition) <= 350 * 350 &&
                    E.IsReady())
                {
                    if (E.IsReady() && LeeUtility.MenuParamBool("useE1C") &&
                        (E.Instance.Name == "BlindMonkEOne" || LeeUtility.MenuParamBool("useE2C")))
                    {
                        E.Cast();
                    }
                    else if (!Q.IsReady() && !E.IsReady() && !R.IsReady() && LeeUtility.MenuParamBool("useW1C") &&
                             (W.Instance.Name == "BlindMonkWOne" || LeeUtility.MenuParamBool("useW2C")) &&
                             Player.Mana - 50 >= 50)
                    {
                        W.Cast();
                    }
                }
            }
        }
Beispiel #26
0
        public static void Combo()
        {
            var eTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);

            if (eTarget == null)
            {
                return;
            }

            var useQ            = Config.Item("UseQCombo").GetValue <bool>();
            var useW            = Config.Item("UseWCombo").GetValue <bool>();
            var useE            = Config.Item("UseECombo").GetValue <bool>();
            var useR            = Config.Item("UseRCombo").GetValue <bool>();
            var useIgnite       = Config.Item("UseIgnite").GetValue <bool>();
            var packetCast      = Config.Item("PacketCast").GetValue <bool>();
            var RMaxStacksCombo = Config.Item("RMaxStacksCombo").GetValue <Slider>().Value;
            var EManaCombo      = Config.Item("EManaCombo").GetValue <Slider>().Value;

            if (eTarget.IsValidTarget(Q.Range) && Q.IsReady() && useQ)
            {
                Q.CastIfHitchanceEquals(eTarget, eTarget.IsMoving ? HitChance.High : HitChance.Medium, packetCast);
            }

            if (!HasWBuff() && Player.AttackRange < Player.Distance(eTarget) && Player.Distance(eTarget) <= (Orbwalking.GetRealAutoAttackRange(eTarget) + W.Range) && W.IsReady() && useW)
            {
                if (packetCast)
                {
                    Packet.C2S.Cast.Encoded(new Packet.C2S.Cast.Struct(Player.NetworkId, SpellSlot.W)).Send();
                }
                else
                {
                    W.Cast();
                }

                Player.IssueOrder(GameObjectOrder.AttackUnit, eTarget);
            }

            if (eTarget.IsValidTarget(E.Range) && E.IsReady() && useE && Player.GetManaPerc() > EManaCombo)
            {
                E.CastIfHitchanceEquals(eTarget, eTarget.IsMoving ? HitChance.High : HitChance.Medium, packetCast);
            }

            if (eTarget.IsValidTarget(R.Range) && R.IsReady() && GetRStacks() < RMaxStacksCombo && useR && Player.Distance(eTarget) > Player.AttackRange)
            {
                R.CastIfHitchanceEquals(eTarget, eTarget.IsMoving ? HitChance.High : HitChance.Medium, packetCast);
            }

            if (IgniteManager.CanKill(eTarget))
            {
                if (IgniteManager.Cast(eTarget))
                {
                    Game.PrintChat(string.Format("Ignite Combo KS -> {0} ", eTarget.SkinName));
                }
            }
        }
Beispiel #27
0
 public static void attackMinion(Obj_AI_Base target, Vector3 moveTo)
 {
     if (target != null && CanAttack() && (player.IsMelee() || InAutoAttackRange(target)))
     {
         if (player.IssueOrder(GameObjectOrder.AttackUnit, target))
         {
             _lastAATick = Environment.TickCount + Game.Ping / 2;
         }
     }
     MoveTo(moveTo);
 }
Beispiel #28
0
 public static void doAttack(AttackableUnit target)
 {
     if (player.IssueOrder(GameObjectOrder.AttackUnit, target))
     {
         FireBeforeAttack(target);
         playerStoped       = false;
         lastAutoAttack     = now;
         lastAutoAttackMove = now;
         lastAutoAttackUnit = target;
     }
 }
Beispiel #29
0
 private static void Orbwalk(Vector3 goalPosition, AttackableUnit target)
 {
     if (target != null && CanAttack() && config.Item("LastHit_Key").GetValue <KeyBind>().Active &&
         Player.IssueOrder(GameObjectOrder.AttackUnit, target))
     {
         lastAutoAttackTick = Environment.TickCount + Game.Ping / 2;
     }
     else if (config.Item("LastHit_Move").GetValue <bool>() && CanMove())
     {
         MoveTo(goalPosition);
     }
 }
Beispiel #30
0
        private void Game_OnGameUpdate(EventArgs args)
        {
            if (KurisuRiven.config.Item("exportjump").GetValue <KeyBind>().Active&& canexport)
            {
                using (var file = new System.IO.StreamWriter(@"C:\Rivenjumps.txt"))
                {
                    file.WriteLine("jumpList.Add(new Coordinate(new Vector3(" + player.Position.X + "f," + player.Position.Y + "f," + player.Position.Z + "f),");
                    file.WriteLine("new Vector3(" + Game.CursorPos.X + "f," + Game.CursorPos.Y + "f," + Game.CursorPos.Z + "f)));");
                    file.Close();
                }

                Game.PrintChat("Debug: Position exported!");
                canexport = false;
            }
            else
            {
                canexport = true;
            }

            if (!active && KurisuRiven.config.Item("jumpkey").GetValue <KeyBind>().Active&& KurisuRiven.cleavecount == 2)
            {
                var playeradjacentpos = (float)(minrange + 1);
                for (int i = 0; i < jumpList.Count; i++)
                {
                    Coordinate pos = jumpList[i];
                    if (player.Distance(pos.pointA) < playeradjacentpos || player.Distance(pos.pointB) < playeradjacentpos)
                    {
                        active = true;
                        if (player.Distance(pos.pointA) < player.Distance(pos.pointB))
                        {
                            playeradjacentpos = player.Distance(pos.pointA);
                            startpoint        = pos.pointA;
                            endpoint          = pos.pointB;
                        }
                        else
                        {
                            playeradjacentpos = player.Distance(pos.pointB);
                            startpoint        = pos.pointB;
                            endpoint          = pos.pointA;
                        }
                    }
                }
                if (active)
                {
                    directionpoint.X = startpoint.X - endpoint.X;
                    directionpoint.Y = startpoint.Y - endpoint.Y;

                    player.IssueOrder(GameObjectOrder.HoldPosition, player.ServerPosition);
                    Packet.C2S.Move.Encoded(new Packet.C2S.Move.Struct(startpoint.X, startpoint.Y)).Send();
                    Utility.DelayAction.Add(Game.Ping + 70, Direction1);
                }
            }
        }
Beispiel #31
0
        private static void OnGameUpdate(EventArgs args)
        {
            Player = ObjectManager.Player;
            Q = new Spell(SpellSlot.Q, Player.AttackRange + 50);
            SOD = new Items.Item(3131, Player.AttackRange + 50);

            Orbwalker.SetAttack(true);
            if (Config.Item("ActiveCombo").GetValue<KeyBind>().Active)
            {
                Combo();
            }
            if (Config.Item("TripleQ").GetValue<KeyBind>().Active)
            {

                TripleQ();


            }
            if (Config.Item("ActiveHarass").GetValue<KeyBind>().Active)
            {
                Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                Harass();
            }
            if (Config.Item("ActiveLane").GetValue<KeyBind>().Active)
            {
                Farm();
            }
            if (Config.Item("ActiveKs").GetValue<bool>())
            {
                KillSteal();
            }
            if (Config.Item("AutoW").GetValue<bool>())
            {
                Heal();

            }

        }