C# Common.Orbwalking类代码示例

 /// <summary>
 ///     Fired when the game is updated.
 /// </summary>
 /// <param name="args">The <see cref="EventArgs" /> instance containing the event data.</param>
 public static void LastHit(Orbwalking.BeforeAttackEventArgs args)
 {
     const float SplashRange = 160f;
     var isUsingFishBones = ObjectManager.Player.HasBuff("JinxQ");
     var minionTarget = (Obj_AI_Minion)args.Target;
     var canLastHit = Variables.QMenu.Item("lasthit").GetValue<SliderButton>().Value.Item2
                      && ObjectManager.Player.ManaPercent
                      > ManaManager.GetNeededMana(Variables.W.Slot, Variables.QMenu.Item("lasthit"));
     if (minionTarget != null)
     {
         var minionsInRange =
             ObjectManager.Get<Obj_AI_Minion>().Count(m => m.Distance(minionTarget) < SplashRange);
         if (isUsingFishBones)
         {
             if (minionsInRange < 3)
             {
                 Variables.Q.Cast();
             }
         }
         else
         {
             if (minionsInRange >= 3 && canLastHit)
             {
                 Variables.Q.Cast();
             }
         }
     }
 }

 /// <summary>
 /// Called Before the orbwalker attacks.
 /// </summary>
 /// <param name="args">The <see cref="Orbwalking.BeforeAttackEventArgs"/> instance containing the event data.</param>
 private void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (ShouldGetExecuted())
     {
         args.Process = false;
     }
 }

 private void OW(Orbwalking.BeforeAttackEventArgs args)
 {
     if (ShouldGetExecuted() && ObjectManager.Player.Buffs.Any(m => m.Name.ToLower() == "vaynetumblefade"))
     {
         args.Process = false;
     }
 }

 public static void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (args.Unit.IsMe && Program.Q.IsReady() && Program.ComboMenu.Item("QCombo").GetValue<bool>())
     {
         if (args.Target.IsValid<Obj_AI_Hero>())
         {
             var target = (Obj_AI_Hero) args.Target;
             if (Program.ComboMenu.Item("RCombo").GetValue<bool>() && Program.R.IsReady() &&
                 Program.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
             {
                 if (!target.UnderTurret(true))
                 {
                     Program.R.Cast();
                 }
             }
             if (target.IsMelee && target.IsFacing(Heroes.Player))
             {
                 if (target.Distance(Heroes.Player.ServerPosition) < 325)
                 {
                     var tumblePosition = target.GetTumblePos();
                     args.Process = false;
                     Tumble.Cast(tumblePosition);
                 }
             }
         }
     }
 }

 private void Orbwalking_BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if(Program.Combo && W.IsReady() && FindCard == 1 && W.Instance.Name != "PickACard" &&  Config.Item("WblockAA", true).GetValue<bool>())
     {
         args.Process = false;
     }
 }

 private static void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (args.Unit.IsMe)
     {
         args.Process = !player.HasBuff("KatarinaR");
     }
 }

        private void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
        {
            if (!Q.IsReady() || !Config.Item("autoQ", true).GetValue<bool>() || !(args.Target is Obj_AI_Hero))
                return;
            var t = (Obj_AI_Hero)args.Target;

            if (FishBoneActive && t.IsValidTarget())
            {
                var realDistance = GetRealDistance(t);
                if (Program.Combo && realDistance < GetRealPowPowRange(t) && (Player.Mana < RMANA + 20 || Player.GetAutoAttackDamage(t) * 3 < t.Health))
                    Q.Cast();
                else if (Program.Farm && Config.Item("Qharras", true).GetValue<bool>() && (realDistance > bonusRange() || realDistance < GetRealPowPowRange(t) || Player.Mana < RMANA + EMANA + WMANA + WMANA))
                    Q.Cast();
            }

            if (Program.LaneClear && !FishBoneActive && Config.Item("farmQ", true).GetValue<bool>() && Player.ManaPercent > Config.Item("Mana", true).GetValue<Slider>().Value && Player.Mana > RMANA + EMANA + WMANA + 30)
            {

                var allMinionsQ = MinionManager.GetMinions(Player.ServerPosition, bonusRange());
                foreach (var minion in allMinionsQ.Where(
                    minion => args.Target.NetworkId != minion.NetworkId && minion.Distance(args.Target.Position) < 200 && (5 - Q.Level) * Player.GetAutoAttackDamage(minion) < args.Target.Health && (5 - Q.Level) * Player.GetAutoAttackDamage(minion) < minion.Health))
                {
                    Q.Cast();
                }
            }
        }

        /// <summary>
        ///     Called on orbwalker action.
        /// </summary>
        /// <param name="args">The <see cref="Orbwalking.BeforeAttackEventArgs" /> instance containing the event data.</param>
        public static void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
        {
            /// <summary>
            ///     Check for R Instance.
            /// </summary>
            args.Process = !Variables.R.Instance.Name.Equals("QuinnRFinale");

            /// <summary>
            ///     The Target Forcing Logic.
            /// </summary>
            var hero = (Obj_AI_Hero)args.Target;
            var bestTarget =
                HeroManager.Enemies.Where(
                    t => t.IsValidTarget(Orbwalking.GetRealAutoAttackRange(t)) && t.HasBuff("quinnw"))
                    .OrderByDescending(o => Data.Get<ChampionPriorityData>().GetPriority(o.ChampionName))
                    .FirstOrDefault();
            if (hero != null && bestTarget?.NetworkId != hero.NetworkId
                && Variables.GetRealHealth(hero) > ObjectManager.Player.GetAutoAttackDamage(hero) * 3)
            {
                Variables.Orbwalker.ForceTarget(bestTarget);
                return;
            }

            Variables.Orbwalker.ForceTarget(null);
        }

        public CommonForceUltimate(ZedMenu zedMenu, ZedSpells zedSpells, Orbwalking.Orbwalker orbwalker)
        {
            player = ObjectManager.Player;

            this.zedMenu = zedMenu;
            r = zedSpells.R;
            zedOrbwalker = orbwalker;

            mouseImage1 = new Render.Sprite(Resources.mouse1, new Vector2(0, 0));
            mouseImage1.Scale = new Vector2(0.50f, 0.50f);
            mouseImage1.Add();

            mouseImage2 = new Render.Sprite(Resources.mouse2, new Vector2(0, 0));
            mouseImage2.Scale = new Vector2(0.50f, 0.50f);
            mouseImage2.Add();

            denyMouseImage = new Render.Sprite(Resources.denymouse, new Vector2(0, 0));
            denyMouseImage.Scale = new Vector2(0.50f, 0.50f);
            denyMouseImage.Add();
            denyMouseImage.Visible = false;

            Text.Add();
            Text.Visible = false;

            Game.OnWndProc += CheckMouseButtons;
            Game.OnUpdate += ShowAnimation;
        }

        /// <summary>
        ///     Called on orbwalker action.
        /// </summary>
        /// <param name="args">The <see cref="Orbwalking.BeforeAttackEventArgs" /> instance containing the event data.</param>
        public static void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
        {
            switch (Variables.Orbwalker.ActiveMode)
            {
                /// <summary>
                ///     The 'No AA in Combo' Logic.
                /// </summary>
                case Orbwalking.OrbwalkingMode.Combo:
                    if (!Variables.GeneralMenu.Item("aacombo").IsActive())
                    {
                        args.Process = Bools.HasSheenBuff();
                    }
                    break;

                /// <summary>
                ///     The 'Support Mode' Logic.
                /// </summary>
                case Orbwalking.OrbwalkingMode.Mixed:
                case Orbwalking.OrbwalkingMode.LastHit:
                case Orbwalking.OrbwalkingMode.LaneClear:
                    var target = Variables.Orbwalker.GetTarget();
                    if (target is Obj_AI_Minion && target.IsEnemy && Variables.GeneralMenu.Item("support").IsActive())
                    {
                        args.Process = !HeroManager.Allies.Any(a => a.Distance(ObjectManager.Player) < 2500);
                    }
                    break;
            }
        }

        /// <summary>
        ///     The is the spell active method.
        /// </summary>
        /// <param name="spellSlot">
        ///     The spell slot.
        /// </param>
        /// <param name="orbwalkingMode">
        ///     The orbwalking mode.
        /// </param>
        /// <returns>
        ///     <see cref="bool" />
        /// </returns>
        private static bool IsSpellActive(SpellSlot spellSlot, Orbwalking.OrbwalkingMode orbwalkingMode)
        {
            if (Program.Orbwalker.ActiveMode != orbwalkingMode || !spellSlot.IsReady())
            {
                return false;
            }

            try
            {
                var orbwalkerModeLower = Program.Orbwalker.ActiveMode.ToString().ToLower();
                var spellSlotNameLower = spellSlot.ToString().ToLower();

                return MyMenu.RootMenu.Item(orbwalkerModeLower + spellSlotNameLower + "use").GetValue<bool>()
                       && MyMenu.RootMenu.Item(orbwalkerModeLower + spellSlotNameLower + "mana")
                              .GetValue<Slider>()
                              .Value <= ObjectManager.Player.ManaPercent;
            }
            catch (Exception e)
            {
                Logging.AddEntry(
                    LoggingEntryTrype.Error,
                    "@SpellManager.cs: Can not get spell active state for slot {0} - {1}",
                    spellSlot.ToString(),
                    e);
                throw;
            }
        }

 protected override void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (ObjectManager.Player.Buffs.Any(b=>b.Name.ToLower().Contains("tumblefade")) && ObjectManager.Get<Obj_AI_Hero>().Any(h => h.IsEnemy && h.IsValidTarget() && h.IsMelee && h.Distance(ObjectManager.Player) < 325))
     {
         args.Process = false;
     }
 }

 public static void CastFlayPush(Obj_AI_Hero target, Orbwalking.OrbwalkingMode Mode)
 {
     var targetPrediction = Prediction.GetPrediction(target, 0.25f);
             var finalPosition = target.ServerPosition.Extend(
                 ObjectManager.Player.ServerPosition,
                 ObjectManager.Player.ServerPosition.Distance(targetPrediction.UnitPosition) / 2f);
             Thresh.spells[SpellSlot.E].Cast(finalPosition);
 }

 public static Menu AddModeMenu(this Menu mainMenu, Orbwalking.OrbwalkingMode Mode)
 {
     var modeMenu = new Menu($"[iSR] {Mode}", $"iseriesr.{ObjectManager.Player.ChampionName.ToLower()}.{Mode.ToString().ToLower()}");
     {
         mainMenu.AddSubMenu(modeMenu);
     }
     return modeMenu;
 }

 private static Menu AddManaManagerMenu(this Menu mainMenu, Orbwalking.OrbwalkingMode Mode)
 {
     var manaManager = new Menu("Mana Manager", $"iseriesr.{ObjectManager.Player.ChampionName.ToLower()}.{Mode.ToString().ToLower()}.mm");
     {
         mainMenu.AddSubMenu(manaManager);
     }
     return manaManager;
 }