예제 #1
0
        public override bool Particle(Particle particle, string name)
        {
            if (!name.Contains("powershot_channel") && !name.Contains("windrunner_spell_powershot"))
            {
                return(false);
            }

            if (!WindrunnerPowershotMenu.EnableItem)
            {
                return(true);
            }

            var hero = EntityManager.GetEntities <Hero>().FirstOrDefault(x => !x.IsAlly(LocalHero) && !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_windrunner);

            if (hero == null)
            {
                return(true);
            }

            var startPosition = hero.Position;

            Powershot(particle, startPosition, hero);

            if (!name.Contains("windrunner_spell_powershot") && (WindrunnerPowershotMenu.WhenIsVisibleItem || !hero.IsVisible))
            {
                var pos        = Pos(startPosition, WindrunnerPowershotMenu.OnWorldItem);
                var minimapPos = MinimapPos(startPosition, WindrunnerPowershotMenu.OnMinimapItem);

                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_windrunner", AbilityId.windrunner_powershot, 0, WindrunnerPowershotMenu.SideMessageItem, WindrunnerPowershotMenu.SoundItem);
            }

            return(true);
        }
예제 #2
0
        public override bool Entity(Unit unit, Hero hero)
        {
            if (hero.HeroId != HeroId.npc_dota_hero_leshrac)
            {
                return(false);
            }

            if (!LeshracSplitEarthMenu.EnableItem)
            {
                return(true);
            }

            if (hero.IsAlly(LocalHero))
            {
                return(true);
            }

            var position = unit.Position;

            SplitEarth(unit, hero, position);

            if (LeshracSplitEarthMenu.WhenIsVisibleItem || !hero.IsVisible)
            {
                var pos        = Pos(position, LeshracSplitEarthMenu.OnWorldItem);
                var minimapPos = MinimapPos(position, LeshracSplitEarthMenu.OnMinimapItem);
                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_leshrac", AbilityId.leshrac_split_earth, 0, LeshracSplitEarthMenu.SideMessageItem, LeshracSplitEarthMenu.SoundItem);
            }

            return(true);
        }
예제 #3
0
        public override bool Entity(Unit unit, Hero hero)
        {
            if (hero.HeroId != HeroId.npc_dota_hero_kunkka)
            {
                return(false);
            }

            if (!KunkkaTorrentMenu.EnableItem)
            {
                return(true);
            }

            if (hero.IsAlly(LocalHero))
            {
                return(true);
            }

            var position = unit.Position;

            Torrent(unit, hero, position);

            if (KunkkaTorrentMenu.WhenIsVisibleItem || !hero.IsVisible)
            {
                var pos        = Pos(position, KunkkaTorrentMenu.OnWorldItem);
                var minimapPos = MinimapPos(position, KunkkaTorrentMenu.OnMinimapItem);
                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_kunkka", AbilityId.kunkka_torrent, 0, KunkkaTorrentMenu.SideMessageItem, KunkkaTorrentMenu.SoundItem);
            }

            return(true);
        }
        public override bool Entity(Unit unit, Hero hero)
        {
            if (hero.HeroId != HeroId.npc_dota_hero_lina)
            {
                return(false);
            }

            if (!LinaLightStrikeArrayMenu.EnableItem)
            {
                return(true);
            }

            if (hero.IsAlly(LocalHero))
            {
                return(true);
            }

            var position = unit.Position;

            LightStrikeArray(unit, position);

            if (LinaLightStrikeArrayMenu.WhenIsVisibleItem || !hero.IsVisible)
            {
                var pos        = Pos(position, LinaLightStrikeArrayMenu.OnWorldItem);
                var minimapPos = MinimapPos(position, LinaLightStrikeArrayMenu.OnMinimapItem);
                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_lina", AbilityId.lina_light_strike_array, 0, LinaLightStrikeArrayMenu.SideMessageItem, LinaLightStrikeArrayMenu.SoundItem);
            }

            return(true);
        }
예제 #5
0
        public override bool Particle(Particle particle, string name)
        {
            if (!name.Contains("pudge_meathook"))
            {
                return(false);
            }

            if (!PudgeHookMenu.EnableItem)
            {
                return(true);
            }

            var hero = EntityManager.GetEntities <Hero>().FirstOrDefault(x => !x.IsAlly(LocalHero) && !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_pudge);

            if (hero == null)
            {
                return(true);
            }

            UpdateManager.BeginInvoke(1, () =>
            {
                if (name.Contains("pudge_meathook_impact"))
                {
                    finish = true;
                    return;
                }

                var startPosition = particle.GetControlPoint(0);
                Hook(particle, startPosition);

                if (PudgeHookMenu.WhenIsVisibleItem || !hero.IsVisible)
                {
                    var pos        = Pos(startPosition, PudgeHookMenu.OnWorldItem);
                    var minimapPos = MinimapPos(startPosition, PudgeHookMenu.OnMinimapItem);

                    Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_pudge", AbilityId.pudge_meat_hook, 0, PudgeHookMenu.SideMessageItem, PudgeHookMenu.SoundItem);
                }
            });

            return(true);
        }
        public override bool Particle(Particle particle, string name)
        {
            if (name.Contains("ancient_apparition_ice_blast_explode"))
            {
                finish = true;
                return(true);
            }

            if (!name.Contains("ancient_apparition_ice_blast_final"))
            {
                return(false);
            }

            if (!AncientApparitionIceBlastMenu.EnableItem)
            {
                return(true);
            }

            if (EntityManager.GetEntities <Hero>().Any(x => x.IsAlly(LocalHero) && !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_ancient_apparition))
            {
                return(true);
            }

            UpdateManager.BeginInvoke(() =>
            {
                if (!particle.IsValid)
                {
                    return;
                }

                var startPosition = particle.GetControlPoint(0);
                IceBlast(particle, startPosition);

                var pos        = Pos(startPosition, AncientApparitionIceBlastMenu.OnWorldItem);
                var minimapPos = MinimapPos(startPosition, AncientApparitionIceBlastMenu.OnMinimapItem);

                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_ancient_apparition", AbilityId.ancient_apparition_ice_blast, 0, AncientApparitionIceBlastMenu.SideMessageItem, AncientApparitionIceBlastMenu.SoundItem);
            });

            return(true);
        }
예제 #7
0
        public override bool Particle(Particle particle, string name)
        {
            if (!name.Contains("mirana_spell_arrow"))
            {
                return(false);
            }

            if (!MiranaArrowMenu.EnableItem)
            {
                return(true);
            }

            var hero = EntityManager.GetEntities <Hero>().FirstOrDefault(x => !x.IsAlly(LocalHero) && !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_mirana);

            if (hero == null)
            {
                return(true);
            }

            UpdateManager.BeginInvoke(() =>
            {
                var position = particle.GetControlPoint(0);

                Arrow(particle, position, hero.Handle.ToString());

                var pos        = Pos(position, MiranaArrowMenu.OnWorldItem);
                var minimapPos = MinimapPos(position, MiranaArrowMenu.OnMinimapItem);
                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_mirana", AbilityId.mirana_arrow, 0, MiranaArrowMenu.SideMessageItem, MiranaArrowMenu.SoundItem);

                if (MiranaArrowMenu.WriteOnChatItem)
                {
                    DisplayMessage();
                }
            });



            return(true);
        }
예제 #8
0
        public override bool Particle(Particle particle, string name)
        {
            if (!name.Contains("invoker_emp"))
            {
                return(false);
            }

            if (!InvokerEMPMenu.EnableItem)
            {
                return(true);
            }

            if (!EntityManager.GetEntities <Hero>().Any(x => !x.IsAlly(LocalHero) && !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_invoker))
            {
                return(true);
            }

            var handle = particle.Handle.ToString();

            UpdateManager.BeginInvoke(1, () =>
            {
                var position = particle.GetControlPoint(0);
                DrawRange(handle, position, 675, Color, 70);

                var pos        = Pos(position, InvokerEMPMenu.OnWorldItem);
                var minimapPos = MinimapPos(position, InvokerEMPMenu.OnMinimapItem);
                Verification.InfoVerification(pos, minimapPos, "npc_dota_hero_invoker", AbilityId.invoker_emp, 0, InvokerEMPMenu.SideMessageItem, InvokerEMPMenu.SoundItem);
            });

            UpdateManager.BeginInvoke(2900, () =>
            {
                DrawRangeRemove(handle);
            });

            return(true);
        }
예제 #9
0
        private async void Charge(Unit unit, Modifier modifier, bool isHero)
        {
            try
            {
                if (unit.Team != LocalHero.Team)
                {
                    return;
                }

                var effectName = "particles/units/heroes/hero_spirit_breaker/spirit_breaker_charge_target.vpcf";
                if (isHero)
                {
                    if (LocalHero.Handle == unit.Handle)
                    {
                        ColorScreen = true;
                    }

                    effectName = "materials/ensage_ui/particles/spirit_breaker_charge_target.vpcf";

                    var position   = unit.Position;
                    var pos        = Pos(position, SpiritBreakerChargeMenu.OnWorldItem);
                    var minimapPos = MinimapPos(position, SpiritBreakerChargeMenu.OnMinimapItem);

                    Verification.InfoVerification(pos, minimapPos, unit.Name, AbilityId.spirit_breaker_charge_of_darkness, 0, SpiritBreakerChargeMenu.SideMessageItem, SpiritBreakerChargeMenu.SoundItem);

                    if (SpiritBreakerChargeMenu.WriteOnChatItem)
                    {
                        DisplayMessage(unit);
                    }
                }

                ParticleManager.CreateOrUpdateParticle($"ChargeUnit", effectName, EntityManager.GetEntityByHandle(unit.Handle), ParticleAttachment.OverheadFollow);

                var spiritBreaker = EntityManager.GetEntities <Hero>().FirstOrDefault(x => !x.IsIllusion && x.HeroId == HeroId.npc_dota_hero_spirit_breaker);
                var speed         = spiritBreaker.GetAbilityById(AbilityId.spirit_breaker_charge_of_darkness).GetAbilitySpecialDataWithTalent(spiritBreaker, "movement_speed");

                var rawGameTime    = GameManager.RawGameTime;
                var firstIsVisible = false;

                do
                {
                    var isVisible = spiritBreaker.IsVisible;
                    if (isVisible)
                    {
                        rawGameTime    = GameManager.RawGameTime;
                        firstIsVisible = true;
                    }

                    if (firstIsVisible)
                    {
                        startChargePosition = spiritBreaker.Position.Extend(unit.Position, (GameManager.RawGameTime - rawGameTime) * speed);
                        endChargePosition   = unit.Position;
                        DrawLine("Charge", startChargePosition, endChargePosition, 150, 185, Color.DarkRed);

                        if (SpiritBreakerChargeMenu.OnMinimapItem)
                        {
                            OnMinimap = true;
                        }

                        if (!isVisible)
                        {
                            DrawRange("Charge", startChargePosition, 100, Color.Red, 180);
                        }
                        else
                        {
                            DrawRangeRemove("Charge");
                        }
                    }

                    await Task.Delay(50);
                }while (modifier.IsValid);

                ColorScreen = false;
                OnMinimap   = false;

                ParticleManager.RemoveParticle("ChargeUnit");
                DrawRangeRemove("Charge");
                DrawLineRemove("Charge");
                startChargePosition = Vector3.Zero;
            }
            catch (Exception e)
            {
                LogManager.Error(e);
            }
        }