Esempio n. 1
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            var thrashIsEnabled = new BooleanCondition(Settings.GuardianThrashEnabled);
            var inBearForm = new MeIsInBearFormCondition();
            var attackableTarget = new MeHasAttackableTargetCondition();
            var targetIsWithinMeleeRange = new MyTargetIsWithinMeleeRangeCondition();
            var facingTarget = new MeIsFacingTargetCondition();
            var minEnemies = new AttackableTargetsMinCountCondition(Settings.GuardianThrashMinEnemies);

            Conditions.Add(thrashIsEnabled);
            Conditions.Add(inBearForm);
            Conditions.Add(attackableTarget);
            Conditions.Add(targetIsWithinMeleeRange);
            Conditions.Add(facingTarget);
            Conditions.Add(minEnemies);
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, Spell.Id));

            PandemicConditions.Add(thrashIsEnabled);
            PandemicConditions.Add(inBearForm);
            PandemicConditions.Add(attackableTarget);
            PandemicConditions.Add(targetIsWithinMeleeRange);
            PandemicConditions.Add(facingTarget);
            PandemicConditions.Add(minEnemies);
            PandemicConditions.Add(new BooleanCondition(Settings.GuardianThrashAllowClipping));
            PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
            PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, Spell.Id,
                TimeSpan.FromSeconds(4.8)));
        }
Esempio n. 2
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            // Shared //
            var ripIsEnabled = new BooleanCondition(Settings.RipEnabled);
            var minComboPoints = new MyComboPointsCondition(5, 5);
            var healthCheck = new ConditionTestSwitchCondition(
                new BooleanCondition(Settings.RipEnemyHealthCheck),
                new MyTargetHealthMultiplierCondition(Settings.RipEnemyHealthMultiplier)
                );
            var energy = new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
                new MyEnergyRangeCondition(30.0/2.0),
                new MyEnergyRangeCondition(30.0)
                );

            // Normal //
            Conditions.Add(ripIsEnabled);
            Conditions.Add(minComboPoints);
            Conditions.Add(healthCheck);
            Conditions.Add(energy);
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, SpellBook.Rip));

            // Pandemic //
            PandemicConditions.Add(ripIsEnabled);
            PandemicConditions.Add(minComboPoints);
            PandemicConditions.Add(healthCheck);
            PandemicConditions.Add(energy);
            PandemicConditions.Add(new BooleanCondition(Settings.RipAllowClipping));
            PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, SpellBook.Rip));
            PandemicConditions.Add(new TargetHealthRangeCondition(TargetType.MyCurrentTarget, 25, 100));
            PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, SpellBook.Rip,
                TimeSpan.FromSeconds(7)));
        }
Esempio n. 3
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            var enabled = new BooleanCondition(Settings.ThrashEnabled);
            var minTargetCount = new ConditionTestSwitchCondition(
                new BooleanCondition(Settings.ThrashClearcastingProcEnabled),
                new TargetHasAuraCondition(TargetType.Me, SpellBook.ClearcastingProc),
                new AttackableTargetsMinCountCondition(Settings.ThrashMinEnemies)
                );
            var distance = new MyTargetDistanceCondition(0, Settings.AoeRange);

            Conditions.Add(enabled);
            Conditions.Add(minTargetCount);
            Conditions.Add(distance);
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
            if (Settings.SavageRoarEnabled)
            {
                Conditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.SavageRoar),
                    new MySavageRoarAuraCondition()
                    ));
            }

            PandemicConditions.Add(enabled);
            PandemicConditions.Add(minTargetCount);
            PandemicConditions.Add(distance);
            PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
            PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, Spell.Id,
                TimeSpan.FromSeconds(4)));
            if (Settings.SavageRoarEnabled)
            {
                PandemicConditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.SavageRoar),
                    new MySavageRoarAuraCondition()
                    ));
            }
        }
Esempio n. 4
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            // Shared //
            var savageRoarIsEnabled = new BooleanCondition(Settings.SavageRoarEnabled);
            var minComboPoints = new MyComboPointsCondition(Settings.SavageRoarMinComboPoints, 5);
            var energy = new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
                new MyEnergyRangeCondition(25.0/2.0),
                new MyEnergyRangeCondition(25.0)
                );

            // Normal //
            Conditions.Add(savageRoarIsEnabled);
            Conditions.Add(minComboPoints);
            Conditions.Add(energy);
            Conditions.Add(new MySavageRoarAuraCondition(false));

            // Pandemic //
            PandemicConditions.Add(savageRoarIsEnabled);
            PandemicConditions.Add(minComboPoints);
            PandemicConditions.Add(energy);
            PandemicConditions.Add(new BooleanCondition(Settings.SavageRoarAllowClipping));
            PandemicConditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.GlyphOfSavagery));
            PandemicConditions.Add(new ConditionOrList(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.SavageRoar),
                new TargetHasAuraCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar)
                ));
            PandemicConditions.Add(new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.SavageRoar),
                new TargetAuraMinTimeLeftCondition(TargetType.Me, SpellBook.SavageRoar, TimeSpan.FromSeconds(3.5))
                ));
            PandemicConditions.Add(new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar),
                new TargetAuraMinTimeLeftCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar, TimeSpan.FromSeconds(3.5))
                ));
        }
Esempio n. 5
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            // Shared //
            var rakeIsEnabled = new BooleanCondition(Settings.RakeEnabled);
            var meIsNotProwling = new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.Prowl);
            var energy = new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
                new MyEnergyRangeCondition(35.0/2.0),
                new MyEnergyRangeCondition(35.0)
                );

            // Normal //
            Conditions.Add(rakeIsEnabled);
            Conditions.Add(meIsNotProwling);
            Conditions.Add(energy);
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, SpellBook.RakeBleedDebuff));
            Conditions.Add(new MyMaxRakedUnitsCondition(Settings.RakeMaxEnemies));

            // Pandemic //
            PandemicConditions.Add(rakeIsEnabled);
            PandemicConditions.Add(meIsNotProwling);
            PandemicConditions.Add(energy);
            PandemicConditions.Add(new BooleanCondition(Settings.RakeAllowClipping));
            PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, SpellBook.RakeBleedDebuff));
            PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget,
                SpellBook.RakeBleedDebuff, TimeSpan.FromSeconds(4.5)));
        }
Esempio n. 6
0
        public override void ApplyDefaultSettings()
        {
            base.ApplyDefaultSettings();

            // Shared //
            var isEnabled = new BooleanCondition(Settings.MoonfireEnabled);
            var isLowLevelCheck = new ConditionTestSwitchCondition(
                new MeKnowsSpellCondition(SpellBook.CatForm),
                new ConditionDependencyList(
                    new BooleanCondition(Settings.MoonfireEnabled),
                    new MeIsInCatFormCondition()
                    )
                );
            var energy = new ConditionTestSwitchCondition(
                new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
                new MyEnergyRangeCondition(35.0/2.0),
                new MyEnergyRangeCondition(35.0)
                );

            // Normal //
            Conditions.Add(isEnabled);
            Conditions.Add(isLowLevelCheck);
            Conditions.Add(energy);
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget,
                SpellBook.MoonfireDotDebuffLowLevel));
            Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget,
                SpellBook.MoonfireDotDebuffHighLevel));
            if (Settings.MoonfireOnlyWithLunarInspiration)
            {
                Conditions.Add(new MeKnowsSpellCondition(SpellBook.LunarInspiration));
            }
            if (Settings.FerociousBiteEnabled)
            {
                Conditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.FerociousBite),
                    new MyComboPointsCondition(0, 4)
                    ));
            }
            if (Settings.RipEnabled)
            {
                Conditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.Rip),
                    new MyComboPointsCondition(0, 4)
                    ));
            }

            // Pandemic //
            PandemicConditions.Add(isEnabled);
            PandemicConditions.Add(isLowLevelCheck);
            PandemicConditions.Add(energy);
            PandemicConditions.Add(new BooleanCondition(Settings.MoonfireAllowClipping));
            PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget,
                SpellBook.MoonfireDotDebuffHighLevel));
            PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget,
                SpellBook.MoonfireDotDebuffHighLevel, TimeSpan.FromSeconds(4)));
            if (Settings.FerociousBiteEnabled)
            {
                PandemicConditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.FerociousBite),
                    new MyComboPointsCondition(0, 4)
                    ));
            }
            if (Settings.RipEnabled)
            {
                PandemicConditions.Add(new ConditionTestSwitchCondition(
                    new MeKnowsSpellCondition(SpellBook.Rip),
                    new MyComboPointsCondition(0, 4)
                    ));
            }
        }