Example #1
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            try
            {
                if (!args.ParticleEffect.IsValid)
                {
                    return;
                }

                if (!this.abilityData.Particles.TryGetValue(args.ParticleEffect.Name, out var data))
                {
                    return;
                }

                if (!data.ParticleReleaseData)
                {
                    return;
                }

                data.AddDrawableAbility(
                    this.drawableAbilities,
                    args.ParticleEffect,
                    this.allyTeam,
                    this.notificationsEnabled ? this.notificator : null);
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #2
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            try
            {
                if (args.ParticleEffect.Name != "particles/units/heroes/hero_nyx_assassin/nyx_assassin_vendetta_start.vpcf")
                {
                    return;
                }

                var particle = args.ParticleEffect;
                var position = particle.GetControlPoint(0);
                var vendetta = EntityManager9.Abilities.FirstOrDefault(
                    x => x.Id == AbilityId.nyx_assassin_vendetta && x.Owner.Distance(position) < 500);

                if (vendetta == null || vendetta.Owner.Team == this.Owner.Team)
                {
                    return;
                }

                this.ForceUse(vendetta.Owner, position);
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #3
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            try
            {
                var particleEffect = args.ParticleEffect;
                if (!particleEffect.IsValid)
                {
                    return;
                }

                var name = particleEffect.Name;

                if (this.ignoredParticles.Contains(name))
                {
                    return;
                }

                var particle = new Particle(particleEffect, name, sender, true);

                this.ParticleAdded?.Invoke(particle);
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #4
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            var particleEffect = args.ParticleEffect;

            if (particleEffect.Owner == null || !particleEffect.IsValid || particleEffect.Owner.IsVisible)
            {
                return;
            }

            if (!particleEffect.Name.Contains("generic_hit_blood") || !sender.Name.Contains("npc_dota_neutral_") && !sender.Name.Contains("npc_dota_roshan"))
            {
                return;
            }

            Pos.RemoveAll(x => x.GetPos.Distance(particleEffect.GetControlPoint(0)) < 500);
            Pos.Add(new Position(particleEffect.GetControlPoint(0)));

            var rawGameTime = Game.RawGameTime;

            UpdateManager.BeginInvoke(
                () =>
            {
                Pos.RemoveAll(x => x.GetGameTime == rawGameTime);
            },
                Config.TimerItem.Value * 1000);
        }
Example #5
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            try
            {
                if (sender == null || sender.Handle != this.Handle || args.ParticleEffect.Name != "particles/items_fx/immunity_sphere.vpcf")
                {
                    return;
                }

                if (this.linkensSphereTalent?.IsValid != true || this.linkensSphereTalent.Level <= 0)
                {
                    return;
                }

                this.talentSleeper.Sleep(this.linkensSphereTalent.SpellBlockCooldown);
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #6
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            try
            {
                if (!args.ParticleEffect.IsValid)
                {
                    return;
                }

                var particleName = args.ParticleEffect.Name;

                if (!this.releasedParticles.TryGetValue(particleName, out var abilityId))
                {
                    return;
                }

                if (!(this.evadableAbilities.Find(x => x.Ability.Id == abilityId) is IParticle ability))
                {
                    return;
                }

                var allyAbility = EntityManager9.Heroes.Any(
                    x => x.IsAlly(this.owner.Team) && (x.Id == HeroId.npc_dota_hero_rubick || x.Id == HeroId.npc_dota_hero_morphling) &&
                    x.IsAlive && x.Abilities.Any(z => z.Id == abilityId && z.TimeSinceCasted < 0.5f));

                if (allyAbility)
                {
                    return;
                }

                ability.AddParticle(args.ParticleEffect, particleName);
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #7
0
        private void OnParticleEffectReleased(Entity sender, ParticleEffectReleasedEventArgs args)
        {
            var particleEffect = args.ParticleEffect;

            if (!particleEffect.IsValid)
            {
                return;
            }

            var name = particleEffect.Name;

            if (name.Contains("blink_dagger_end"))
            {
                CheckEnemyBlink = sender as Hero;
            }

            // GetControlPoint 0
            if (Config.ParticleToTexture.ControlPoint_0.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_0.FirstOrDefault(
                    x => name.Contains(x.Key)).Value;

                Config.ParticleSpells.Spells(
                    sender as Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(0));

                return;
            }

            // GetControlPoint 0 Fix
            if (Config.ParticleToTexture.ControlPoint_0Fix.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_0Fix.FirstOrDefault(x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Spellbook.Spells.Any(v =>
                                           v.Name.Contains(AbilityTexturName)));

                Config.ParticleSpells.Spells(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(0));

                return;
            }

            // GetControlPoint 1
            if (Config.ParticleToTexture.ControlPoint_1.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_1.FirstOrDefault(x => name.Contains(x.Key)).Value;

                Config.ParticleSpells.Spells(
                    sender as Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(1));

                return;
            }

            // GetControlPoint 1 Fix
            if (Config.ParticleToTexture.ControlPoint_1Fix.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_1Fix.FirstOrDefault(x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Spellbook.Spells.Any(v =>
                                           v.Name.Contains(AbilityTexturName)));

                Config.ParticleSpells.Spells(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(1));

                return;
            }

            // GetControlPoint 2
            if (Config.ParticleToTexture.ControlPoint_2.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_2.FirstOrDefault(x => name.Contains(x.Key)).Value;

                Config.ParticleSpells.Spells(
                    sender as Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(2));

                return;
            }

            // GetControlPoint 2 Fix
            if (Config.ParticleToTexture.ControlPoint_2Fix.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_2Fix.FirstOrDefault(x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Spellbook.Spells.Any(v =>
                                           v.Name.Contains(AbilityTexturName)));

                Config.ParticleSpells.Spells(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(2));

                return;
            }

            // GetControlPoint 5
            if (Config.ParticleToTexture.ControlPoint_5.Any(
                    x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_5.FirstOrDefault(x => name.Contains(x.Key)).Value;

                Config.ParticleSpells.Spells(
                    sender as Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(5));

                return;
            }

            // GetControlPoint 5 Fix
            if (Config.ParticleToTexture.ControlPoint_5Fix.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_5Fix.FirstOrDefault(x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Spellbook.Spells.Any(v =>
                                           v.Name.Contains(AbilityTexturName)));

                Config.ParticleSpells.Spells(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(5));

                return;
            }

            // GetControlPoint 1 Plus
            if (Config.ParticleToTexture.ControlPoint_1Plus.Any(
                    x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ControlPoint_1Plus.FirstOrDefault(x => name.Contains(x.Key)).Value;
                if (particleEffect.GetControlPoint(0).ToVector2()
                    == particleEffect.GetControlPoint(1).ToVector2())
                {
                    return;
                }

                Config.ParticleSpells.Spells(
                    sender as Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(1));

                return;
            }

            // Items
            if (Config.ParticleToTexture.Items.Any(
                    x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.ParticleToTexture.Items.FirstOrDefault(x => name.Contains(x.Key)).Value;

                if (AbilityTexturName.Contains("item_blink"))
                {
                    var position = particleEffect.GetControlPoint(0);
                    UpdateManager.BeginInvoke(() =>
                    {
                        Config.ParticleItems.Items(
                            CheckEnemyBlink,
                            name,
                            AbilityTexturName,
                            position);
                    });
                }

                else if (AbilityTexturName.Contains("item_refresher"))
                {
                    Config.ParticleItems.Items(
                        sender as Hero,
                        name,
                        AbilityTexturName,
                        particleEffect.GetControlPoint(0));
                }

                else if (AbilityTexturName.Contains("item_bfury"))
                {
                    if (particleEffect.GetControlPoint(0).ToVector2()
                        == particleEffect.GetControlPoint(1).ToVector2())
                    {
                        return;
                    }

                    Config.ParticleItems.Items(
                        sender as Hero,
                        name,
                        AbilityTexturName,
                        particleEffect.GetControlPoint(1));
                }
                else

                if (AbilityTexturName.Contains("item_pipe") ||
                    AbilityTexturName.Contains("item_hood_of_defiance") ||
                    AbilityTexturName.Contains("item_crimson_guard"))
                {
                    Config.ParticleItems.Items(
                        sender as Hero,
                        name,
                        AbilityTexturName,
                        particleEffect.GetControlPoint(1));
                }

                return;
            }

            // Items Semi Null CP0
            if (Config.ParticleToTexture.ItemsSemiNullCP0.Any(
                    x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ItemsSemiNullCP0.FirstOrDefault(
                    x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Inventory.Items.Any(v =>
                                          v.Name.Contains(AbilityTexturName) &&
                                          v?.Cooldown / v?.CooldownLength * 100 >= 99));

                Config.ParticleItems.ItemsNull(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(0));

                return;
            }

            // Items Semi Null CP1
            if (Config.ParticleToTexture.ItemsSemiNullCP1.Any(
                    x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ItemsSemiNullCP1.FirstOrDefault(
                    x => name.Contains(x.Key)).Value;

                var Hero = EntityManager <Hero> .Entities.FirstOrDefault(
                    x =>
                    x.IsValid &&
                    !x.IsIllusion &&
                    x.Inventory.Items.Any(v =>
                                          v.Name.Contains(AbilityTexturName) &&
                                          v?.Cooldown / v?.CooldownLength * 100 >= 99));

                Config.ParticleItems.ItemsNull(
                    Hero,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(1));

                return;
            }

            // Item Smoke
            if (Config.ParticleToTexture.ItemsNullCP0.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ItemsNullCP0.FirstOrDefault(
                    x => name.Contains(x.Key)).Value;

                var IgnorAllySmoke = EntityManager <Hero> .Entities.Any(
                    x =>
                    x.Team == Context.Owner.Team &&
                    x.HasModifier("modifier_smoke_of_deceit"));

                if (!IgnorAllySmoke)
                {
                    Config.ParticleItems.ItemsNull(
                        null,
                        name,
                        AbilityTexturName,
                        particleEffect.GetControlPoint(0));
                }

                return;
            }

            if (Config.ParticleToTexture.ItemsNullCP1.Any(x => name.Contains(x.Key)))
            {
                var AbilityTexturName = Config.
                                        ParticleToTexture.ItemsNullCP1.FirstOrDefault(
                    x => name.Contains(x.Key)).Value;

                Config.ParticleItems.ItemsNull(
                    null,
                    name,
                    AbilityTexturName,
                    particleEffect.GetControlPoint(1));

                return;
            }
        }