Exemple #1
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 3, true);
            Cost     = 122;
            Range    = 45;


            Priority = SkillPriority.High;

            PreCast = new SkillPreCast(SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckCanCast);

            PreCast.Criteria += (s) => !Hotbar.HasDebuff(SNOPower.Succubus_BloodStar);

            ClusterConditions.Add(new SkillClusterConditions(4d, 45f, 4, true));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: Range, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal | TargetProperties.Fast));
            SingleUnitCondition.Add(new UnitTargetConditions
            {
                TrueConditionFlags = TargetProperties.None,
                Criteria           = (unit) => FunkyGame.Hero.dCurrentEnergyPct > 0.9d,
                //Distance = Range,
                FalseConditionFlags = TargetProperties.LowHealth,
            });

            FcriteriaCombat = (u) => !FunkyGame.Hero.Class.bWaitingForSpecial;
        }
Exemple #2
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 1, true);
            Cost     = RuneIndex == 3 ? 10 : 20;
            Range    = 50;

            IsChanneling        = true;
            IsDestructiblePower = true;

            Priority = SkillPriority.Medium;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 45, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

            ClusterConditions.Add(new SkillClusterConditions(10d, 45f, 2, true));

            FcriteriaCombat = (u) =>
            {
                if (FunkyGame.Hero.Class.bWaitingForSpecial)
                {
                    return(false);
                }

                var isChanneling = (IsFiring || LastUsedMilliseconds < 450);
                //If channeling, check if energy is greater then 10.. else only start when energy is at least -40-
                return((isChanneling && FunkyGame.Hero.dCurrentEnergy > 6) || (FunkyGame.Hero.dCurrentEnergy > 40) &&
                       (!FunkyGame.Hero.Class.bWaitingForSpecial || FunkyGame.Hero.dCurrentEnergy >= FunkyGame.Hero.Class.iWaitingReservedAmount));
            };
        }
Exemple #3
0
        public override void Initialize()
        {
            Cooldown      = 5;
            ExecutionType = AbilityExecuteFlags.Target | AbilityExecuteFlags.ClusterTargetNearest;
            WaitVars      = new WaitLoops(0, 1, true);
            Cost          = RuneIndex == 3?10:20;
            Range         = 50;
            IsRanged      = true;
            IsProjectile  = true;
            IsChanneling  = true;
            UseageType    = AbilityUseage.Combat;
            Priority      = AbilityPriority.Medium;
            PreCast       = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));

            SingleUnitCondition = new UnitTargetConditions(TargetProperties.IsSpecial, 45);
            ClusterConditions   = new SkillClusterConditions(10d, 45f, 2, true);

            FcriteriaCombat = () =>
            {
                var isChanneling = (IsFiring || LastUsedMilliseconds < 450);
                //If channeling, check if energy is greater then 10.. else only start when energy is at least -40-
                return((isChanneling && Bot.Character.Data.dCurrentEnergy > 6) || (Bot.Character.Data.dCurrentEnergy > 40) &&
                       (!Bot.Character.Class.bWaitingForSpecial || Bot.Character.Data.dCurrentEnergy >= Bot.Character.Class.iWaitingReservedAmount));
            };
        }
Exemple #4
0
        public override void Initialize()
        {
            FullMarauderSetBonus = Equipment.CheckLegendaryItemCount(LegendaryItemTypes.EmbodimentoftheMarauder, 6);
            BombadiersRucksack   = Equipment.CheckLegendaryItemCount(LegendaryItemTypes.BombadiersRucksack);

            WaitVars = new WaitLoops(0, 0, true);
            Cost     = 30;
            Range    = 55;

            Priority = SkillPriority.High;
            PreCast  = new SkillPreCast
            {
                Flags = SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckCanCast,
            };
            PreCast.Criteria += skill => FunkyGame.Targeting.Cache.Environment.HeroPets.DemonHunterSentry < SentryMax();
            PreCast.CreatePrecastCriteria();

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, Range, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));
            //Any unit when our energy is greater than 90%!
            SingleUnitCondition.Add(new UnitTargetConditions
            {
                TrueConditionFlags  = TargetProperties.None,
                Criteria            = (unit) => FunkyGame.Hero.dCurrentEnergyPct > (FullMarauderSetBonus ? 0.5d : 0.9d),
                MaximumDistance     = Range,
                FalseConditionFlags = TargetProperties.LowHealth,
            });

            ClusterConditions.Add(new SkillClusterConditions(6d, Range, 3, true));


            FcriteriaCombat = (u) => FunkyGame.Targeting.Cache.Environment.HeroPets.DemonHunterSentry < SentryMax();
        }
Exemple #5
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(1, 1, true);
            Cost     = 250;
            Range    = RuneIndex == 4 ? 20 : 40;


            Priority = SkillPriority.Medium;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckEnergy |
                                         SkillPrecastFlags.CheckCanCast));

            PreCast.Criteria += (s) => !Hotbar.HasDebuff(SNOPower.Succubus_BloodStar);

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: Range, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal | TargetProperties.Fast));
            //Any unit when our energy is greater than 90%!
            SingleUnitCondition.Add(new UnitTargetConditions
            {
                TrueConditionFlags  = TargetProperties.None,
                Criteria            = (unit) => FunkyGame.Hero.dCurrentEnergyPct > 0.9d,
                MaximumDistance     = Range,
                FalseConditionFlags = TargetProperties.LowHealth,
            });

            ClusterConditions.Add(new SkillClusterConditions(4d, RuneIndex == 4 ? 20f : 40f, 2, true));

            FcriteriaCombat = (u) => !FunkyGame.Hero.Class.bWaitingForSpecial;
        }
Exemple #6
0
        public override void Initialize()
        {
            Cooldown         = 3300;
            ExecutionType    = AbilityExecuteFlags.Buff;
            WaitVars         = new WaitLoops(0, 1, true);
            Cost             = Bot.Character.Class.HotBar.PassivePowers.Contains(SNOPower.Monk_Passive_ChantOfResonance) ? 25 : 50;
            IsBuff           = true;
            UseageType       = AbilityUseage.Anywhere;
            Priority         = AbilityPriority.High;
            PreCast          = new SkillPreCast((AbilityPreCastFlags.CheckEnergy | AbilityPreCastFlags.CheckRecastTimer));
            IsSpecialAbility = true;
            FcriteriaBuff    = () => !Bot.Character.Class.HotBar.HasBuff(SNOPower.X1_Monk_MantraOfRetribution_v2_Passive);

            FcriteriaCombat = () => !Bot.Character.Class.HotBar.HasBuff(SNOPower.X1_Monk_MantraOfRetribution_v2_Passive)
                              ||
                              Bot.Settings.Class.bMonkSpamMantra && Bot.Targeting.Cache.CurrentTarget != null &&
                              (Bot.Targeting.Cache.Environment.iElitesWithinRange[(int)RangeIntervals.Range_25] > 0 ||
                               Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_20] >= 2 ||
                               (Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_20] >= 1 && Bot.Settings.Class.bMonkInnaSet) ||
                               (Bot.Targeting.Cache.CurrentUnitTarget.IsEliteRareUnique || Bot.Targeting.Cache.CurrentTarget.IsBoss) &&
                               Bot.Targeting.Cache.CurrentTarget.RadiusDistance <= 25f) &&
                              // Check if either we don't have blinding flash, or we do and it's been cast in the last 6000ms
                              //DateTime.Now.Subtract(dictAbilityLastUse[SNOPower.Monk_BlindingFlash]).TotalMilliseconds <= 6000)) &&
                              (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_BlindingFlash) ||
                               (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_BlindingFlash) && (Bot.Character.Class.HotBar.HasBuff(SNOPower.Monk_BlindingFlash))));
        }
Exemple #7
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 1, true);
            Cost     = 10;

            if (RuneIndex != 4)
            {
                IsDestructiblePower = true;
                Range    = 50;
                Priority = SkillPriority.Medium;
                PreCast  = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckEnergy));

                ClusterConditions.Add(new SkillClusterConditions(4d, 40, 2, true));
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 50, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

                FcriteriaCombat = (u) => !FunkyGame.Hero.Class.bWaitingForSpecial && ((!Hotbar.HasPower(SNOPower.DemonHunter_ClusterArrow)) ||
                                                                                      LastUsedMilliseconds >= 110000);
            }
            else
            {            //Shuriken Cloud
                _executiontype  = SkillExecutionFlags.Buff;
                PreCast         = new SkillPreCast(SkillPrecastFlags.CheckCanCast);
                Priority        = SkillPriority.High;
                IsBuff          = true;
                FcriteriaBuff   = () => !Hotbar.HasBuff(SNOPower.DemonHunter_Chakram);
                FcriteriaCombat = (u) => !Hotbar.HasBuff(SNOPower.DemonHunter_Chakram);
            }
        }
Exemple #8
0
        public override void Initialize()
        {
            Cooldown         = 100000;
            ExecutionType    = AbilityExecuteFlags.Buff;
            WaitVars         = new WaitLoops(4, 5, true);
            Cost             = 25;
            UseageType       = AbilityUseage.Combat;
            IsSpecialAbility = true;
            Priority         = AbilityPriority.High;
            PreCast          = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated | AbilityPreCastFlags.CheckCanCast |
                                                 AbilityPreCastFlags.CheckEnergy));
            UnitsWithinRangeConditions  = new Tuple <RangeIntervals, int>(RangeIntervals.Range_25, 1);
            ElitesWithinRangeConditions = new Tuple <RangeIntervals, int>(RangeIntervals.Range_30, 1);
            SingleUnitCondition         = new UnitTargetConditions(TargetProperties.IsSpecial, 30);
            FcriteriaCombat             = () =>
            {
                bool missingBuffs = MissingBuffs();
                if (missingBuffs)
                {
                    Bot.Character.Class.bWaitingForSpecial = true;
                }

                return(!missingBuffs);
            };
        }
Exemple #9
0
        public override void Initialize()
        {
            Cooldown      = 15200;
            ExecutionType = AbilityExecuteFlags.Buff;
            WaitVars      = new WaitLoops(0, 1, true);
            Cost          = 10;
            UseageType    = AbilityUseage.Anywhere;
            Priority      = AbilityPriority.High;
            PreCast       = new SkillPreCast((AbilityPreCastFlags.CheckEnergy | AbilityPreCastFlags.CheckCanCast |
                                              AbilityPreCastFlags.CheckRecastTimer));

            FcriteriaCombat = () => Bot.Targeting.Cache.Environment.iElitesWithinRange[(int)RangeIntervals.Range_15] >= 1 || Bot.Character.Data.dCurrentHealthPct <= 0.4 ||
                              (Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_20] >= 5 &&
                               Bot.Targeting.Cache.Environment.iElitesWithinRange[(int)RangeIntervals.Range_50] == 0) ||
                              (Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_15] >= 3 && Bot.Character.Data.dCurrentEnergyPct <= 0.5) ||
                              (Bot.Targeting.Cache.CurrentTarget.IsBoss && Bot.Targeting.Cache.CurrentTarget.RadiusDistance <= 15f) ||
                              (Bot.Settings.Class.bMonkInnaSet && Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_15] >= 1 &&
                               Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_SweepingWind) && !Bot.Character.Class.HotBar.HasBuff(SNOPower.Monk_SweepingWind))
                              &&
                              // Check if we don't have breath of heaven
                              (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_BreathOfHeaven) ||
                               (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_BreathOfHeaven) && (!Bot.Settings.Class.bMonkInnaSet ||
                                                                                                                   Bot.Character.Class.HotBar.HasBuff(SNOPower.Monk_BreathOfHeaven)))) &&
                              // Check if either we don't have sweeping winds, or we do and it's ready to cast in a moment
                              (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_SweepingWind) ||
                               (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_SweepingWind) && (Bot.Character.Data.dCurrentEnergy >= 95 ||
                                                                                                                 (Bot.Settings.Class.bMonkInnaSet &&
                                                                                                                  Bot.Character.Data.dCurrentEnergy >= 25) ||
                                                                                                                 Bot.Character.Class.HotBar.HasBuff(SNOPower.Monk_SweepingWind))) ||
                               Bot.Character.Data.dCurrentHealthPct <= 0.4);
        }
Exemple #10
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 1, true);
            Cost     = Hotbar.PassivePowers.Contains(SNOPower.Monk_Passive_ChantOfResonance) ? 25 : 50;


            Priority = SkillPriority.High;

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, 30, -1, 0.99d));

            if (Equipment.CheckLegendaryItemCount(LegendaryItemTypes.MonkeyKingsGarb, 4))
            {
                PreCast         = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
                FcriteriaBuff   = () => FunkyBaseExtension.Settings.Monk.bMonkSpamMantra && FunkyGame.Targeting.Cache.Environment.SurroundingUnits > 0;
                FcriteriaCombat = (u) =>
                                  !FunkyGame.Hero.Class.bWaitingForSpecial &&
                                  FunkyBaseExtension.Settings.Monk.bMonkSpamMantra &&
                                  FunkyGame.Targeting.Cache.Environment.SurroundingUnits > 0;
            }
            else
            {
                PreCast         = new SkillPreCast((SkillPrecastFlags.CheckEnergy | SkillPrecastFlags.CheckRecastTimer));
                FcriteriaBuff   = () => FunkyBaseExtension.Settings.Monk.bMonkSpamMantra && FunkyGame.Targeting.Cache.Environment.SurroundingUnits > 0 && LastUsedMilliseconds > 3000;
                FcriteriaCombat = (u) => FunkyBaseExtension.Settings.Monk.bMonkSpamMantra && LastUsedMilliseconds > 3000;
            }
        }
Exemple #11
0
        public override void Initialize()
        {
            Cooldown      = 2900;
            ExecutionType = AbilityExecuteFlags.Buff;
            WaitVars      = new WaitLoops(1, 1, true);
            Cost          = 20;
            UseageType    = AbilityUseage.Anywhere;
            Priority      = AbilityPriority.Medium;
            PreCast       = new SkillPreCast((AbilityPreCastFlags.CheckEnergy | AbilityPreCastFlags.CheckCanCast |
                                              AbilityPreCastFlags.CheckPlayerIncapacitated));

            IsBuff        = true;
            FcriteriaBuff = () => Bot.Settings.OutOfCombatMovement && !Bot.Character.Class.HotBar.HasBuff(Power);

            FcriteriaCombat = () => (!Bot.Character.Class.HotBar.HasBuff(SNOPower.Barbarian_Sprint) && Bot.Settings.OutOfCombatMovement) ||
                              (((Bot.Settings.Class.bFuryDumpWrath && Bot.Character.Data.dCurrentEnergyPct >= 0.95 &&
                                 Bot.Character.Class.HotBar.HasBuff(SNOPower.Barbarian_WrathOfTheBerserker)) ||
                                (Bot.Settings.Class.bFuryDumpAlways && Bot.Character.Data.dCurrentEnergyPct >= 0.95) ||
                                ((Bot.Character.Class.Abilities[SNOPower.Barbarian_Sprint].AbilityUseTimer() && !Bot.Character.Class.HotBar.HasBuff(SNOPower.Barbarian_Sprint)) &&
                                 // Always keep up if we are whirlwinding, or if the target is a goblin
                                 (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Barbarian_Whirlwind) ||
                                  Bot.Targeting.Cache.CurrentTarget.IsTreasureGoblin))) &&
                               (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Barbarian_BattleRage) ||
                                (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Barbarian_BattleRage) && Bot.Character.Class.HotBar.HasBuff(SNOPower.Barbarian_BattleRage))));
        }
Exemple #12
0
        public override void Initialize()
        {
            Cooldown      = 15000;
            ExecutionType = AbilityExecuteFlags.Buff;
            WaitVars      = new WaitLoops(0, 1, true);
            Cost          = 59;
            Counter       = 5;
            UseageType    = AbilityUseage.Combat;
            Priority      = AbilityPriority.High;

            PreCast           = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated | AbilityPreCastFlags.CheckCanCast | AbilityPreCastFlags.CheckEnergy));
            ClusterConditions = new SkillClusterConditions(6d, 9f, 2, false, useRadiusDistance: true);
            FcriteriaCombat   = () =>
            {
                double lastCast   = LastUsedMilliseconds;
                int    RecastMS   = RuneIndex == 1?45000:20000;
                bool   recast     = lastCast > RecastMS;               //if using soul to waste -- 45ms, else 20ms.
                int    stackCount = Bot.Character.Class.HotBar.GetBuffStacks(SNOPower.Witchdoctor_SoulHarvest);
                if (stackCount < 5)
                {
                    return(true);
                }
                if (recast)
                {
                    return(true);
                }
                return(false);
            };
        }
Exemple #13
0
        public override void Initialize()
        {
            if (!Bot.Settings.Class.bMonkComboStrike)
            {
                Cooldown = 5;
            }
            else
            {
                Cooldown = 250 + (250 * Bot.Settings.Class.iMonkComboStrikeAbilities);
            }

            ExecutionType = AbilityExecuteFlags.Target;
            WaitVars      = new WaitLoops(0, 1, false);
            Priority      = Bot.Settings.Class.bMonkComboStrike?AbilityPriority.Medium:AbilityPriority.Low;
            Range         = 14;
            UseageType    = AbilityUseage.Combat;
            var precastflags = AbilityPreCastFlags.CheckPlayerIncapacitated;

            //Combot Strike? lets enforce recast timer and cast check
            if (Bot.Settings.Class.bMonkComboStrike)
            {
                precastflags |= AbilityPreCastFlags.CheckRecastTimer | AbilityPreCastFlags.CheckCanCast;
            }

            PreCast = new SkillPreCast(precastflags);
        }
Exemple #14
0
        public override void Initialize()
        {
            //Runeindex 2 == Sticky Trap!
            if (RuneIndex == 2)
            {
                ExecutionType = SkillExecutionFlags.Target | SkillExecutionFlags.ClusterTarget;
            }

            WaitVars = new WaitLoops(1, 1, true);
            Cost     = 30;
            Range    = 40;

            Priority = SkillPriority.Medium;

            PreCast = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckRecastTimer | SkillPrecastFlags.CheckEnergy));

            if (RuneIndex == 2)             //sticky trap on weak non-full HP units!
            {
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.Weak, falseConditionalFlags: TargetProperties.FullHealth));
            }
            else
            {
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.RareElite));
            }


            ClusterConditions.Add(new SkillClusterConditions(6d, 45f, 2, true));

            FcriteriaCombat = (u) => FunkyGame.Targeting.Cache.Environment.HeroPets.DemonHunterSpikeTraps <
                              (Hotbar.PassivePowers.Contains(SNOPower.DemonHunter_Passive_CustomEngineering) ? 6 : 3);
        }
Exemple #15
0
        public override void Initialize()
        {
            Range    = 7;
            Priority = SkillPriority.None;

            WaitVars = new WaitLoops(0, 2, true);
            PreCast  = new SkillPreCast(SkillPrecastFlags.None);
        }
Exemple #16
0
        public override void Initialize()
        {
            WaitVars   = new WaitLoops(3, 3, true);
            Priority   = SkillPriority.None;
            UseageType = SkillUseage.OutOfCombat;
            PreCast    = new SkillPreCast(SkillPrecastFlags.None);

            //Important!! We have to override the default return of true.. we dont want this to fire as a combat Ability.
            FcriteriaCombat = (u) => false;
        }
Exemple #17
0
 public override void Initialize()
 {
     Cooldown      = 5;
     ExecutionType = AbilityExecuteFlags.Target;
     WaitVars      = new WaitLoops(0, 1, true);
     Range         = 14;
     UseageType    = AbilityUseage.Combat;
     Priority      = AbilityPriority.Low;
     PreCast       = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
 }
Exemple #18
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(1, 2, true);
            Cost     = 25;


            Priority = SkillPriority.High;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckEnergy |
                                         SkillPrecastFlags.CheckRecastTimer));
        }
Exemple #19
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 0, true);
            Cost     = 35;
            Range    = 48;


            Priority = SkillPriority.Medium;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckCanCast));
        }
Exemple #20
0
        public override void Initialize()
        {
            Cooldown = 15000;

            WaitVars = new WaitLoops(0, 1, true);
            Cost     = 59;
            Counter  = 5;

            Priority = SkillPriority.Medium;
            Range    = 10;

            PreCast = new SkillPreCast(SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckCanCast);
            ClusterConditions.Add(new SkillClusterConditions(6d, 10f, 4, false, useRadiusDistance: true));



            if (!Equipment.CheckLegendaryItemCount(LegendaryItemTypes.RaimentoftheJadeHarvester, 6))
            {
                SingleUnitCondition.Add(new UnitTargetConditions
                {
                    Criteria            = (unit) => Hotbar.GetBuffStacks(SNOPower.Witchdoctor_SoulHarvest) == 0,
                    MaximumDistance     = 9,
                    FalseConditionFlags = TargetProperties.Normal,
                    HealthPercent       = 0.95d,
                    TrueConditionFlags  = TargetProperties.None,
                });

                FcriteriaCombat = (u) =>
                {
                    double lastCast   = LastUsedMilliseconds;
                    int    RecastMS   = RuneIndex == 1 ? 45000 : 20000;
                    bool   recast     = lastCast > RecastMS;               //if using soul to waste -- 45ms, else 20ms.
                    int    stackCount = Hotbar.GetBuffStacks(SNOPower.Witchdoctor_SoulHarvest);
                    if (stackCount < 5)
                    {
                        return(true);
                    }
                    if (recast)
                    {
                        return(true);
                    }
                    return(false);
                };
            }
            else
            {
                SingleUnitCondition.Add(new UnitTargetConditions
                {
                    MaximumDistance     = 9,
                    FalseConditionFlags = TargetProperties.Normal,
                    HealthPercent       = 0.95d,
                    TrueConditionFlags  = TargetProperties.None,
                });
            }
        }
Exemple #21
0
        public override void Initialize()
        {
            Cooldown = 90000;

            WaitVars = new WaitLoops(0, 1, true);

            Priority = SkillPriority.High;
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.Boss, maxdistance: 50, MinimumHealthPercent: 0.75d));
            ClusterConditions.Add(new SkillClusterConditions(10d, 50f, 4, true, clusterflags: ClusterProperties.Elites));
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);
        }
Exemple #22
0
 public override void Initialize()
 {
     Cooldown        = 10200;
     ExecutionType   = AbilityExecuteFlags.Self;
     WaitVars        = new WaitLoops(1, 1, true);
     Cost            = 0;
     UseageType      = AbilityUseage.Anywhere;
     Priority        = AbilityPriority.Medium;
     PreCast         = new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer | AbilityPreCastFlags.CheckCanCast | AbilityPreCastFlags.CheckPlayerIncapacitated));
     FcriteriaCombat = () => (Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_20] > 2);
 }
Exemple #23
0
        public override void Initialize()
        {
            ClusterConditions.Add(new SkillClusterConditions(6d, 40f, 1, true));
            WaitVars = new WaitLoops(0, 0, false);
            Cost     = 0;
            Range    = 40;


            Priority = SkillPriority.Low;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
        }
Exemple #24
0
 public override void Initialize()
 {
     Cooldown      = 90000;
     ExecutionType = AbilityExecuteFlags.Self;
     WaitVars      = new WaitLoops(1, 1, true);
     UseageType    = AbilityUseage.Combat;
     Priority      = AbilityPriority.Medium;
     PreCast       = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated | AbilityPreCastFlags.CheckCanCast));
     ElitesWithinRangeConditions = new Tuple <RangeIntervals, int>(RangeIntervals.Range_25, 1);
     SingleUnitCondition         = new UnitTargetConditions(TargetProperties.IsSpecial, 16);
 }
Exemple #25
0
        public override void Initialize()
        {
            Cooldown      = 5;
            Range         = 8;
            Priority      = AbilityPriority.None;
            ExecutionType = AbilityExecuteFlags.Target;

            WaitVars   = new WaitLoops(0, 0, true);
            PreCast    = new SkillPreCast(AbilityPreCastFlags.None);
            UseageType = AbilityUseage.Combat;
        }
Exemple #26
0
        public override void Initialize()
        {
            WaitVars = new WaitLoops(0, 0, true);
            Cost     = 18;
            Range    = 35;


            Priority        = SkillPriority.Medium;
            PreCast         = new SkillPreCast(SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckEnergy | SkillPrecastFlags.CheckCanCast);
            FcriteriaCombat = (u) => !FunkyGame.Hero.Class.bWaitingForSpecial;
        }
Exemple #27
0
 public override void Initialize()
 {
     Cooldown            = 200;
     ExecutionType       = AbilityExecuteFlags.Target | AbilityExecuteFlags.ClusterTargetNearest;
     WaitVars            = new WaitLoops(1, 1, true);
     Range               = 15;
     UseageType          = AbilityUseage.Combat;
     Priority            = AbilityPriority.Low;
     PreCast             = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
     ClusterConditions   = new SkillClusterConditions(6d, 10f, 2, true);
     SingleUnitCondition = new UnitTargetConditions(TargetProperties.None, 8);
 }
Exemple #28
0
        public override void Initialize()
        {
            Cooldown = 15000;

            WaitVars = new WaitLoops(0, 1, true);

            Priority = SkillPriority.High;
            PreCast  = new SkillPreCast((SkillPrecastFlags.CheckCanCast));

            FcriteriaBuff   = () => FunkyGame.Hero.dCurrentHealthPct <= 0.45d && FunkyGame.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_40] > 0;
            FcriteriaCombat = (u) => FunkyGame.Hero.dCurrentHealthPct <= 0.45d && FunkyGame.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_40] > 0;
        }
Exemple #29
0
        public override void Initialize()
        {
            TallManFinger = Equipment.CheckLegendaryItemCount(LegendaryItemTypes.TheTallMansFinger);

            WaitVars = new WaitLoops(0, 0, true);

            Priority = SkillPriority.High;
            PreCast  = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            FcriteriaBuff   = () => FunkyGame.Targeting.Cache.Environment.HeroPets.ZombieDogs < GetTotalZombieDogsSummonable();
            FcriteriaCombat = (u) => FunkyGame.Targeting.Cache.Environment.HeroPets.ZombieDogs < GetTotalZombieDogsSummonable();
        }
Exemple #30
0
        public override void Initialize()
        {
            Range = RuneIndex == 4 ? 35 : 45;

            WaitVars = new WaitLoops(0, 0, false);
            Cost     = 0;

            Priority = SkillPriority.Low;

            PreCast = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None));
        }