Exemple #1
0
        public override void Initialize()
        {
            Cooldown=1000;

                //Runeindex 2 == Sticky Trap!
                if (RuneIndex != 2)
                    ExecutionType = AbilityExecuteFlags.Location | AbilityExecuteFlags.ClusterTargetNearest;
                else
                    ExecutionType = AbilityExecuteFlags.Target | AbilityExecuteFlags.ClusterTarget;

                WaitVars=new WaitLoops(1, 1, true);
                Cost=30;
                Range=40;
                UseageType=AbilityUseage.Anywhere;
                Priority=AbilityPriority.Medium;

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

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

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

                FcriteriaCombat=() => Bot.Character.Data.PetData.DemonHunterSpikeTraps<
                                      (Bot.Character.Class.HotBar.PassivePowers.Contains(SNOPower.DemonHunter_Passive_CustomEngineering)?6:3);
        }
Exemple #2
0
        public override void Initialize()
        {
            Cooldown=1000;
                ExecutionType=AbilityExecuteFlags.Buff;
                UseageType=AbilityUseage.Combat;
                WaitVars=new WaitLoops(2, 2, true);
                Cost=50;
                Priority=AbilityPriority.High;

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

                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 7);
                //ElitesWithinRangeConditions = new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 3);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.Fast|TargetProperties.IsSpecial, 23);
                ClusterConditions = new SkillClusterConditions(8d, 20f, 4, false, 0, ClusterProperties.Large, 10f, false);
                FcriteriaCombat = () =>
                {
                    if (LastConditionPassed == ConditionCriteraTypes.SingleTarget) return true; //special and fast..

                    //Use every 5.5s when 7+ units are within 25f.
                    if (LastConditionPassed == ConditionCriteraTypes.UnitsInRange && LastUsedMilliseconds > 5500 && !Bot.Character.Class.bWaitingForSpecial)
                        return true;

                    if (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_ExplodingPalm)) return true; //Non Exploding Palm Check

                    if ((Bot.Targeting.Cache.CurrentUnitTarget.HasDOTdps.HasValue && Bot.Targeting.Cache.CurrentUnitTarget.HasDOTdps.Value)
                        && Bot.Targeting.Cache.CurrentUnitTarget.CurrentHealthPct<0.10d)
                    {
                        return true;
                    }

                    return false;
                };
        }
Exemple #3
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 #4
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 #5
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 #6
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(0, 2, false);
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Low;
                Range=RuneIndex==0?25:12;

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

                ClusterConditions=new SkillClusterConditions(5d, 20f, 1, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.None);
        }
Exemple #7
0
 public override void Initialize()
 {
     Cooldown=10000;
         ExecutionType=AbilityExecuteFlags.Buff;
         WaitVars=new WaitLoops(1, 1, true);
         Cost=20;
         Range=0;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckRecastTimer|
                                   AbilityPreCastFlags.CheckEnergy));
         ClusterConditions=new SkillClusterConditions(4d, 10f, 2, false);
         //SingleUnitCondition=new UnitTargetConditions(TargetProperties.CloseDistance);
 }
Exemple #8
0
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
         ClusterConditions=new SkillClusterConditions(6d, 40f, 1, true);
         WaitVars=new WaitLoops(0, 1, true);
         Cost=0;
         Range=40;
         IsRanged=true;
         IsProjectile=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Low;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
 }
Exemple #9
0
        public override void Initialize()
        {
            Cooldown=10000;
                ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.ZigZagPathing;
                WaitVars=new WaitLoops(1, 1, true);
                Range=48;
                UseageType=AbilityUseage.Anywhere;
                IsASpecialMovementPower = true;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckCanCast));

                ClusterConditions=new SkillClusterConditions(5d, 48f, 2, false, minDistance: 15f);

                FcriteriaCombat=() =>
                {
                    return ((Bot.Settings.Class.bTeleportFleeWhenLowHP&&
                             (Bot.Character.Data.dCurrentHealthPct<0.5d)||
                             (Bot.Targeting.Cache.RequiresAvoidance))
                            ||
                            (Bot.Settings.Class.bTeleportIntoGrouping&&LastConditionPassed==ConditionCriteraTypes.Cluster)
                            ||
                            (!Bot.Settings.Class.bTeleportFleeWhenLowHP&&!Bot.Settings.Class.bTeleportIntoGrouping));

                };
                FCombatMovement=v =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (!Bot.Character.Class.bWaitingForSpecial&&Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        return v;
                    }

                    return Vector3.Zero;
                };
                FOutOfCombatMovement=v =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        return v;
                    }

                    return Vector3.Zero;
                };
        }
Exemple #10
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.ClusterTarget;

                WaitVars=new WaitLoops(1, 1, true);
                Cost=30;
                Range=50;
                IsRanged=true;
                IsProjectile=true;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy));
                ClusterConditions=new SkillClusterConditions(10d, 40, 3, true);
        }
Exemple #11
0
        public override void Initialize()
        {
            Cooldown=9000;
                ExecutionType=AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(0, 0, true);
                Range=14;
                UseageType=AbilityUseage.Anywhere;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckCanCast));

                ClusterConditions = new SkillClusterConditions(7d, 20f, 2, false);
                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_20, 1);
                ElitesWithinRangeConditions = new Tuple<RangeIntervals, int>(RangeIntervals.Range_20, 1);
                //SingleUnitCondition=new UnitTargetConditions(TargetProperties.None, 12);
        }
Exemple #12
0
 public override void Initialize()
 {
     Cooldown=200;
         ExecutionType=AbilityExecuteFlags.Self;
         WaitVars=new WaitLoops(4, 4, true);
         Cost=0;
         UseageType=AbilityUseage.Anywhere;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.None, 10,
             falseConditionalFlags: TargetProperties.Fast);
         ClusterConditions=new SkillClusterConditions(5d, 7, 2, false);
         FcriteriaCombat=() => true;
 }
Exemple #13
0
 public override void Initialize()
 {
     Cooldown=10000;
         ExecutionType=AbilityExecuteFlags.Target|AbilityExecuteFlags.ClusterTarget;
         WaitVars=new WaitLoops(1, 1, true);
         Cost=3;
         SecondaryEnergy=true;
         Range=40;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckRecastTimer));
         ClusterConditions=new SkillClusterConditions(4d, 35f, 2, true);
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.RareElite, 40);
 }
Exemple #14
0
 public override void Initialize()
 {
     Cooldown=150;
         ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(1, 2, true);
         Cost=20;
         Range=Bot.Character.Class.HotBar.RuneIndexCache[Power]==0?13:Bot.Character.Class.HotBar.RuneIndexCache[Power]==1?20:16;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));
         ClusterConditions=new SkillClusterConditions(6d, 20f, 2, true);
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial, 20);
         FcriteriaCombat=() => !Bot.Character.Class.bWaitingForSpecial;
 }
Exemple #15
0
 public override void Initialize()
 {
     Cooldown=2000;
         ExecutionType=AbilityExecuteFlags.Buff;
         WaitVars=new WaitLoops(1, 2, true);
         Cost=25;
         Range = 25;
         UseageType=AbilityUseage.Anywhere;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckCanCast));
         ClusterConditions=new SkillClusterConditions(15d, 20f, 2, false, useRadiusDistance: true);
         SingleUnitCondition = new UnitTargetConditions(TargetProperties.CloseDistance | TargetProperties.Weak);
         FcriteriaCombat = () => !Bot.Character.Class.bWaitingForSpecial;
 }
Exemple #16
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(0, 1, true);
                Cost=0;
                Range=50;
                IsRanged=true;
                IsProjectile=true;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Low;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));

                ClusterConditions=new SkillClusterConditions(5d, 49f, 2, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.None, 49);
        }
Exemple #17
0
 public override void Initialize()
 {
     Cooldown=2500;
         ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(1, 2, true);
         Cost=40;
         Range=50;
         IsRanged=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckRecastTimer));
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial);
         ClusterConditions=new SkillClusterConditions(5d, 50f, 2, true);
         FcriteriaCombat=() => !Bot.Character.Class.bWaitingForSpecial;
 }
Exemple #18
0
        public override void Initialize()
        {
            Cooldown=16000;
                ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.ZigZagPathing;
                WaitVars=new WaitLoops(0, 1, true);
                Cost=15;
                Range=35;
                UseageType=AbilityUseage.Combat;
                IsASpecialMovementPower = true;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckCanCast|
                                          AbilityPreCastFlags.CheckEnergy));
                ClusterConditions=new SkillClusterConditions(5d, 48f, 2, false);
                //TestCustomCombatConditionAlways=true,
                FcriteriaCombat=() => ((Bot.Settings.Class.bTeleportFleeWhenLowHP&&Bot.Character.Data.dCurrentHealthPct<0.5d)
                                       ||
                                       (Bot.Settings.Class.bTeleportIntoGrouping&&
                                        Bot.Targeting.Cache.Clusters.AbilityClusterCache(combatClusterCondition).Count > 0 &&
                                        Bot.Targeting.Cache.Clusters.AbilityClusterCache(combatClusterCondition)[0].Midpoint.Distance(
                                            Bot.Character.Data.PointPosition)>15f)
                                       ||(!Bot.Settings.Class.bTeleportFleeWhenLowHP&&!Bot.Settings.Class.bTeleportIntoGrouping));
                FCombatMovement=v =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (!Bot.Character.Class.bWaitingForSpecial&&Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        return v;
                    }

                    return Vector3.Zero;
                };
                FOutOfCombatMovement=v =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        return v;
                    }

                    return Vector3.Zero;
                };
        }
Exemple #19
0
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(0, 1, true);
         Cost=10;
         Range=48;
         IsRanged=true;
         IsProjectile=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy));
         ClusterConditions=new SkillClusterConditions(4d, 40, 2, true);
         FcriteriaCombat = () => (!Bot.Targeting.Cache.CurrentTarget.IsTreasureGoblin &&
                                Bot.Targeting.Cache.CurrentTarget.SNOID!=5208&&Bot.Targeting.Cache.CurrentTarget.SNOID!=5209&&
                                Bot.Targeting.Cache.CurrentTarget.SNOID!=5210);
 }
Exemple #20
0
        public override void Initialize()
        {
            Cooldown=250;
                ExecutionType=AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(1, 1, true);
                Cost=30;
                Range=10;
                Priority=AbilityPriority.Medium;
                UseageType=AbilityUseage.Combat;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckEnergy|AbilityPreCastFlags.CheckCanCast|
                                          AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckPlayerIncapacitated));
                ClusterConditions=new SkillClusterConditions(4d, 18f, 3, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial, 10);

                FcriteriaCombat=() => (!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_SweepingWind)||
                                       (Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.Monk_SweepingWind)&&Bot.Character.Class.HotBar.HasBuff(SNOPower.Monk_SweepingWind)))&&
                                      (!Bot.Character.Class.bWaitingForSpecial||Bot.Character.Data.dCurrentEnergy>=Bot.Character.Class.iWaitingReservedAmount);
        }
Exemple #21
0
        public override void Initialize()
        {
            Cooldown=8000;
                ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.Location;
                ClusterConditions=new SkillClusterConditions(5d, 20f, 1, true, 0.25d);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.None, 21, 0.5d, TargetProperties.DOTDPS);
                WaitVars=new WaitLoops(1, 1, true);
                Cost=196;
                Range=21;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckCanCast|
                                          AbilityPreCastFlags.CheckEnergy|AbilityPreCastFlags.CheckRecastTimer));

                PreCast.Criteria += (s) => !Bot.Character.Class.HotBar.HasDebuff(SNOPower.Succubus_BloodStar);

                IsSpecialAbility=true;
        }
Exemple #22
0
        public override void Initialize()
        {
            Cooldown=200;
                ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.Location;
                WaitVars=new WaitLoops(2, 2, true);
                Cost=Bot.Character.Class.HotBar.RuneIndexCache[SNOPower.Barbarian_SeismicSlam]==3?15:30;
                Range=40;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;

                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                          AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));
                ClusterConditions=new SkillClusterConditions(Bot.Character.Class.HotBar.RuneIndexCache[Power]==4?4d:6d, 40f, 2, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial,
                    falseConditionalFlags: TargetProperties.TreasureGoblin|TargetProperties.Fast);

                FcriteriaCombat=() => !Bot.Character.Class.bWaitingForSpecial;
        }
Exemple #23
0
 public override void Initialize()
 {
     Cooldown=1500;
         ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.Location;
         WaitVars=new WaitLoops(1, 2, true);
         Counter=1;
         Cost=15;
         Range=50;
         IsRanged=true;
         IsProjectile = true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.High;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckPetCount));
         ClusterConditions=new SkillClusterConditions(7d, 50f, 2, true);
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial,
             falseConditionalFlags: TargetProperties.Fast);
 }
Exemple #24
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.Target|AbilityExecuteFlags.ClusterTarget;
                WaitVars=new WaitLoops(0, 0, true);
                Range=(Bot.Character.Class.HotBar.RuneIndexCache[SNOPower.Wizard_Electrocute]==2?15:40);
                IsRanged=true;
                IsProjectile=true;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Low;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));

                //Aim for cluster with 2 units very close together.
                ClusterConditions=new SkillClusterConditions(3d, Bot.Character.Class.HotBar.RuneIndexCache[SNOPower.Wizard_Electrocute]==2?15:40, 2,
                    true);
                //No conditions for a single target.
                SingleUnitCondition=new UnitTargetConditions();
        }
Exemple #25
0
        //42 Channeling Base Cost
        //Level > 55 == 66
        //((Level - 5) / 2) + 42
        //
        //140 Base Cost
        //Level > 55 == 220
        //(((Level - 5) / 2) * 3.2)+140)
        public override void Initialize()
        {
            var range = Bot.Character.Class.HotBar.RuneIndexCache[Power] == 0 ? 40 : Bot.Character.Class.HotBar.RuneIndexCache[Power] == 4 ? 14 : 25;
            //Cost = CastingCost();
            Cooldown = 5;
            ExecutionType = AbilityExecuteFlags.ClusterLocation | AbilityExecuteFlags.Target;
            WaitVars = new WaitLoops(0, 0, true);
            Range = range;
            IsRanged = true;
            IsProjectile = true;
            IsChanneling = true;
            UseageType = AbilityUseage.Combat;
            Priority = AbilityPriority.High;
            PreCast = new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
            SingleUnitCondition = new UnitTargetConditions(TargetProperties.None, range);
            ClusterConditions = new SkillClusterConditions(5d, range, 2, true);

            FcriteriaCombat = () => (Bot.Character.Data.dCurrentEnergy >= CastingCost() || Bot.Character.Data.dCurrentEnergy >= ChannelingCost()&& IsCurrentlyChanneling());
        }
Exemple #26
0
        public override void Initialize()
        {
            Cooldown=150;
                ExecutionType=AbilityExecuteFlags.Location|AbilityExecuteFlags.ClusterLocation;
                WaitVars=new WaitLoops(1, 1, true);
                Cost=50;
                Range=50;
                IsRanged=true;
                IsProjectile=true;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                          AbilityPreCastFlags.CheckRecastTimer));

                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_50, 3);
                ElitesWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_50, 1);
                //SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial,69),
                ClusterConditions=new SkillClusterConditions(4d, 45, 2, true);
        }
Exemple #27
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;

                WaitVars=new WaitLoops(0, 1, true);
                Cost=134;
                Range=15;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;

                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                          AbilityPreCastFlags.CheckCanCast));

                //FcriteriaPreCast=new Func<bool>(() => { return !Bot.Character_.Class.HotBar.HasDebuff(SNOPower.Succubus_BloodStar); });

                ClusterConditions=new SkillClusterConditions(5d, 20f, 2, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.None);
        }
Exemple #28
0
        public override void Initialize()
        {
            Cooldown=15000;
                ExecutionType=AbilityExecuteFlags.ClusterTargetNearest|AbilityExecuteFlags.Target;
                ClusterConditions=new SkillClusterConditions(5d, 20f, 1, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.None, 25,
                    falseConditionalFlags: TargetProperties.DOTDPS);
                WaitVars=new WaitLoops(1, 1, true);
                Cost=108;
                Range=21;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckCanCast|
                                          AbilityPreCastFlags.CheckEnergy));

                PreCast.Criteria += (s) => !Bot.Character.Class.HotBar.HasDebuff(SNOPower.Succubus_BloodStar);

                FcriteriaCombat=() => !Bot.Character.Class.bWaitingForSpecial;
        }
Exemple #29
0
        public override void Initialize()
        {
            Cooldown=10200;
                WaitVars=new WaitLoops(2, 2, true);
                ExecutionType=AbilityExecuteFlags.ClusterLocation|AbilityExecuteFlags.Location;
                Range=35;
                Priority=AbilityPriority.Medium;
                UseageType=AbilityUseage.Combat;
                IsASpecialMovementPower = true;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckRecastTimer|
                                          AbilityPreCastFlags.CheckCanCast));
                ClusterConditions=new SkillClusterConditions(5d, 30, 2, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial,
                    falseConditionalFlags: TargetProperties.Fast, MinimumDistance: 30);

                FCombatMovement=(v) =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (!Bot.Character.Class.bWaitingForSpecial&&Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        else
                            return v;
                    }

                    return Vector3.Zero;
                };
                FOutOfCombatMovement=(v) =>
                {
                    float fDistanceFromTarget=Bot.Character.Data.Position.Distance(v);
                    if (Funky.Difference(Bot.Character.Data.Position.Z, v.Z)<=4&&fDistanceFromTarget>=20f)
                    {
                        if (fDistanceFromTarget>35f)
                            return MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 35f);
                        else
                            return v;
                    }

                    return Vector3.Zero;
                };
        }
Exemple #30
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.ClusterTarget|AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(0, 1, true);
                Cost=10;
                Range=50;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy));

                ClusterConditions=new SkillClusterConditions(4d, 40, 2, true);
                SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial);

                FcriteriaCombat=() =>
                {
                    return ((!Bot.Character.Class.HotBar.HotbarPowers.Contains(SNOPower.DemonHunter_ClusterArrow))||
                            LastUsedMilliseconds>=110000);
                };
        }