Skill Precast Conditions
Beispiel #1
0
        public override void Initialize()
        {
            Priority = SkillPriority.Medium;
            Range = 60;
            PreCast=new SkillPreCast((SkillPrecastFlags.CheckCanCast |SkillPrecastFlags.CheckPlayerIncapacitated));

            var IntersectingUnitTargetConditions =
                new UnitTargetConditions
                {
                    TrueConditionFlags = TargetProperties.None,
                    MaximumDistance = Range,
                    Criteria = (unit) => unit.TargetInfo.IntersectingUnits>2
                };
            SingleUnitCondition.Add(IntersectingUnitTargetConditions);
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, Range, falseConditionalFlags: TargetProperties.Normal));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.Summoner, Range, falseConditionalFlags: TargetProperties.LowHealth));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.AvoidanceSummoner, Range, falseConditionalFlags: TargetProperties.LowHealth));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.Debuffing, Range, falseConditionalFlags: TargetProperties.LowHealth));
            //SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.Ranged, Range, MinimumHealthPercent: 0.50d));
            SingleUnitCondition.Add(new UnitTargetConditions
            {
                Criteria = (unit) => FunkyGame.Hero.dCurrentEnergyPct > 0.80d,
                MaximumDistance = Range,
                FalseConditionFlags = TargetProperties.LowHealth,
            });
        }
Beispiel #2
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;
        }
Beispiel #3
0
        public override void Initialize()
        {
            Priority = SkillPriority.High;
            PreCast = new SkillPreCast((SkillPrecastFlags.CheckRecastTimer | SkillPrecastFlags.CheckCanCast));

            FcriteriaCombat = (u) => FunkyGame.Hero.dCurrentHealthPct <= 0.45;
        }
Beispiel #4
0
        public override void Initialize()
        {
            Priority = SkillPriority.Low;
            Range = 16;

            //Combot Strike? lets enforce recast timer and cast check
            //if (FunkyBaseExtension.Settings.Monk.bMonkComboStrike)
                //precastflags |= SkillPrecastFlags.CheckRecastTimer | SkillPrecastFlags.CheckCanCast;

            if (FunkyBaseExtension.Settings.Monk.bMonkComboStrike)
            {
                PreCast = new SkillPreCast
                {
                    Flags = SkillPrecastFlags.CheckPlayerIncapacitated
                };
                PreCast.Criteria += skill => FunkyGame.Hero.Class.LastUsedAbilities.IndexOf(this) >= FunkyBaseExtension.Settings.Monk.iMonkComboStrikeAbilities-1;
                PreCast.CreatePrecastCriteria();

                //Use as third hitter!
                if (RuneIndex==0)
                    Priority=SkillPriority.None;
            }
            else
                PreCast = new SkillPreCast(SkillPrecastFlags.CheckPlayerIncapacitated);
        }
Beispiel #5
0
        public override void Initialize()
        {
            Priority = SkillPriority.High;
            Cost = 50;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckEnergy | SkillPrecastFlags.CheckExisitingBuff | SkillPrecastFlags.CheckCanCast);
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 40, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

            if (FunkyBaseExtension.Settings.Barbarian.bBarbUseWOTBAlways)
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None));

            FcriteriaCombat = (u) =>
            {
                //Anytime?
                if (FunkyBaseExtension.Settings.Barbarian.bBarbUseWOTBAlways)
                    return true;

                //Treasure Goblins?
                if (u.IsTreasureGoblin)
                    return FunkyBaseExtension.Settings.Barbarian.bGoblinWrath;

                //Normal Targets?
                if (u.Properties.HasFlag(TargetProperties.Normal))
                    return false;

                return true;
            };
        }
Beispiel #6
0
        public override void Initialize()
        {
            if (RuneIndex != 4)
                Cooldown = 20000;

            Range = 49;
            Cost = RuneIndex == 4 ? 40 : 0;
            Priority = SkillPriority.High;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            //Fires of Heaven (Straight Line Fire)
            ClusterConditions.Add(RuneIndex == 4
                ? new SkillClusterConditions(5d, 45f, 3, true)
                : new SkillClusterConditions(8d, 45f, 4, true));

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 45, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

            //Fire of Heaven (No CD!)
            if (RuneIndex == 4)
            {
                SingleUnitCondition.Add(new UnitTargetConditions
                {
                    TrueConditionFlags = TargetProperties.None,
                    Criteria = (unit) => FunkyGame.Hero.dCurrentEnergyPct > 0.90d,
                    FalseConditionFlags = TargetProperties.LowHealth|TargetProperties.Weak,
                });
            }
        }
Beispiel #7
0
 public override void Initialize()
 {
     Priority = SkillPriority.Low;
     Range = 44;
     Cost = 10;
     PreCast = new SkillPreCast((SkillPrecastFlags.CheckCanCast | SkillPrecastFlags.CheckPlayerIncapacitated));
 }
Beispiel #8
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();
        }
Beispiel #9
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);
            };
        }
Beispiel #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;
            }
        }
Beispiel #11
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);
            }
        }
Beispiel #12
0
 public override void Initialize()
 {
     Cost = 10;
     Range = 30;
     Priority = SkillPriority.Low;
     PreCast = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
 }
Beispiel #13
0
        public override void Initialize()
        {
            Range = 49;
            Cost = 20;
            Priority = SkillPriority.Medium;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            ClusterConditions.Add(new SkillClusterConditions(10d, 35f, 3, true));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, Range, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

            //Use on any unit with Gyrfalcons Foote equipped.
            if (Equipment.LegendaryEquippedItems.Any(i => i == LegendaryItemTypes.GyrfalconsFoote))
            {
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, Range));
            }
            else
            {
                //Use on any unit when energy is greater than 90%
                SingleUnitCondition.Add(new UnitTargetConditions
                {
                    TrueConditionFlags = TargetProperties.None,
                    Criteria = (unit) => FunkyGame.Hero.dCurrentEnergyPct > 0.9d,
                    MaximumDistance = Range,
                    FalseConditionFlags = TargetProperties.LowHealth,
                });
            }
        }
Beispiel #14
0
        public override void Initialize()
        {
            Range = RuneIndex == 2 ? 40
                : RuneIndex == 1 ? 26 : 15;

            Priority = SkillPriority.Low;
            PreCast = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
        }
Beispiel #15
0
        public override void Initialize()
        {
            Range = 25;
            Priority = SkillPriority.None;

            WaitVars = new WaitLoops(0, 0, true);
            PreCast = new SkillPreCast(SkillPrecastFlags.None);
        }
Beispiel #16
0
 public override void Initialize()
 {
     Priority = SkillPriority.Low;
     Range = 10;
     PreCast = new SkillPreCast((SkillPrecastFlags.CheckCanCast));
     ClusterConditions.Add(new SkillClusterConditions(4d, 10f, 2, true));
     SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None));
 }
Beispiel #17
0
        public override void Initialize()
        {
            Range = 25;
            Cost = 10;
            Priority = SkillPriority.Medium;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            FcriteriaCombat = (u) => FunkyGame.Hero.dCurrentHealthPct < 0.5d;
        }
Beispiel #18
0
        public override void Initialize()
        {
            Range = 8;
            Priority = SkillPriority.High;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 30, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));
            ClusterConditions.Add(new SkillClusterConditions(10d, 30, 10, false));
        }
Beispiel #19
0
        public override void Initialize()
        {
            Cooldown=150;

                WaitVars=new WaitLoops(0, 0, true);
                Cost=15;
                IsChanneling=true;

                Range=23;
                Priority=SkillPriority.Medium;
                PreCast=new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated));

                //UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 2);
                //ElitesWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 1);

                ClusterConditions.Add(new SkillClusterConditions(5d, Range, 2, true));
                SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, Range, MinimumHealthPercent: 0.95d, falseConditionalFlags: TargetProperties.Normal));

                FcriteriaCombat=(u) =>
                {
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost = RuneIndex == 3 ? 8 : 10;

                    //If channeling, check if energy is greater then 10.. else only start when energy is at least -40-
                    return (isChanneling&&FunkyGame.Hero.dCurrentEnergy>channelingCost)||(FunkyGame.Hero.dCurrentEnergy>40)
                           &&(!FunkyGame.Hero.Class.bWaitingForSpecial||FunkyGame.Hero.dCurrentEnergy>=FunkyGame.Hero.Class.iWaitingReservedAmount);
                };

                FCombatMovement=v =>
                {
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost = RuneIndex == 3 ? 8 : 10;

                    //If channeling, check if energy is greater then 10.. else only start when energy is at least -40-
                    if ((isChanneling&&FunkyGame.Hero.dCurrentEnergy>channelingCost)||(FunkyGame.Hero.dCurrentEnergy>15)&&!FunkyGame.Hero.Class.bWaitingForSpecial)
                    {
                        if (v.Distance(FunkyGame.Hero.Position)>10f)
                            return MathEx.CalculatePointFrom(v, FunkyGame.Hero.Position, 10f);
                        return v;
                    }

                    return Vector3.Zero;
                };

                FOutOfCombatMovement=v =>
                {
                    Vector3 vTargetAimPoint=MathEx.CalculatePointFrom(v, FunkyGame.Hero.Position, 10f);
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost = RuneIndex == 3 ? 8 : 10;

                    //If channeling, check if energy is greater then 10.. else only start when energy is at least -40-
                    if ((isChanneling&&FunkyGame.Hero.dCurrentEnergy>channelingCost)||FunkyGame.Hero.dCurrentEnergyPct>0.50d)
                        return vTargetAimPoint;

                    return Vector3.Zero;
                };
        }
Beispiel #20
0
 protected SkillCriteria()
 {
     SingleUnitCondition = new List<UnitTargetConditions>();
     ClusterConditions = new List<SkillClusterConditions>();
     TestCustomCombatConditions = false;
     FcriteriaCombat = (u) => true;
     FcriteriaBuff = () => true;
     PreCast = new SkillPreCast();
 }
Beispiel #21
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));
        }
Beispiel #22
0
        public override void Initialize()
        {
            Priority = SkillPriority.High;

            FcriteriaBuff = () => false;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckPlayerIncapacitated | SkillPrecastFlags.CheckCanCast);
            //SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, 10));
            FcriteriaCombat = (u) => FunkyGame.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_12] > 0;
        }
Beispiel #23
0
        public override void Initialize()
        {
            Range = 20;
            Priority = SkillPriority.High;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            ClusterConditions.Add(new SkillClusterConditions(10d, 20f, 5, false, useRadiusDistance: true));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, 20, MinimumHealthPercent: 0.99d, falseConditionalFlags: TargetProperties.Normal));
        }
Beispiel #24
0
        public override void Initialize()
        {
            Range = 49;
            Cost = 30;
            Priority = SkillPriority.Medium;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckCanCast);

            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, maxdistance: 45, MinimumHealthPercent: 0.95d));
        }
Beispiel #25
0
        public override void Initialize()
        {
            Priority = SkillPriority.High;
            PreCast = new SkillPreCast(SkillPrecastFlags.CheckRecastTimer);

            //Make sure we are targeting something!
            SingleUnitCondition.Add(new UnitTargetConditions());
            FcriteriaCombat = (u) => FunkyGame.Hero.dCurrentHealthPct < 0.5d;
        }
Beispiel #26
0
        public override void Initialize()
        {
            Range = 30;
            Priority = SkillPriority.Low;
            PreCast = new SkillPreCast(SkillPrecastFlags.None);

            ClusterConditions.Add(new SkillClusterConditions(8d, 20f, 3, true));
            SingleUnitCondition.Add(new UnitTargetConditions());
        }
Beispiel #27
0
        public override void Initialize()
        {
            Range = 8;
            Cost = 10;

            Priority = SkillPriority.Low;
            PreCast = new SkillPreCast(SkillPrecastFlags.None);
            SingleUnitCondition.Add(new UnitTargetConditions());
        }
Beispiel #28
0
        public override void Initialize()
        {
            Range = 35;

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

            ClusterConditions.Add(new SkillClusterConditions(4d, 35, 2, true));
            SingleUnitCondition.Add(new UnitTargetConditions());
        }
Beispiel #29
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;
        }
        public override void Initialize()
        {
            Range = 48;

            IsChanneling = true;

            Priority = SkillPriority.Low;
            PreCast = new SkillPreCast((SkillPrecastFlags.CheckPlayerIncapacitated));
            SingleUnitCondition.Add(new UnitTargetConditions(TargetProperties.None, -1, 10));
        }