public CatFormPowerShiftAbility() : base(WoWSpell.FromId(SpellBook.CatForm)) { Category = AbilityCategory.Buff; // No conditions. }
public Premed() : base(WoWSpell.FromId(SpellBook.CastPremed), true, true) { Category = AbilityCategory.Combat; Conditions.Add(new BooleanCondition(Me.ComboPoints <= 4)); Conditions.Add(new ImStealthedCondition()); }
public HealingTouchMyAllyAbility() : base(WoWSpell.FromId(SpellBook.HealingTouch)) { Category = AbilityCategory.Heal; RequiredConditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.Prowl)); }
public static async Task <bool> CastGroundOnMe(int Spell, System.Windows.Media.Color newColor, bool reqs = true, string addLog = "") { foreach (var item in GroundSpellBlacklist) { if (item.SpellId == Spell && item.IsBlacklisted()) { return(false); } } if (!reqs) { return(false); } //L.combatLog("Trying to cast: " + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) ? "" : " - " + addLog)); if (!SpellManager.CanCast(WoWSpell.FromId(Spell))) { return(false); } if (await GCD(Spell, newColor, true, "CastGround") && !await Coroutine.Wait(1000, () => Me.CurrentPendingCursorSpell != null)) { AddSpellToBlacklist(Spell); L.diagnosticsLog("No Cursor Detected"); return(false); } lastSpellCast = Spell; if (SpellManager.ClickRemoteLocation(Me.Location) == false) { AddSpellToBlacklist(Spell); } await CommonCoroutines.SleepForLagDuration(); return(true); }
/// <summary> /// Specifies the current target when casting spell and sleeps for lag /// </summary> /// <param name="Spell"></param> /// <param name="reqs"></param> /// <returns></returns> public async Task <bool> Cast(int Spell, Color newColor, bool reqs = true) { if (!CurrentTarget.IsValidCombatUnit()) { return(false); } if (!reqs) { //L.combatLog("Trying to cast: " + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) ? "" : " - " + addLog)); return(false); } if (!SpellManager.CanCast(WoWSpell.FromId(Spell), CurrentTarget, false, false, false)) //Should we check for if out currentTarget is moving? *Second false { return(false); } if (!SpellManager.Cast(Spell, CurrentTarget)) { return(false); } //lastSpellCast = Spell; combatLog("^" + WoWSpell.FromId(Spell).Name, newColor); await CommonCoroutines.SleepForLagDuration(); return(true); }
protected override void OnBeforeAction(ActionBase action) { if (WoWParty.NumPartyMembers > 0 && HelpfulTarget.IsValid && HelpfulTarget.HealthPercentage > 60) { var tank = HelpfulTargets.OrderByDescending(m => m.MaxHealth).First() ?? WoWPlayer.Invalid; if (tank.IsValid && !tank.IsDead && tank.Distance < Globals.MaxDistance) { var beacon = WoWSpell.GetSpell("Beacon of Light"); if (beacon.IsValid && beacon.IsReady && !tank.Auras["Beacon of Light"].IsValid) { Log.WriteLine("Casting {0} on {1}", beacon.Name, tank.Name); beacon.Cast(tank); Sleep(Globals.SpellWait); } } } if (action != null) { var aw = WoWSpell.GetSpell("Avenging Wrath"); if (aw.IsValid && aw.IsReady) { Log.WriteLine("Popping {0}", aw.Name); aw.Cast(); Sleep(Globals.SpellWait); } } }
static public Composite Cast(int spellId, CanRunDecoratorDelegate cond, WoWUnitDelegate target) { return(new Decorator(ret => target != null && cond(ret) && CanCast(spellId), new Action(ret => { SpellManager.Cast(spellId, target(ret)); Logging.Write(LogLevel.Diagnostic, Colors.White, "" + WoWSpell.FromId(spellId).Name); string temp; if (target(ret).IsPlayer) { temp = "Casting " + WoWSpell.FromId(spellId).Name + " on Player at " + Math.Round(target(ret).HealthPercent, 0) + " with " + Helpers.Rogue.me.ComboPoints + "CP and " + Rogue.mCurrentEnergy + " energy"; } else { temp = "Casting " + WoWSpell.FromId(spellId).Name + " on " + target(ret).Name + " at " + Math.Round(target(ret).HealthPercent, 0) + " with " + Helpers.Rogue.me.ComboPoints + "CP and " + Rogue.mCurrentEnergy + " energy"; } Logging.Write(LogLevel.Normal, temp); } ) )); }
public override async Task <bool> CastOnTarget(WoWUnit target) { Conditions.Clear(); if (MustWaitForGlobalCooldown) { Conditions.Add(new IsOffGlobalCooldownCondition()); } if (MustWaitForSpellCooldown) { Conditions.Add(new SpellIsNotOnCooldownCondition(Spell)); } Conditions.Add(new BooleanCondition(SettingsManager.Instance.UseShadowReflection)); Conditions.Add(new BooleanCondition(target != null)); Conditions.Add(new InMeeleRangeCondition(target)); Conditions.Add(new ConditionSwitchTester( new BooleanCondition(Me.Specialization == Styx.WoWSpec.RogueSubtlety), new ConditionAndList( new CoolDownLeftMaxCondition(WoWSpell.FromId(SpellBook.AuraShadowDance), System.TimeSpan.FromSeconds(1)), new TargetAuraUpCondition(Me, WoWSpell.FromId(SpellBook.CastSliceNDice))), // <-- If in Subtlety Specc new ConditionSwitchTester( new BooleanCondition(Me.Specialization == Styx.WoWSpec.RogueAssassination), new TargetAuraUpCondition(target, WoWSpell.FromId(SpellBook.CastRupture)) // <-- If in AssaSpecc ) // Add Combat here )); Conditions.Add(new ConditionSwitchTester( new BooleanCondition(SettingsManager.Instance.ShadowReflectionOnlyOnBoss), new OnlyOnBossCondition())); return(await base.CastOnTarget(target)); }
private int GetMaxRepeat(WoWSpell recipe) { int maxRepeat = int.MaxValue; var spellReagents = recipe.InternalInfo.SpellReagents; if (!spellReagents.HasValue) { return(maxRepeat); } for (int index = 0; index < spellReagents.Value.Reagent.Length; index++) { var reagent = spellReagents.Value.Reagent[index]; if (reagent == 0) { continue; } var required = spellReagents.Value.ReagentCount[index]; if (required <= 0) { continue; } var numInBags = StyxWoW.Me.BagItems.Sum(i => i != null && i.IsValid && i.Entry == reagent ? i.StackCount : 0); var repeatNum = (int)(numInBags / required); if (repeatNum < maxRepeat) { maxRepeat = repeatNum; } } return(maxRepeat); }
public override void OnStart() { var skillLine = (SkillLine)TradeSkillId; if (!Enum.GetValues(typeof(SkillLine)).Cast <SkillLine>().Contains(skillLine)) { QBCLog.ProfileError("TradeSkillId {0} is not a valid tradeskill Id.", TradeSkillId); } // special case for Runeforging since it's not considered a profession. _recipeSpell = skillLine == SkillLine.Runeforging ? WoWSpell.FromId(TradeSkillItemId) : GetRecipeSpell(TradeSkillItemId); if (_recipeSpell == null || !_recipeSpell.IsValid) { QBCLog.ProfileError("TradeSkillItemId {0} is not a valid Item or Spell Id.", TradeSkillId); } // This reports problems, and stops BT processing if there was a problem with attributes... // We had to defer this action, as the 'profile line number' is not available during the element's // constructor call. OnStart_HandleAttributeProblem(); // If the quest is complete, this behavior is already done... // So we don't want to falsely inform the user of things that will be skipped. if (!IsDone) { this.UpdateGoalText(QuestId); } }
public WrathAbility() : base(WoWSpell.FromId(SpellBook.Wrath)) { Conditions.Add(new MeHasAttackableTargetCondition()); Conditions.Add(new MeIsFacingTargetCondition()); Conditions.Add(new MyTargetDistanceCondition(0, 38)); }
private void update() { var spellId = spellid_input.Value; var spellname = spellname_txt.Text; CurrentEclipse_lbl.Text = StyxWoW.Me.CurrentEclipse.ToString(CultureInfo.InvariantCulture); ChanneledSpellID_lbl.Text = StyxWoW.Me.ChanneledCastingSpellId.ToString(CultureInfo.InvariantCulture); WoWSpell spell; SpellManager.Spells.TryGetValue(spellname, out spell); // Fishing for KeyNotFoundException's yay! if (spell != null) { spellId = spell.Id; } WoWSpell test = WoWSpell.FromId((int)spellId); // populate values if (test != null) { spellid_lbl.Text = test.Id.ToString(CultureInfo.InvariantCulture); smHasSpell_lbl.Text = SpellManager.HasSpell(test).ToString(CultureInfo.InvariantCulture); smCanCast_lbl.Text = SpellManager.CanCast(test).ToString(CultureInfo.InvariantCulture); spellname_lbl.Text = test.Name; spellCancast_lbl.Text = test.CanCast.ToString(CultureInfo.InvariantCulture); smIsValid_lbl.Text = test.IsValid.ToString(CultureInfo.InvariantCulture); smCooldownTimeLeftid_lbl.Text = test.CooldownTimeLeft.ToString(); smCooldownid_lbl.Text = test.Cooldown.ToString(CultureInfo.InvariantCulture); smCooldownTimeLeft_lbl.Text = SpellManager.Spells[spellname].CooldownTimeLeft.ToString(); } }
private static void CastDeathgate() { if (s_Me.IsCasting || s_Me.IsChanneling || s_Me.IsMoving) { return; } var deathGateRemainingCooldown = WoWSpell.FromId(DeathgateId).CooldownTimeLeft.Seconds; if (!WoWSpell.FromId(DeathgateId).Cooldown) { if (!SpellManager.CanCast(DeathgateId)) { return; } SpellManager.Cast(DeathgateId); } else { if (deathGateRemainingCooldown > 0 && deathGateRemainingCooldown < 45) { QBCLog.Info("Waiting for Death Gate to get off cooldown. {0} seconds remaining.", deathGateRemainingCooldown); } } }
public StealthAbility() : base(WoWSpell.FromId(SpellBook.CastStealth), true, true) { base.Category = AbilityCategory.Buff; base.Conditions.Add(new TargetNotAuraUpCondition(Me, WoWSpell.FromId(SpellBook.AuraStealth))); base.Conditions.Add(new ImNotStealthedCondition()); base.Conditions.Add(new BooleanCondition(SettingsManager.Instance.AlwaysStealth)); }
public RacialsBloodElfAbility() : base(WoWSpell.FromId(SpellBook.RacialBloodElfArcaneTorrent), false, true) { base.Category = AbilityCategory.Buff; base.Conditions.Add(new BooleanCondition(SettingsManager.Instance.UseBloodElfRacial)); base.Conditions.Add(new IsRaceCondition(WoWRace.BloodElf)); }
private static async Task <bool> UseRacialToClearLoC() { if (Main.Debug) { Log.Diagnostics("In UseRacialToClearLoc() call"); } if (!_locDelay.IsRunning) { _locDelay.Start(); return(false); } if (_locDelay.ElapsedMilliseconds > SettingsManager.Instance.LoCDelay) { if (WoWSpell.FromId(SpellBook.RacialHumanEveryManForHimself).CooldownTimeLeft.TotalMilliseconds == 0) { if (await Abilities.Cast <Shared.Racials.RacialHumanAbility>(Me)) { _locDelay.Reset(); return(true); } } else { Log.Diagnostics("Human Racial is on Cooldown."); } return(true); } return(true); }
public static bool Cast2(int Spell, System.Windows.Media.Color newColor, bool reqs = true, string addLog = "", bool sleep = true) { //if (Spell == Helpers.Spell_Book.Glide) //{ // L.debugLog("Glide: " + reqs.ToString()); //} if (!currentTarget.IsValidCombatUnit()) { return(false); } if (!reqs) { //L.combatLog("Trying to cast: " + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) ? "" : " - " + addLog)); return(false); } if (!SpellManager.CanCast(WoWSpell.FromId(Spell), currentTarget, false, false, false)) //Should we check for if out currentTarget is moving? *Second false { return(false); } if (!SpellManager.Cast(Spell, currentTarget)) { return(false); } lastSpellCast = Spell; L.combatLog("^" + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) || !GeneralSettings.Instance.GeneralDebug ? "" : " - " + addLog), newColor); return(true); }
/// <summary>Returns a summoned pet</summary> /// <param name="nameID">the id of the spell</param> /// <param name="cond">The conditions that must be true</param> /// <param name="label">A descriptive label for the clients GUI logging output</param> /// <returns>The cast pet summon spell.</returns> public static Composite CastPetSummonSpell(int nameID, CanRunDecoratorDelegate cond, string label) { WoWSpell summonPet = WoWSpell.FromId(nameID); if (summonPet.CastTime > 0) { Spell.KnownChanneledSpells.Add(summonPet.Name); } return(new Decorator( delegate(object a) { if (!cond(a)) { return false; } if (!Spell.CanCast(summonPet.ToString())) { return false; } return true; }, new Decorator(ret => !Me.GotAlivePet && PetTimer.IsFinished, new Sequence( new Action(a => CLULogger.Log(" {0}", label)), new Action(a => SpellManager.Cast(summonPet)), Spell.CreateWaitForLagDuration(), new Wait(5, a => Me.GotAlivePet || !Me.IsCasting, new PrioritySelector( new Decorator(a => StyxWoW.Me.IsCasting, new Action(ret => SpellManager.StopCasting())), new ActionAlwaysSucceed())))))); }
public static async Task <bool> CastOnGround(int spell, WoWUnit unit, bool reqs) { var sp = WoWSpell.FromId(spell); var sname = sp != null ? sp.Name : "#" + spell; if (!reqs || !SpellManager.CanCast(spell) || unit == null) { return(false); } var onLocation = unit.Location; if (!SpellManager.Cast(spell)) { return(false); } if (!await Coroutine.Wait(1000, () => StyxWoW.Me.CurrentPendingCursorSpell != null)) { Logging.Write(Colors.DarkRed, "Cursor Spell Didn't happen"); return(false); } SpellManager.ClickRemoteLocation(onLocation); Log.WritetoFile(LogLevel.Diagnostic, String.Format("Casting {0}", sname)); await CommonCoroutines.SleepForLagDuration(); return(true); }
public ForceOfNatureAbility() : base(WoWSpell.FromId(SpellBook.ForceOfNature), true, true) { RequiredConditions.Add(new MeHasAttackableTargetCondition()); RequiredConditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.Prowl)); RequiredConditions.Add(new MyTargetDistanceCondition(0, 10)); }
/// <summary> /// Does not specify a target when casting a spell and sleeps for lag /// </summary> /// <param name="Spell">The spell you wish to cast.</param> /// <param name="reqs">The requirements to cast the spell.</param> /// <returns></returns> public static async Task <bool> GCD(int Spell, System.Windows.Media.Color newColor, bool reqs = true, string addLog = "", bool sleep = true) { if (!reqs) { //L.combatLog("Trying to cast: " + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) ? "" : " - " + addLog)); return(false); } //if (SpellManager.GlobalCooldown || !SpellManager.CanCast(Spell)) // return false; if (OnCooldown(Spell)) { return(false); } if (!SpellManager.Cast(Spell)) { return(false); } lastSpellCast = Spell; L.combatLog("*" + WoWSpell.FromId(Spell).Name + (String.IsNullOrEmpty(addLog) || !GeneralSettings.Instance.GeneralDebug ? "" : " - " + addLog), newColor); if (sleep) { await CommonCoroutines.SleepForLagDuration(); } else { await Coroutine.Yield(); } return(true); }
public static async Task <bool> CoCast(int spell, WoWUnit unit, bool reqs, bool cancel) { var sp = WoWSpell.FromId(spell); var sname = sp != null ? sp.Name : "#" + spell; if (unit == null || !reqs || !SpellManager.CanCast(spell, unit, true)) { return(false); } if (!SpellManager.Cast(spell, unit)) { return(false); } if (!await Coroutine.Wait(GetSpellCastTime(sname), () => cancel) && GetSpellCastTime(sname).TotalSeconds > 0) { SpellManager.StopCasting(); Log.WriteLog("Canceling " + sname + "."); return(false); } await CommonCoroutines.SleepForLagDuration(); return(true); }
/// <summary> /// <para>The default declaration defines an instant use ability that is on the GCD</para> /// <para>mustWaitForGlobalCooldown = true</para> /// <para>mustWaitForSpellCooldown = false</para> /// </summary> public AbilityBase(WoWSpell spell, bool mustWaitForGlobalCooldown = true, bool mustWaitForSpellCooldown = false) { this.Category = AbilityCategory.Normal; this.DrCategory = DrCategory.None; if (spell == null) { throw new AbilityException("Spell cannot be null"); } this.Spell = spell; MustWaitForGlobalCooldown = mustWaitForGlobalCooldown; MustWaitForSpellCooldown = mustWaitForSpellCooldown; this.Conditions = new List <ICondition>(); if (MustWaitForGlobalCooldown) { this.Conditions.Add(new IsOffGlobalCooldownCondition()); } if (MustWaitForSpellCooldown) { this.Conditions.Add(new SpellIsNotOnCooldownCondition(this.Spell)); } if (Category == AbilityCategory.Combat) { this.Conditions.Add(new InMeeleRangeCondition()); } }
public static void Pulse() { // Loop threw each of our foreach (KeyValuePair <String, WoWAura> entry in StyxWoW.Me.ActiveAuras) { // Create our spell that is on us so we can use it WoWSpell Spell = WoWSpell.FromId(entry.Value.SpellId); // Anything Blacklisted contine; if (lIgnore.Contains(Spell.Name)) { continue; } // if theres something we need to trinket, lets do it if (lTrinket.Contains(Spell.Mechanic) || lBlacklist.Contains(Spell.Name)) { if (entry.Value.TimeLeft.Seconds >= 3) { Log.WriteDebug("Trinketing - Name: {0} Timeleft: {1}", Spell.Name, entry.Value.TimeLeft); UseTrinket(); } } } }
public CatFormAbility() : base(WoWSpell.FromId(SpellBook.CatForm)) { Category = AbilityCategory.Buff; RequiredConditions.Add(new MeIsNotInCatFormCondition()); }
public override async Task <bool> CastOnTarget(WoWUnit target) { Conditions.Clear(); if (MustWaitForGlobalCooldown) { Conditions.Add(new IsOffGlobalCooldownCondition()); } if (MustWaitForSpellCooldown) { Conditions.Add(new SpellIsNotOnCooldownCondition(Spell)); } Conditions.Add(new BooleanCondition(target != null)); Conditions.Add(new InMeeleRangeCondition(target)); Conditions.Add(Energy); Conditions.Add(new ConditionOrList( new TargetIsInHealthRangeCondition(target, 0, 35), new ConditionAndList( new TargetAuraUpCondition(Me, WoWSpell.FromId(SpellBook.AuraBlindside)), new ConditionOrList( new TargetAuraUpCondition(Me, WoWSpell.FromId(SpellBook.CastEnvenom)), new AuraMaxRemaningTimeCondition(TimeSpan.FromSeconds(1), WoWSpell.FromId(SpellBook.AuraBlindside), Me)) ))); Conditions.Add(new ConditionSwitchTester( new BooleanCondition(SettingsManager.Instance.T184PEnabled), new WillNotCapComboPointsCondition(3), new WillNotCapComboPointsCondition(1))); return(await base.CastOnTarget(target)); }
public WarStompAbility() : base(WoWSpell.FromId(SpellBook.TaurenRacialWarStomp), true, true) { RequiredConditions.Add(new MeHasAttackableTargetCondition()); RequiredConditions.Add(new MeIsFacingTargetCondition()); RequiredConditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.Prowl)); }
public override async Task <bool> CastOnTarget(WoWUnit target) { Conditions.Clear(); if (MustWaitForGlobalCooldown) { Conditions.Add(new IsOffGlobalCooldownCondition()); } if (MustWaitForSpellCooldown) { Conditions.Add(new SpellIsNotOnCooldownCondition(Spell)); } Conditions.Add(new BooleanCondition(target != null)); Conditions.Add(new InMeeleRangeCondition(target)); Conditions.Add(new BooleanCondition(Me.AuraStacks(SpellBook.AuraAnticipation) <= 1)); Conditions.Add(new ConditionSwitchTester( new BooleanCondition(SettingsManager.Instance.OffensiveVanishOnlyOnBoss), new OnlyOnBossCondition())); Conditions.Add(new BooleanCondition(SettingsManager.Instance.UseVanish)); // t18 bonus! add if you got t18 Conditions.Add(new ConditionSwitchTester( new BooleanCondition(SettingsManager.Instance.T184PEnabled), new ConditionAndList( new TargetNotAuraUpCondition(Me, WoWSpell.FromId(SpellBook.AuraDeathlyShadows)), new ConditionOrList( new CoolDownLeftMaxCondition(WoWSpell.FromId(SpellBook.AuraShadowDance), System.TimeSpan.FromSeconds(1)), new CoolDownLeftMinCondition(WoWSpell.FromId(SpellBook.AuraShadowDance), System.TimeSpan.FromSeconds(7)))), new ConditionAndList( new ImNotStealthedCondition(), new TargetNotAuraUpCondition(target, WoWSpell.FromId(SpellBook.AuraFindWeakness))))); return(await base.CastOnTarget(target)); }
public RacialOrcBloodFuryAbility() : base(WoWSpell.FromId(SpellBook.RacialOrcBloodFury), false, true) { base.Category = AbilityCategory.Buff; base.Conditions.Add(new BooleanCondition(SettingsManager.Instance.UseOrcRacial)); base.Conditions.Add(new IsRaceCondition(WoWRace.Orc)); }
public SavageRoarAbility() : base(WoWSpell.FromId(SpellBook.SavageRoar)) { Category = AbilityCategory.Buff; RequiredConditions.Add(new MeIsInCatFormCondition()); }
protected MeleeFeralAbilityBase(WoWSpell spell, bool savageRoarCheck) : base(spell) { SavageRoarCheck = savageRoarCheck; RequiredConditions.Add(new MeHasAttackableTargetCondition()); RequiredConditions.Add(new MeIsFacingTargetCondition()); RequiredConditions.Add(new MeIsInCatFormCondition()); RequiredConditions.Add(new MyTargetIsWithinMeleeRangeCondition()); }
/// <summary> /// Returns true if the movement imparing effects are breakable via a usable spell /// </summary> /// <param name="spell">The spell to check for</param> /// <returns>True if we should use the spell</returns> private static bool freeMeSpellUsage(WoWSpell spell) { if (spell != null) { switch (spell.Name) { case "Berserker Rage": return StyxWoW.Me.GetAllAuras().Any(a => a.Spell.Mechanic == WoWSpellMechanic.Fleeing || a.Spell.Mechanic == WoWSpellMechanic.Sapped || a.Spell.Mechanic == WoWSpellMechanic.Incapacitated); default: return false; } } return false; }
/// <summary> /// <para>The default declaration defines an instant use ability that is on the GCD</para> /// <para>mustWaitForGlobalCooldown = true</para> /// <para>mustWaitForSpellCooldown = false</para> /// </summary> protected AbilityBase(WoWSpell spell, bool mustWaitForGlobalCooldown = true, bool mustWaitForSpellCooldown = false) { Category = AbilityCategory.Normal; if (spell == null) throw new AbilityException("Spell cannot be null"); Spell = spell; MustWaitForGlobalCooldown = mustWaitForGlobalCooldown; MustWaitForSpellCooldown = mustWaitForSpellCooldown; Conditions = new List<ICondition>(); RequiredConditions = new List<ICondition>(); }
/// <summary> /// <para>The default declaration defines an instant use ability that is on the GCD</para> /// <para>mustWaitForGlobalCooldown = true</para> /// <para>mustWaitForSpellCooldown = false</para> /// </summary> public AbilityBase(WoWSpell spell, bool mustWaitForGlobalCooldown = true, bool mustWaitForSpellCooldown = false) { this.Category = AbilityCategory.Normal; this.DrCategory = DrCategory.None; if (spell == null) throw new AbilityException("Spell cannot be null"); this.Spell = spell; MustWaitForGlobalCooldown = mustWaitForGlobalCooldown; MustWaitForSpellCooldown = mustWaitForSpellCooldown; this.Conditions = new List<ICondition>(); if (MustWaitForGlobalCooldown) this.Conditions.Add(new IsOffGlobalCooldownCondition()); if (MustWaitForSpellCooldown) this.Conditions.Add(new SpellIsNotOnCooldownCondition(this.Spell)); if(Category == AbilityCategory.Combat) this.Conditions.Add(new InMeeleRangeCondition()); }
/// <summary> /// Returns true if the racials conditions are met /// </summary> /// <param name="racial">the racial to check for</param> /// <returns>true if we can use the racial</returns> private static bool RacialUsageSatisfied(WoWSpell racial) { if (racial != null) { switch (racial.Name) { case "Stoneform": return StyxWoW.Me.GetAllAuras().Any(a => a.Spell.Mechanic == WoWSpellMechanic.Bleeding || a.Spell.DispelType == WoWDispelType.Disease || a.Spell.DispelType == WoWDispelType.Poison); case "Escape Artist": return StyxWoW.Me.Rooted; case "Every Man for Himself": return Unit.UnitIsControlled(StyxWoW.Me,false); case "Shadowmeld": return false; case "Gift of the Naaru": return StyxWoW.Me.HealthPercent <= 80; case "Darkflight": return false; case "Blood Fury": return true; case "War Stomp": return false; case "Berserking": return true; case "Will of the Forsaken": return Unit.UnitIsControlled(StyxWoW.Me, false); case "Cannibalize": return false; case "Arcane Torrent": return StyxWoW.Me.ManaPercent < 91 && StyxWoW.Me.Class != WoWClass.DeathKnight; case "Rocket Barrage": return true; default: return false; } } return false; }
/// <summary> /// checked if the spell has an instant cast, the spell is one which can be cast while moving, or we have an aura active which allows moving without interrupting casting. /// does not check whether you are presently moving, only whether you could cast if you are moving /// </summary> /// <param name="spell">spell to cast</param> /// <returns>true if spell can be cast while moving, false if it cannot</returns> private static bool AllowMovingWhileCasting(WoWSpell spell) { // quick return for instant spells if (spell.IsInstantCast() && !spell.IsChanneled) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "MoveWhileCasting[{0}]: true, since instant cast and not a funnel spell", spell.Name ); return true; } // assume we cant move, but check for class specific buffs which allow movement while casting bool allowMovingWhileCasting = false; if (Me.Class == WoWClass.Shaman) allowMovingWhileCasting = spell.Name == "Lightning Bolt"; else if (TalentManager.CurrentSpec == WoWSpec.MageFire) allowMovingWhileCasting = spell.Name == "Scorch"; else if (Me.Class == WoWClass.Hunter) allowMovingWhileCasting = spell.Name == "Steady Shot" || (spell.Name == "Aimed Shot" && TalentManager.HasGlyph("Aimed Shot")) || spell.Name == "Cobra Shot"; else if (Me.Class == WoWClass.Warlock) allowMovingWhileCasting = (spell.Name == "Incinerate" || spell.Name == "Malefic Grasp" || spell.Name == "Shadow Bolt") && ClassSpecific.Warlock.Common.HasTalent(ClassSpecific.Warlock.WarlockTalents.KiljaedensCunning); // if (!allowMovingWhileCasting && Me.ZoneId == 5723) // allowMovingWhileCasting = Me.HasAura("Molten Feather"); if (!allowMovingWhileCasting) { allowMovingWhileCasting = HaveAllowMovingWhileCastingAura(spell); // we will atleast check spell cooldown... we may still end up wasting buff, but this reduces the chance if (!allowMovingWhileCasting && spell.CooldownTimeLeft == TimeSpan.Zero ) { bool castSuccess = CastBuffToAllowCastingWhileMoving(); if (castSuccess) allowMovingWhileCasting = HaveAllowMovingWhileCastingAura(); } } return allowMovingWhileCasting; }
/// <summary> /// <para>Defines an instant use ability that is on the GCD</para> /// <para>mustWaitForGlobalCooldown = true</para> /// <para>mustWaitForSpellCooldown = false</para> /// </summary> public PandemicAbilityBase(WoWSpell spell, bool mustWaitForGlobalCooldown = true, bool mustWaitForSpellCooldown = false) : base(spell, mustWaitForGlobalCooldown, mustWaitForSpellCooldown) { PandemicConditions = new List<ICondition>(); }
public MeDoesNotKnowSpellCondition(WoWSpell spell) { Spell = spell; }
public static bool CanCastHackHaveEnoughPower(WoWSpell spell, WoWUnit unit) { #if USE_LUA_POWERCHECK string usablecmd = string.Format("return IsUsableSpell(\"{0}\")", spell.Name); List<string> ret = Lua.GetReturnValues(usablecmd); if ( ret == null || !ret.Any()) { if (SingularSettings.DebugSpellCanCast) Logger.WriteFile( "CanCast[{0}]: IsUsable check failed with null", spell.Name); return false; } if (ret[0] != "1") { if (SingularSettings.DebugSpellCanCast) { uint currentPower = Me.CurrentPower; string ptype = Me.PowerType.ToString(); if (Me.Class == WoWClass.Druid) { if (Me.Shapeshift == ShapeshiftForm.Cat || Me.Shapeshift == ShapeshiftForm.Bear || Me.Shapeshift == ShapeshiftForm.DireBear) { if (Me.HealingSpellIds.Contains(spell.Id)) { ptype = "Mana"; currentPower = Me.CurrentMana; } else if (spell.PowerCost >= 100) { ptype = "Mana"; currentPower = Me.CurrentMana; } } } if (ret.Count() > 1 && ret[1] == "1") Logger.WriteFile( "CanCast[{0}]: insufficient power ({1} cost={2} have={3})", spell.Name, ptype, spell.PowerCost, currentPower); else Logger.WriteFile( "CanCast[{0}]: not usable atm ({1} cost={2} have={3})", spell.Name, ptype, spell.PowerCost, currentPower); } return false; } #elif PRE_WOD bool formSwitch = false; uint currentPower = Me.CurrentPower; if (Me.Class == WoWClass.Druid) { if (Me.Shapeshift == ShapeshiftForm.Cat || Me.Shapeshift == ShapeshiftForm.Bear || Me.Shapeshift == ShapeshiftForm.DireBear) { if (spell.IsHeal()) { formSwitch = true; currentPower = Me.CurrentMana; } else if (spell.PowerCost >= 100) { formSwitch = true; currentPower = Me.CurrentMana; } } } if (currentPower < (uint)spell.PowerCost) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: insufficient power (need {1:F0}, have {2:F0} {3})", spell.Name, spell.PowerCost, currentPower, formSwitch ? "Mana in Form" : Me.PowerType.ToString()); return false; } #else if (!spell.CanCast) { return false; } #endif return true; }
/// <summary> /// Safe spell casting. Wait for it to be done or if anything wrong happened return failed. /// </summary> /// <param name="spell"></param> /// <returns></returns> internal static async Task<ActionResult> CastSpell(WoWSpell spell) { if (Me.Mounted) { await CommonCoroutines.Dismount("Dismounting to cast " + spell.Name + "."); await CommonCoroutines.SleepForLagDuration(); } if (Me.IsMoving) { WoWMovement.MoveStop(); await CommonCoroutines.SleepForLagDuration(); } if (Me.IsCasting) { GarrisonButler.Diagnostic("Error casting {0}, already casting at the moment.", spell.Name); return ActionResult.Failed; } try { spell.Cast(); await CommonCoroutines.SleepForLagDuration(); var timeOutLimit = (int) spell.CastTime + 10000; if (!await Buddy.Coroutines.Coroutine.Wait(timeOutLimit, () => !Me.IsCasting)) { GarrisonButler.Diagnostic("Timed out while waiting for spell={0}, castTime={1}, timeOutLimit={2}.", spell.Name, spell.CastTime, timeOutLimit); return ActionResult.Failed; } await CommonCoroutines.SleepForLagDuration(); } catch (Exception e) { GarrisonButler.Diagnostic(e.ToString()); GarrisonButler.Log("Failed casting {0}.", spell.Name); return ActionResult.Failed; } GarrisonButler.Log("Successful cast of {0}.", spell.Name); return ActionResult.Done; }
public CoolDownLeftMaxCondition(WoWSpell spell, TimeSpan maxTimeLeft) { this.Spell = spell; this.MaxTimeLeft = maxTimeLeft; }
// always create passing the existing context so it is preserved for delegate usage internal CastContext(object ctx, SpellFindDelegate ssd, UnitSelectionDelegate onUnit, HasGcd gcd = HasGcd.Yes) { if (ssd == null || onUnit == null) return; if (ssd(ctx, out sfr)) { spell = sfr.Override ?? sfr.Original; name = spell.Name; context = ctx; unit = onUnit(ctx); // health/dist change quickly, so grab these now where // .. we check requirements so the log message we output // .. later reflects what they were when we were testing // .. as opposed to what they may have changed to // .. (since spell lookup, move while casting check, and cancast take time) if (unit != null && unit.IsValid) { health = unit.HealthPercent; distance = unit.SpellDistance(); } } }
public static bool CastPrimative(WoWSpell spell) { LastSpellTarget = WoWGuid.Empty; return SpellManager.Cast(spell); }
public static int GetCharges(WoWSpell spell) { int charges = Lua.GetReturnVal<int>("return GetSpellCharges(" + spell.Id.ToString() + ")", 0); return charges; }
public static int GetBaseCooldown(WoWSpell spell) { int cd = Lua.GetReturnVal<int>("return GetSpellBaseCooldown(" + spell.Id.ToString() + ")", 0); return cd; }
public static bool CanCastHackWillOurMovementInterrupt(WoWSpell spell, WoWUnit unit) { if ((spell.CastTime != 0u || spell.IsChanneled) && Me.IsMoving && !AllowMovingWhileCasting(spell)) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: cannot cast while moving", spell.Name); return true; } return false; }
public static bool CanCastHackInRange(WoWSpell spell, WoWUnit unit) { if (unit != null && !spell.IsSelfOnlySpell && !unit.IsMe) { #if USE_LUA_RANGECHECK // will exercise the IsSpellInRange LUA if it can easily // .. derive a UnitID for the target string sTarget = null; if (unit.Guid == Me.CurrentTargetGuid) sTarget = "target"; else if (unit.IsPlayer && unit.ToPlayer().IsInMyPartyOrRaid()) sTarget = unit.Name; else if (unit.IsPet && unit.OwnedByUnit != null && unit.OwnedByUnit.IsPlayer && unit.OwnedByUnit.ToPlayer().IsInMyPartyOrRaid()) sTarget = unit.OwnedByUnit.Name + "-pet"; else if (Me.GotAlivePet) { if (unit.Guid == Me.Pet.Guid) sTarget = "pet"; else if (unit.Guid == Me.Pet.CurrentTargetGuid) sTarget = "pettarget"; } if (sTarget != null) { // string lua = string.Format("return IsSpellInRange(\"{0}\",\"{1}\")", spell.Name, sTarget); string inRange = Lua.GetReturnVal<string>(lua, 0); if (inRange != "1") { if (SingularSettings.DebugSpellCanCast) Logger.WriteFile( "CanCast[{0}]: target @ {1:F1} yds failed IsSpellInRange() = {2}", spell.Name, unit.Distance, inRange); return false; } } else #endif { if (spell.IsMeleeSpell && !unit.IsWithinMeleeRange) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: target @ {1:F1} yds not in melee range", spell.Name, unit.Distance); return false; } else if (spell.HasRange) { if (unit.Distance > spell.ActualMaxRange(unit)) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: out of range - further than {1:F1}", spell.Name, spell.ActualMaxRange(unit)); return false; } if (unit.Distance < spell.ActualMinRange(unit)) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: out of range - closer than {1:F1}", spell.Name, spell.ActualMinRange(unit)); return false; } } } if (!unit.InLineOfSpellSight) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile( "CanCast[{0}]: not in spell line of {1}", spell.Name, unit.SafeName()); return false; } } return true; }
public static bool CanCastHackIsCastInProgress(WoWSpell spell, WoWUnit unit) { uint lat = SingularRoutine.Latency * 2u; if (Me.ChanneledCastingSpellId == 0) { if (StyxWoW.Me.IsCasting && Me.CurrentCastTimeLeft.TotalMilliseconds > lat) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile("CanCast[{0}]: current cast of {1} has {2:F0} ms left", spell.Name, Me.CurrentCastId, Me.CurrentCastTimeLeft.TotalMilliseconds - lat); return true; } } if (spell.CooldownTimeLeft.TotalMilliseconds > lat) { if (SingularSettings.DebugSpellCasting) Logger.WriteFile("CanCast[{0}]: still on cooldown for {1:F0} ms", spell.Name, spell.CooldownTimeLeft.TotalMilliseconds - lat); return true; } return false; }
public SpellIsNotOnCooldownCondition(WoWSpell spell) { this.Spell = spell; }
// always create passing the existing context so it is preserved for delegate usage internal CogContext(object ctx, SpellFindDelegate ssd, SimpleLocationRetriever locrtrv, SimpleStringDelegate descrtrv) { if (ssd(ctx, out sfr)) { spell = sfr.Override ?? sfr.Original; name = spell.Name; context = ctx; loc = WoWPoint.Empty; targetDesc = ""; if (locrtrv != null) { loc = locrtrv(ctx); if (descrtrv != null) { targetDesc = descrtrv(ctx) + " "; } } } }
public static bool CastPrimative(WoWSpell spell, WoWUnit unit) { LastSpellTarget = unit == null ? WoWGuid.Empty : unit.Guid; return SpellManager.Cast(spell, unit); }
internal CogContext(CastContext cc, SimpleStringDelegate descrtrv) { if (cc.unit != null) { loc = cc.unit.Location; spell = cc.spell; context = cc.context; name = cc.name; sfr = cc.sfr; spell = cc.spell; if (descrtrv != null) { targetDesc = descrtrv(context) + " "; } } }
private static bool SymbCanCast(WoWSpell spell, WoWUnit unit) { if (spell.Cooldown) return false; // check range if (unit != null && !spell.IsSelfOnlySpell) { if (spell.IsMeleeSpell && !unit.IsWithinMeleeRange) return false; if (spell.HasRange && (unit.Distance > (spell.MaxRange + unit.CombatReach + 1) || unit.Distance < (spell.MinRange + unit.CombatReach + 1.66666675f))) return false; if (!unit.InLineOfSpellSight) return false; } if ((spell.CastTime != 0u || Spell.IsFunnel(spell)) && Me.IsMoving && !Spell.HaveAllowMovingWhileCastingAura(spell)) return false; if (Me.ChanneledCastingSpellId == 0) { if (Spell.IsCasting()) return false; if (spell.Cooldown) return false; } if (Me.CurrentPower < spell.PowerCost) return false; return true; }
public static TimeSpan GetSpellCastTime(WoWSpell spell) { if (spell != null) { int time = (int)spell.CastTime; if (time == 0) time = spell.BaseDuration; return TimeSpan.FromMilliseconds(time); } return TimeSpan.Zero; }
public AuraMaxRemaningTimeCondition(TimeSpan maxRemaingTime, WoWSpell aura, WoWUnit target) { _maxRemaingTime = maxRemaingTime; _aura = aura; _target = target; }
public static bool IsSpellOnCooldown(WoWSpell spell) { if (spell == null) return true; if (Me.ChanneledCastingSpellId != 0) return true; uint num = SingularRoutine.Latency * 2u; if (StyxWoW.Me.IsCasting && Me.CurrentCastTimeLeft.TotalMilliseconds > num) return true; if (spell.CooldownTimeLeft.TotalMilliseconds > num) return true; return false; }
public CoolDownLeftMinCondition(WoWSpell spell, TimeSpan minCooldown) { _spell = spell; _minCooldown = minCooldown; }
private void btnStart_Click(object sender, EventArgs e) { if(isRunning) { isRunning = false; if( thread != null ) thread.Join(); return; } if(cbActions.SelectedIndex < 0) return; if(ShadowBot.API.Bot.GetSettings.MouseHook_Enabled) { Mouse.Initialize(); } Spells.CloseMountFrame(); Spells.CloseSpellBookFrame(); DisassembleItem item = (DisassembleItem)cbActions.Items[cbActions.SelectedIndex]; int count = Inventory.GetItemCountById(item.ItemId); if(item.Profession == DisassembleProfession.JEWELCRAFTING || item.Profession == DisassembleProfession.INSCRIPTION) { count /= 5; // Requires atleast 5 to disassemble } int disassembleCount = 0; try { disassembleCount = int.Parse(txtItems.Text); } catch(Exception) { MessageBox.Show("Items to disassemble must be an integer number"); return; } int spellId = 0; switch(item.Profession) { case DisassembleProfession.JEWELCRAFTING: spellId = 31252; break; case DisassembleProfession.INSCRIPTION: spellId = 51005; break; case DisassembleProfession.ENCHANTING: spellId = 13262; break; } disassembleSpell = Spells.GetWoWSpellById(spellId); if(!disassembleSpell.OnActionBar) { bool success = Spells.PlaceGatheringSpellOnBarById(spellId); if(!success) { Log("Failed to place spell on bar"); return; } else { Log("Placed on bar: " + success.ToString()); } } itemsLeft = disassembleCount; disassembleItem = item; btnStart.Text = "Stop"; isRunning = true; if(item.Profession == DisassembleProfession.JEWELCRAFTING || item.Profession == DisassembleProfession.INSCRIPTION) { thread = new Thread(new ThreadStart(ThreadSort)); thread.Start(); } else { thread = new Thread(new ThreadStart(ThreadDisassemble)); thread.Start(); } }
public TargetAuraUpCondition(WoWUnit target, WoWSpell aura , bool isMine = true) { _target = target; _aura = aura; _isMine = isMine; }
/// <summary> /// check for aura which allows moving without interrupting spell casting /// </summary> /// <returns></returns> public static bool HaveAllowMovingWhileCastingAura(WoWSpell spell = null) { WoWAura found = Me.GetAllAuras().FirstOrDefault(a => a.ApplyAuraType == (WoWApplyAuraType)330 && (spell == null || Spell.GetSpellCastTime(spell) < a.TimeLeft)); if (SingularSettings.DebugSpellCasting && found != null) Logger.WriteFile( "MoveWhileCasting[{0}]: true, since we found move buff {1} #{2}", spell == null ? "(null)" : spell.Name, found.Name, found.SpellId ); return found != null; }