示例#1
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_MantraOfHealing_v2_Passive);

                FcriteriaCombat = () => !Bot.Character.Class.HotBar.HasBuff(SNOPower.X1_Monk_MantraOfHealing_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))));
        }
示例#2
0
文件: Sprint.cs 项目: BUFORD/Funky
        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))));
        }
示例#3
0
        public override void Initialize()
        {
            Cooldown=150;
                ExecutionType=AbilityExecuteFlags.ZigZagPathing;
                WaitVars=new WaitLoops(0, 0, true);
                Cost=15;
                IsChanneling=true;
                Range=23;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
                UseageType=AbilityUseage.Anywhere;

                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 2);
                ElitesWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 1);
                SingleUnitCondition=new UnitTargetConditions
                {
                     TrueConditionFlags=TargetProperties.IsSpecial,
                     Distance=30,

                };

                FcriteriaCombat=() =>
                {
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost=Bot.Character.Class.HotBar.RuneIndexCache[Power]==3?8:10;

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

                FCombatMovement=v =>
                {
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost=Bot.Character.Class.HotBar.RuneIndexCache[Power]==3?8:10;

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

                    return Vector3.Zero;
                };

                FOutOfCombatMovement=v =>
                {
                    Vector3 vTargetAimPoint=MathEx.CalculatePointFrom(v, Bot.Character.Data.Position, 10f);
                    bool isChanneling=(IsHobbling||LastUsedMilliseconds<150);
                    int channelingCost=Bot.Character.Class.HotBar.RuneIndexCache[Power]==3?8:10;

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

                    return Vector3.Zero;
                };
        }
示例#4
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;
                };
        }
示例#5
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);
        }
示例#6
0
        public override void Initialize()
        {
            Cooldown=15200;
                ExecutionType=AbilityExecuteFlags.Buff;
                WaitVars=new WaitLoops(0, 0, true);
                Cost=49;
                UseageType=AbilityUseage.Anywhere;
                IsSpecialAbility=true;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckEnergy|AbilityPreCastFlags.CheckCanCast));

                IsBuff=true;
                FcriteriaBuff=() => Bot.Settings.OutOfCombatMovement;

                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;
                };
                FcriteriaCombat=() => (    (Bot.Character.Data.dCurrentHealthPct <= 0.35d) ||
                                           (RuneIndex==3&&Bot.Character.Data.dCurrentEnergyPct<0.25d)||
                                           (Bot.Targeting.Cache.Environment.FleeTriggeringUnits.Count > 0) ||
                                           (Bot.Targeting.Cache.Environment.TriggeringAvoidances.Count > 0) ||
                                           (Bot.Character.Data.bIsIncapacitated || Bot.Character.Data.bIsRooted));
        }
示例#7
0
文件: SpikeTrap.cs 项目: BUFORD/Funky
        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);
        }
示例#8
0
文件: RapidFire.cs 项目: BUFORD/Funky
        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);
                };
        }
示例#9
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;
                };
        }
示例#10
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));
 }
示例#11
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;
        }
示例#12
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);
 }
示例#13
0
 protected SkillCriteria()
 {
     SingleUnitCondition = null;
     ElitesWithinRangeConditions = null;
     UnitsWithinRangeConditions = null;
     ClusterConditions = null;
     TestCustomCombatConditions = false;
     FcriteriaCombat = () => true;
     FcriteriaBuff = () => true;
     PreCast = new SkillPreCast();
 }
示例#14
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);
 }
示例#15
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);
 }
示例#16
0
        public override void Initialize()
        {
            Cooldown=1500;
                ExecutionType=AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(1, 1, true);
                Cost=0;
                UseageType=AbilityUseage.Anywhere;
                Priority=AbilityPriority.Medium;

                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckRecastTimer));
                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_15, 1);
        }
示例#17
0
文件: Familiar.cs 项目: BUFORD/Funky
 public override void Initialize()
 {
     Cooldown=60000;
         ExecutionType=AbilityExecuteFlags.Buff;
         WaitVars=new WaitLoops(1, 2, true);
         Cost=25;
         UseageType=AbilityUseage.Anywhere;
         IsBuff=true;
         Priority=AbilityPriority.High;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckRecastTimer));
 }
示例#18
0
文件: Serenity.cs 项目: BUFORD/Funky
        public override void Initialize()
        {
            Cooldown=20200;
                ExecutionType=AbilityExecuteFlags.Buff;
                WaitVars=new WaitLoops(1, 1, true);
                UseageType=AbilityUseage.Anywhere;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer));

                //TODO:: Give better conditions
                FcriteriaCombat = () => Bot.Character.Data.dCurrentHealthPct <= 0.45d
                                      &&Bot.Targeting.Cache.Environment.iAnythingWithinRange[(int)RangeIntervals.Range_20]>0;
        }
示例#19
0
文件: Revenge.cs 项目: BUFORD/Funky
        public override void Initialize()
        {
            Cooldown=600;
                ExecutionType=AbilityExecuteFlags.Self;
                WaitVars=new WaitLoops(4, 4, true);
                Cost=0;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Medium;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                          AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));

                UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_6, 1);
        }
示例#20
0
 public override void Initialize()
 {
     Cooldown = 100000;
     ExecutionType = AbilityExecuteFlags.Buff;
     WaitVars = new WaitLoops(1, 1, true);
     Cost = 20;
     IsBuff = true;
     UseageType = AbilityUseage.Anywhere;
     Priority = AbilityPriority.Low;
     PreCast = new SkillPreCast(AbilityPreCastFlags.CheckExisitingBuff | AbilityPreCastFlags.CheckEnergy | AbilityPreCastFlags.CheckPlayerIncapacitated | AbilityPreCastFlags.CheckCanCast);
     FcriteriaBuff = () => true;
     FcriteriaBuff = () => LastUsedMilliseconds > 30000;
 }
示例#21
0
 public override void Initialize()
 {
     Cooldown=120500;
         ExecutionType=AbilityExecuteFlags.Buff;
         WaitVars=new WaitLoops(4, 4, true);
         Cost=50;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.High;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));
         //ElitesWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_25, 1);
         //SingleUnitCondition=new UnitTargetConditions(TargetProperties.IsSpecial, 25);
 }
示例#22
0
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(0, 1, true);
         Cost=10;
         Range=44;
         IsRanged=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Low;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckEnergy|
                                   AbilityPreCastFlags.CheckCanCast|AbilityPreCastFlags.CheckPlayerIncapacitated));
 }
示例#23
0
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(0, 0, true);
         Cost=35;
         Range=48;
         IsRanged=true;
         IsProjectile=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy));
 }
示例#24
0
文件: Strafe.cs 项目: BUFORD/Funky
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.ZigZagPathing;
         WaitVars=new WaitLoops(0, 0, true);
         Cost=15;
         Range=25;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Medium;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckEnergy));
         UnitsWithinRangeConditions=new Tuple<RangeIntervals, int>(RangeIntervals.Range_15, 2);
         //SingleUnitCondition = new UnitTargetConditions(TargetProperties.None, 15);
 }
示例#25
0
        public override void Initialize()
        {
            Cooldown=30000;
                ExecutionType=AbilityExecuteFlags.None;
                WaitVars=new WaitLoops(3, 3, true);
                Priority=AbilityPriority.High;

                UseageType=AbilityUseage.Anywhere;
                PreCast=new SkillPreCast(AbilityPreCastFlags.CheckPlayerIncapacitated|AbilityPreCastFlags.CheckRecastTimer);

                //Important!! We have to override the default return of true.. we dont want this to fire as a combat Ability.
                FcriteriaCombat=() => { return Bot.Character.Data.dCurrentHealthPct<=Bot.Settings.Combat.PotionHealthPercent; };
        }
示例#26
0
 public override void Initialize()
 {
     Cooldown=5;
         ExecutionType=AbilityExecuteFlags.Target;
         WaitVars=new WaitLoops(0, 0, false);
         Range=48;
         IsRanged=true;
         IsChanneling=true;
         UseageType=AbilityUseage.Combat;
         Priority=AbilityPriority.Low;
         PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
         SingleUnitCondition=new UnitTargetConditions(TargetProperties.None);
 }
示例#27
0
        public override void Initialize()
        {
            Cooldown=30200;
                ExecutionType=AbilityExecuteFlags.Buff;
                WaitVars=new WaitLoops(0, 0, true);
                Cost=0;
                UseageType=AbilityUseage.Anywhere;
                IsSpecialAbility=true;
                Priority=AbilityPriority.High;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckRecastTimer|AbilityPreCastFlags.CheckCanCast));

                FcriteriaCombat=() => Bot.Character.Data.dCurrentHealthPct<=0.45;
        }
示例#28
0
        public override void Initialize()
        {
            Cooldown=5;
                ExecutionType=AbilityExecuteFlags.Target;
                WaitVars=new WaitLoops(0, 1, true);
                Range=Bot.Character.Class.HotBar.RuneIndexCache[SNOPower.Wizard_ShockPulse]==2?40
                    :Bot.Character.Class.HotBar.RuneIndexCache[SNOPower.Wizard_ShockPulse]==1?26:15;

                IsRanged=true;
                IsProjectile=true;
                UseageType=AbilityUseage.Combat;
                Priority=AbilityPriority.Low;
                PreCast=new SkillPreCast((AbilityPreCastFlags.CheckPlayerIncapacitated));
        }
示例#29
0
文件: Grenades.cs 项目: BUFORD/Funky
 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));
 }
示例#30
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);
        }