Exemplo n.º 1
0
        public static void CastWithSebbyPred(Spell spell, Obj_AI_Base unit, HitChance hit)
        {
            SebbyLib.Prediction.SkillshotType CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotLine;
            bool aoe2 = false;

            if (spell.Type == SkillshotType.SkillshotCircle)
            {
                CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotCircle;
                aoe2      = true;
            }

            if (spell.Width > 80 && !spell.Collision)
            {
                aoe2 = true;
            }

            var predInput2 = new SebbyLib.Prediction.PredictionInput
            {
                Aoe       = aoe2,
                Collision = spell.Collision,
                Speed     = spell.Speed,
                Delay     = spell.Delay,
                Range     = spell.Range,
                From      = ObjectManager.Player.ServerPosition,
                Radius    = spell.Width,
                Unit      = unit,
                Type      = CoreType2
            };
            var poutput2 = SebbyLib.Prediction.Prediction.GetPrediction(predInput2);

            //var poutput2 = QWER.GetPrediction(target);

            if (spell.Speed != float.MaxValue && OktwCommon.CollisionYasuo(ObjectManager.Player.ServerPosition,
                                                                           poutput2.CastPosition))
            {
                return;
            }

            switch (hit)
            {
            case HitChance.Low:
                if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.Low)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.Medium:
                if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.Medium)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.High:
                if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.High)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.VeryHigh:
                if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.VeryHigh)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.Immobile:
                if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.Immobile)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;
            }
        }
Exemplo n.º 2
0
        /// <summary>
        ///     General Usage of Spells
        /// </summary>
        /// <param name="QWER"></param>
        /// <param name="target"></param>

        #region SebbySpell
        public static void SebbySpellMain(Spell QWER, Obj_AI_Base target)
        {
            if (RootConfig.SelectedPrediction.GetValue <StringList>().SelectedIndex == 1)
            {
                var CoreType2 = SkillshotType.SkillshotLine;
                var aoe2      = false;

                if (QWER.Type == LeagueSharp.Common.SkillshotType.SkillshotCircle)
                {
                    CoreType2 = SkillshotType.SkillshotCircle;
                    aoe2      = true;
                }

                if ((QWER.Width > 80) && !QWER.Collision)
                {
                    aoe2 = true;
                }

                var predInput2 = new PredictionInput
                {
                    Aoe       = aoe2,
                    Collision = QWER.Collision,
                    Speed     = QWER.Speed,
                    Delay     = QWER.Delay,
                    Range     = QWER.Range,
                    From      = Player.ServerPosition,
                    Radius    = QWER.Width,
                    Unit      = target,
                    Type      = CoreType2
                };
                var poutput2 = Prediction.GetPrediction(predInput2);

                if (OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                {
                    return;
                }

                if ((QWER.Speed != float.MaxValue) &&
                    OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                {
                    return;
                }
                // LastPoint - Save | Make sure to replace the HitChances with VeryHigh/Medium - Invert them
                if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 0)
                {
                    if (poutput2.Hitchance >= HitChance.Medium)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                    else if (predInput2.Aoe && (poutput2.AoeTargetsHitCount > 1) && (poutput2.Hitchance >= HitChance.Medium))
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
                else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 1)
                {
                    if (poutput2.Hitchance >= HitChance.High)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
                else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 2)
                {
                    if (poutput2.Hitchance >= HitChance.VeryHigh)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
            }
            else if (RootConfig.SelectedPrediction.GetValue <StringList>().SelectedIndex == 0)
            {
                if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 0)
                {
                    QWER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.Medium);
                }
                else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 1)
                {
                    QWER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.High);
                }
                else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 2)
                {
                    QWER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.VeryHigh);
                }
            }
            else if (RootConfig.SelectedPrediction.GetValue <StringList>().SelectedIndex == 2)
            {
                if (target is AIHeroClient && target.IsValid)
                {
                    var t = target as AIHeroClient;
                    if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 0)
                    {
                        QWER.SPredictionCast(t, LeagueSharp.Common.HitChance.Medium);
                    }
                    else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 1)
                    {
                        QWER.SPredictionCast(t, LeagueSharp.Common.HitChance.High);
                    }
                    else if (RootConfig.SelectedHitChance.GetValue <StringList>().SelectedIndex == 2)
                    {
                        QWER.SPredictionCast(t, LeagueSharp.Common.HitChance.VeryHigh);
                    }
                }
                else
                {
                    QWER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.High);
                }
            }
        }
Exemplo n.º 3
0
        public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
        {
            if (sender.Owner.IsMe)
            {
                if (getCheckBoxItem(menu, "ENABLED") && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass)))
                {
                    if (!ShineCommon.Utility.IsValidSlot(args.Slot))
                    {
                        return;
                    }

                    if (SDKPredictioner.Spells[(int)args.Slot] == null)
                    {
                        return;
                    }

                    if (!getCheckBoxItem(menu, String.Format("{0}{1}", ObjectManager.Player.ChampionName, args.Slot)))
                    {
                        return;
                    }

                    if (handleEvent[(int)args.Slot])
                    {
                        args.Process = false;
                        handleEvent[(int)args.Slot] = false;
                        var enemy = TargetSelector.GetTarget(SDKPredictioner.Spells[(int)args.Slot].Range, DamageType.Physical);

                        if (enemy != null)
                        {
                            SebbyLib.Movement.SkillshotType CoreType2 = SebbyLib.Movement.SkillshotType.SkillshotLine;
                            bool aoe2 = false;

                            if (SDKPredictioner.Spells[(int)args.Slot].Type == SkillshotType.SkillshotCircle)
                            {
                                //CoreType2 = SebbyLib.Movement.SkillshotType.SkillshotCircle;
                                //aoe2 = true;
                            }

                            if (SDKPredictioner.Spells[(int)args.Slot].Width > 80 && !SDKPredictioner.Spells[(int)args.Slot].Collision)
                            {
                                aoe2 = true;
                            }

                            var predInput2 = new SebbyLib.Movement.PredictionInput
                            {
                                Aoe       = aoe2,
                                Collision = SDKPredictioner.Spells[(int)args.Slot].Collision,
                                Speed     = SDKPredictioner.Spells[(int)args.Slot].Speed,
                                Delay     = SDKPredictioner.Spells[(int)args.Slot].Delay,
                                Range     = SDKPredictioner.Spells[(int)args.Slot].Range,
                                From      = Player.ServerPosition,
                                Radius    = SDKPredictioner.Spells[(int)args.Slot].Width,
                                Unit      = enemy,
                                Type      = CoreType2
                            };
                            var poutput2 = SebbyLib.Movement.Prediction.GetPrediction(predInput2);

                            if (SDKPredictioner.Spells[(int)args.Slot].Speed != float.MaxValue && OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                            {
                                return;
                            }

                            if (getBoxItem(menu, "SPREDHITC") == 0) // Very High
                            {
                                if (poutput2.Hitchance >= SebbyLib.Movement.HitChance.VeryHigh)
                                {
                                    SDKPredictioner.Spells[(int)args.Slot].Cast(poutput2.CastPosition);
                                }
                                else if (predInput2.Aoe && poutput2.AoeTargetsHitCount > 1 && poutput2.Hitchance >= SebbyLib.Movement.HitChance.High)
                                {
                                    SDKPredictioner.Spells[(int)args.Slot].Cast(poutput2.CastPosition);
                                }
                            }
                            else if (getBoxItem(menu, "SPREDHITC") == 1)
                            {
                                if (poutput2.Hitchance >= SebbyLib.Movement.HitChance.High)
                                {
                                    SDKPredictioner.Spells[(int)args.Slot].Cast(poutput2.CastPosition);
                                }
                            }
                            else if (getBoxItem(menu, "SPREDHITC") == 2)
                            {
                                if (poutput2.Hitchance >= SebbyLib.Movement.HitChance.Medium)
                                {
                                    SDKPredictioner.Spells[(int)args.Slot].Cast(poutput2.CastPosition);
                                }
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 4
0
        private static void SebbySpell(Spell WR, Obj_AI_Base target)
        {
            var CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotLine;
            var aoe2      = false;

            if (WR.Type == SkillshotType.SkillshotCircle)
            {
                CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotCircle;
                aoe2      = true;
            }

            if ((WR.Width > 80) && !WR.Collision)
            {
                aoe2 = true;
            }

            var predInput2 = new PredictionInput
            {
                Aoe       = aoe2,
                Collision = WR.Collision,
                Speed     = WR.Speed,
                Delay     = WR.Delay,
                Range     = WR.Range,
                From      = Player.ServerPosition,
                Radius    = WR.Width,
                Unit      = target,
                Type      = CoreType2
            };
            var poutput2 = Prediction.GetPrediction(predInput2);

            if (OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
            {
                return;
            }

            if ((WR.Speed != float.MaxValue) && OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
            {
                return;
            }

            if (Menu.Item("HitChance").GetValue <StringList>().SelectedIndex == 0)
            {
                if (poutput2.Hitchance >= HitChance.Medium)
                {
                    WR.Cast(poutput2.CastPosition);
                }
            }
            else if (Menu.Item("HitChance").GetValue <StringList>().SelectedIndex == 1)
            {
                if (poutput2.Hitchance >= HitChance.High)
                {
                    WR.Cast(poutput2.CastPosition);
                }
            }
            else if (Menu.Item("HitChance").GetValue <StringList>().SelectedIndex == 2)
            {
                if (poutput2.Hitchance >= HitChance.VeryHigh)
                {
                    WR.Cast(poutput2.CastPosition);
                }
            }
        }
Exemplo n.º 5
0
        private void SebbySpell(Spell ER, Obj_AI_Base target)
        {
            if (Config.Item("Prediction").GetValue <StringList>().SelectedIndex == 1)
            {
                var CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotLine;
                var aoe2      = false;

                if (ER.Type == SkillshotType.SkillshotCircle)
                {
                    CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotLine;
                    aoe2      = true;
                }

                if ((ER.Width > 80) && !ER.Collision)
                {
                    aoe2 = true;
                }

                var predInput2 = new PredictionInput
                {
                    Aoe       = aoe2,
                    Collision = ER.Collision,
                    Speed     = ER.Speed,
                    Delay     = ER.Delay,
                    Range     = ER.Range,
                    From      = Player.ServerPosition,
                    Radius    = ER.Width,
                    Unit      = target,
                    Type      = CoreType2
                };
                var poutput2 = SebbyLib.Prediction.Prediction.GetPrediction(predInput2);

                if (OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                {
                    return;
                }

                if ((ER.Speed != float.MaxValue) &&
                    OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                {
                    return;
                }

                if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 0)
                {
                    if (poutput2.Hitchance >= HitChance.Medium)
                    {
                        ER.Cast(poutput2.CastPosition);
                    }
                    else if (predInput2.Aoe && (poutput2.AoeTargetsHitCount > 1) && (poutput2.Hitchance >= HitChance.Medium))
                    {
                        ER.Cast(poutput2.CastPosition);
                    }
                }
                else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 1)
                {
                    if (poutput2.Hitchance >= HitChance.High)
                    {
                        ER.Cast(poutput2.CastPosition);
                    }
                }
                else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 2)
                {
                    if (poutput2.Hitchance >= HitChance.VeryHigh)
                    {
                        ER.Cast(poutput2.CastPosition);
                    }
                }
            }
            else if (Config.Item("Prediction").GetValue <StringList>().SelectedIndex == 0)
            {
                if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 0)
                {
                    ER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.Medium);
                }
                else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 1)
                {
                    ER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.High);
                }
                else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 2)
                {
                    ER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.VeryHigh);
                }
            }
            else if (Config.Item("Prediction").GetValue <StringList>().SelectedIndex == 2)
            {
                var hero = target as Obj_AI_Hero;
                if ((hero != null) && hero.IsValid)
                {
                    var t = hero;
                    if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 0)
                    {
                        ER.SPredictionCast(t, LeagueSharp.Common.HitChance.Medium);
                    }
                    else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 1)
                    {
                        ER.SPredictionCast(t, LeagueSharp.Common.HitChance.High);
                    }
                    else if (Config.Item("HitChance").GetValue <StringList>().SelectedIndex == 2)
                    {
                        ER.SPredictionCast(t, LeagueSharp.Common.HitChance.VeryHigh);
                    }
                }
                else
                {
                    ER.CastIfHitchanceEquals(target, LeagueSharp.Common.HitChance.High);
                }
            }
        }
Exemplo n.º 6
0
        public void Combo()
        {
            var useq   = Config.comboQ.GetValue <bool>();
            var usew   = Config.comboW.GetValue <bool>();
            var usee   = Config.comboE.GetValue <bool>();
            var useR   = Config.comboR.GetValue <bool>();
            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

            //var targetextend = TargetSelector.GetTarget();
            if ((target == null) || !target.IsValidTarget())
            {
                return;
            }

            //Chat.Print("Q Damage: " + Q.GetDamage(target) + " Sheen Damage:" + GetSheenDamage(target));
            //var distancebetweenmeandtarget = ObjectManager.Player.ServerPosition.Distance(target.ServerPosition);

            /*if (Q.IsReady() && target.Distance(Player.Position) > 650)
             * {
             *  var gapclosingMinion = ObjectManager.Get<Obj_AI_Minion>().Where(m => m.ServerPosition.Distance(ObjectManager.Player.ServerPosition) < 650 &&
             *      m.IsEnemy && m.ServerPosition.Distance(target.ServerPosition) < distancebetweenmeandtarget && m.Health > 1 && m.Health < Q.GetDamage(m) + GetSheenDamage(m)).OrderBy(m => m.Position.Distance(target.ServerPosition)).FirstOrDefault();
             *  if (gapclosingMinion != null)
             *  {
             *      Q.Cast(gapclosingMinion);
             *  }
             * }*/

            if (target.IsValidTarget(Q.Range) && !target.IsValidTarget(Player.AttackRange) && Q.IsReady() && useq)
            {
                Q.CastOnUnit(target);
                if (E.Instance.IsReady() && target.IsValidTarget(E.Range) && usee)
                {
                    E.CastOnUnit(target);
                }
                if (W.Instance.IsReady() && usew && target.IsValidTarget(Player.AttackRange))
                {
                    // Yes lads E.Range is intentionally here :gosh:
                    W.Cast();
                }
                if (target.IsValidTarget(R.Range) && useR)
                {
                    var pred = R.GetPrediction(target);
                    if ((pred.Hitchance >= HitChance.High) && HasRBuff())
                    {
                        if (OktwCommon.CollisionYasuo(Player.Position, pred.CastPosition))
                        {
                            return;
                        }
                        R.Cast(pred.CastPosition);
                    }
                }
            }
            else if (target.IsValidTarget(E.Range))
            {
                if (Q.Instance.IsReady() && useq)
                {
                    Q.CastOnUnit(target);
                }
                if (E.Instance.IsReady() && usee && target.IsValidTarget(E.Range))
                {
                    E.CastOnUnit(target);
                }
                if (W.Instance.IsReady() && usew && target.IsValidTarget(Player.AttackRange))
                {
                    // Yes lads E.Range is intentionally here :gosh:
                    W.Cast();
                }
                if (R.Instance.IsReady() && useR && target.IsValidTarget(R.Range))
                {
                    var pred = R.GetPrediction(target);
                    if (pred.Hitchance >= HitChance.High)
                    {
                        if (OktwCommon.CollisionYasuo(Player.Position, pred.CastPosition))
                        {
                            return;
                        }
                        R.Cast(pred.CastPosition);
                    }
                }
            }
        }
Exemplo n.º 7
0
        public static void CastSdk(this Spell spell, Obj_AI_Base unit, HitChance hit, bool aoe)
        {
            SDKPrediction.SkillshotType CoreType2 = SDKPrediction.SkillshotType.SkillshotLine;

            if (spell.Type == SkillshotType.SkillshotCircle)
            {
                CoreType2 = SDKPrediction.SkillshotType.SkillshotCircle;
                aoe       = true;
            }

            if (spell.Width > 80 && !spell.Collision)
            {
                aoe = true;
            }

            var predInput2 = new SDKPrediction.PredictionInput
            {
                AoE       = aoe,
                Collision = spell.Collision,
                Speed     = spell.Speed,
                Delay     = spell.Delay,
                Range     = spell.Range,
                From      = ObjectManager.Player.ServerPosition,
                Radius    = spell.Width,
                Unit      = unit,
                Type      = CoreType2
            };

            var poutput2 = SDKPrediction.GetPrediction(predInput2);

            if (spell.Speed != Single.MaxValue &&
                OktwCommon.CollisionYasuo(ObjectManager.Player.ServerPosition, poutput2.CastPosition))
            {
                return;
            }

            switch (hit)
            {
            case HitChance.Low:
                if (poutput2.Hitchance >= SDKPrediction.HitChance.Low)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.Medium:
                if (poutput2.Hitchance >= SDKPrediction.HitChance.Medium)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.High:
                if (poutput2.Hitchance >= SDKPrediction.HitChance.High)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.VeryHigh:
                if (poutput2.Hitchance >= SDKPrediction.HitChance.VeryHigh)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;

            case HitChance.Immobile:
                if (poutput2.Hitchance >= SDKPrediction.HitChance.Immobile)
                {
                    spell.Cast(poutput2.CastPosition);
                }
                break;
            }

            if (predInput2.AoE && poutput2.AoeTargetsHitCount > 1 &&
                poutput2.Hitchance >= SDKPrediction.HitChance.High)
            {
                spell.Cast(poutput2.CastPosition, true);
            }
        }
Exemplo n.º 8
0
        public static void CastSpell(Spell QWER, Obj_AI_Base target)
        {
            if (MenuPrediction["PredictionMODE"].GetValue <MenuList>().Index == 0)
            {
                SebbyLib.Prediction.SkillshotType CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotLine;
                bool aoe2 = false;

                if (QWER.Type == SkillshotType.SkillshotCircle)
                {
                    CoreType2 = SebbyLib.Prediction.SkillshotType.SkillshotCircle;
                    aoe2      = true;
                }

                if (QWER.Width > 80 && !QWER.Collision)
                {
                    aoe2 = true;
                }

                var predInput2 = new SebbyLib.Prediction.PredictionInput
                {
                    Aoe       = aoe2,
                    Collision = QWER.Collision,
                    Speed     = QWER.Speed,
                    Delay     = QWER.Delay,
                    Range     = QWER.Range,
                    From      = Player.ServerPosition,
                    Radius    = QWER.Width,
                    Unit      = target,
                    Type      = CoreType2
                };
                var poutput2 = SebbyLib.Prediction.Prediction.GetPrediction(predInput2);

                //var poutput2 = QWER.GetPrediction(target);

                if (QWER.Speed != float.MaxValue && OktwCommon.CollisionYasuo(Player.ServerPosition, poutput2.CastPosition))
                {
                    return;
                }

                if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 0)
                {
                    if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.VeryHigh)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                    else if (predInput2.Aoe && poutput2.AoeTargetsHitCount > 1 && poutput2.Hitchance >= SebbyLib.Prediction.HitChance.High)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
                else if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 1)
                {
                    if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.High)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
                else if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 2)
                {
                    if (poutput2.Hitchance >= SebbyLib.Prediction.HitChance.Medium)
                    {
                        QWER.Cast(poutput2.CastPosition);
                    }
                }
            }
            else if (MenuPrediction["PredictionMODE"].GetValue <MenuList>().Index == 1)
            {
                if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 0)
                {
                    QWER.CastIfHitchanceEquals(target, HitChance.VeryHigh);
                }
                return;
            }
            else if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 1)
            {
                QWER.CastIfHitchanceEquals(target, HitChance.High);
                return;
            }
            else if (MenuPrediction["HitChance"].GetValue <MenuList>().Index == 2)
            {
                QWER.CastIfHitchanceEquals(target, HitChance.Medium);
                return;
            }
        }