示例#1
0
        private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            var caster = sender as AIHeroClient;
            var target = args.Target as Obj_AI_Base;

            if (caster == null || target == null || !caster.IsValid || !target.IsValid)
            {
                return;
            }

            var data = TargetedSpellDatabase.List.FirstOrDefault(s => s.hero.Equals(caster.Hero) && s.slot.Equals(args.Slot));

            if (data == null)
            {
                //Console.WriteLine($"OnProcessTargetedSpell: {caster.ChampionName} - [{args.Slot}] - Not Detected");
                return;
            }

            var detected = new DetectedTargetedSpellData
            {
                Caster = caster,
                Target = target,
                Data   = data
            };

            Add(detected);
        }
        private static void Add(DetectedTargetedSpellData args)
        {
            if (args == null || DetectedTargetedSpells.Contains(args))
            {
                Console.WriteLine("Invalid DetectedTargetedSpellData");
                return;
            }

            if (args.Missile != null)
            {
                var detect = DetectedTargetedSpells.FirstOrDefault(s => s.Caster.IdEquals(args.Caster) && s.Missile == null && s.Data.Equals(args.Data));
                if (detect != null)
                {
                    DetectedTargetedSpells.Remove(detect);
                }
            }

            if (args.Caster.Hero == Champion.Nautilus && args.Data.slot == SpellSlot.R && args.Target != null)
            {
                args.Start = args.Caster.ServerPosition.Extend(args.Target, args.Caster.GetAutoAttackRange(args.Target)).To3DWorld();
                if (args.Caster.Distance(args.Target) < args.Caster.GetAutoAttackRange(args.Target))
                {
                    args.Speed = int.MaxValue;
                }
            }

            OnTargetedSpellDetected.Invoke(args);
            DetectedTargetedSpells.Add(args);
        }
示例#3
0
        private static void Add(DetectedTargetedSpellData data)
        {
            if (data == null || DetectedTargetedSpells.Contains(data))
            {
                Console.WriteLine("Invalid DetectedTargetedSpellData");
                return;
            }

            OnTargetedSpellDetected.Invoke(data);
            DetectedTargetedSpells.Add(data);
        }
        internal static void Invoke(DetectedTargetedSpellData args)
        {
            var invocationList = OnDetect?.GetInvocationList();

            if (invocationList != null)
            {
                foreach (var m in invocationList)
                {
                    m?.DynamicInvoke(args);
                }
            }
        }
示例#5
0
        private static void OnTargetedSpellUpdate_OnUpdate(DetectedTargetedSpellData args)
        {
            if (args.Caster == null || !Spells.E.IsReady() || !args.Caster.IsEnemy || !args.Target.IsMe || !args.WillHit(Player.Instance))
            {
                return;
            }

            var spellname = args.Data.MenuItemName;
            var spell     = EnabledSpells.FirstOrDefault(s => s.SpellName.Equals(spellname));

            if (spell == null)
            {
                Logger.Warn($"{spellname} Not valid Spell");
                return;
            }

            if (!spell.Enabled && (!Meniu.BlockExecute || Player.Instance.PredictHealth(args.TicksLeft) > args.GetSpellDamage(Player.Instance)))
            {
                Logger.Warn($"{spellname} Not Enabled from Menu");
                return;
            }

            Block(args, spell);
        }
        private static void GameObject_OnCreate(GameObject sender, EventArgs args)
        {
            var particle = sender as Obj_GeneralParticleEmitter;

            if (particle != null)
            {
                var xdata = TargetedSpellDatabase.Current.FirstOrDefault(s => s.MissileNames != null && s.MissileNames.Any(m => m.Equals(particle.Name)));
                if (xdata != null)
                {
                    var xcaster = EntityManager.Heroes.AllHeroes.OrderBy(o => o.Distance(particle)).FirstOrDefault(h => h.Hero.Equals(xdata.hero) && h.IsInRange(particle, 1000));
                    if (xcaster != null)
                    {
                        var xtarget = EntityManager.Heroes.AllHeroes.OrderBy(o => o.Distance(particle)).FirstOrDefault(h => h.Team != xcaster.Team && h.IsInRange(particle, 1000) && !h.IsDead && h.IsValid);
                        if (xtarget != null)
                        {
                            if (xdata.hero == Champion.Kled)
                            {
                                xdata.Speed = xcaster.MoveSpeed;
                            }

                            Add(new DetectedTargetedSpellData
                            {
                                Caster    = xcaster,
                                Target    = xtarget,
                                Data      = xdata,
                                Start     = xcaster.ServerPosition,
                                StartTick = Core.GameTickCount
                            });
                            return;
                        }
                    }
                }
            }

            var missile = sender as MissileClient;
            var caster  = missile?.SpellCaster as AIHeroClient;

            if (caster == null)
            {
                return;
            }

            var target = missile.Target as Obj_AI_Base;

            if (target == null)
            {
                return;
            }

            var data =
                TargetedSpellDatabase.Current.FirstOrDefault(
                    s => s.MissileNames != null && s.MissileNames.Any(m => m.Equals(missile.SData.Name, StringComparison.CurrentCultureIgnoreCase)) && s.hero.Equals(caster.Hero));

            if (data == null)
            {
                return;
            }

            var detected = new DetectedTargetedSpellData
            {
                Caster    = caster,
                Target    = target,
                Data      = data,
                Start     = missile.StartPosition,
                StartTick = Core.GameTickCount,
                Missile   = missile
            };

            Add(detected);
        }