/// <summary> /// Adds our current target to our listOfHealableUnits /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void addHealableUnit_Click(object sender, EventArgs e) { try { // Add a couple of HealableUnits to the list. if (Me.CurrentTarget != null && HealableUnit.Filter(Me.CurrentTarget)) { if (!HealableUnit.Contains(Me.CurrentTarget)) { CLULogger.TroubleshootLog(" Adding: {0} because of user request.", CLULogger.SafeName(Me.CurrentTarget)); HealableUnit.ListofHealableUnits.Add(new HealableUnit(Me.CurrentTarget)); } } else { MessageBox.Show( "Please make sure that you have a CurrentTarget", "Important Note", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1); } this.RefreshDataGridView(); } catch (Exception ex) { CLULogger.DiagnosticLog("addHealableUnit_Click : {0}", ex); } }
public void CombatLogEventsOnStarted(object o) { try { CLULogger.TroubleshootLog("CombatLogEvents: Connected to the Grid"); // means spell was cast (did not hit target yet) CLULogger.TroubleshootLog("CombatLogEvents: Connect UNIT_SPELLCAST_SUCCEEDED"); Lua.Events.AttachEvent("UNIT_SPELLCAST_SUCCEEDED", this.OnSpellFired_ACK); // user got stunned, silenced, kicked... CLULogger.TroubleshootLog("CombatLogEvents: Connect UNIT_SPELLCAST_INTERRUPTED"); Lua.Events.AttachEvent("UNIT_SPELLCAST_INTERRUPTED", this.OnSpellFired_NACK); // misc fails, due to stopcast, spell spam, etc. CLULogger.TroubleshootLog("CombatLogEvents: Connect UNIT_SPELLCAST_FAILED"); Lua.Events.AttachEvent("UNIT_SPELLCAST_FAILED", this.OnSpellFired_FAIL); CLULogger.TroubleshootLog("CombatLogEvents: Connect UNIT_SPELLCAST_FAILED_QUIET"); Lua.Events.AttachEvent("UNIT_SPELLCAST_FAILED_QUIET", this.OnSpellFired_FAIL); CLULogger.TroubleshootLog("CombatLogEvents: Connect UNIT_SPELLCAST_STOP"); Lua.Events.AttachEvent("UNIT_SPELLCAST_STOP", this.OnSpellFired_FAIL); CLULogger.TroubleshootLog("CombatLogEvents: Connect PARTY_MEMBERS_CHANGED"); Lua.Events.AttachEvent("PARTY_MEMBERS_CHANGED", this.HandlePartyMembersChanged); if ((CLU.LocationContext != GroupLogic.Battleground && CLU.LocationContext != GroupLogic.PVE) || TalentManager.CurrentSpec == WoWSpec.DruidFeral) { AttachCombatLogEvent(); } } catch (Exception ex) { CLULogger.DiagnosticLog("HandlePartyMembersChanged : {0}", ex); } }
/// <summary> /// Resets individual MultiCastMacro int's from one(1) to zero(0) /// </summary> /// <param name="Which">Spell name</param> public static void resetMacro(string Which) { try { Lua.DoString(Which + " = 0;"); } catch { CLULogger.DiagnosticLog("Lua failed in Macro.resetMacro"); } }
/*-------------------------------------------------------- * Spells *-------------------------------------------------------- */ /// <summary>Returns the Pet spell cooldown using Timespan (00:00:00.0000000) /// gtfo if the Pet dosn't have the spell.</summary> /// <param name="name">the name of the spell to check for</param> /// <returns>The spell cooldown.</returns> public static TimeSpan PetSpellCooldown(string name) { WoWPetSpell petAction = PetSpells.FirstOrDefault(p => p.ToString() == name); if (petAction == null || petAction.Spell == null) { return(TimeSpan.Zero); } CLULogger.DiagnosticLog(" [PetSpellCooldown] {0} : {1}", name, petAction.Spell.CooldownTimeLeft); return(petAction.Spell.CooldownTimeLeft); }
/// <summary> /// Calls a pet by name, if applicable. /// </summary> /// <remarks> /// Created 2/7/2011. /// </remarks> /// <param name = "petName">Name of the pet. This parameter is ignored for mages. Warlocks should pass only the name of the pet. Hunters should pass which pet (1, 2, etc)</param> /// <returns>true if it succeeds, false if it fails.</returns> public static bool CallPet(string petName) { if (!CallPetTimer.IsFinished) { return(false); } switch (StyxWoW.Me.Class) { case WoWClass.Warlock: if (Spell.CanCast("Summon " + petName)) { CLULogger.DiagnosticLog(string.Format("[Pet] Calling out my {0}", petName)); bool result = SpellManager.Cast("Summon " + petName); //if (result) // StyxWoW.SleepForLagDuration(); return(result); } break; case WoWClass.Mage: if (Spell.CanCast("Summon Water Elemental")) { CLULogger.DiagnosticLog("[Pet] Calling out Water Elemental"); bool result = SpellManager.Cast("Summon Water Elemental"); //if (result) - All calls to this method are now placed in a sequence that uses WaitContinue // StyxWoW.SleepForLagDuration(); return(result); } break; case WoWClass.Hunter: if (Spell.CanCast("Call Pet " + petName)) { if (!StyxWoW.Me.GotAlivePet) { CLULogger.DiagnosticLog(string.Format("[Pet] Calling out pet #{0}", petName)); bool result = SpellManager.Cast("Call Pet " + petName); //if (result) // StyxWoW.SleepForLagDuration(); return(result); } } break; } return(false); }
/// <summary> /// Saves and Closes the Configuration window. /// </summary> private void BtnSaveAndCloseClick(object sender, EventArgs e) { // prevent an exception from closing HB. try { ((Styx.Helpers.Settings)pgGeneral.SelectedObject).Save(); if (pgClass.SelectedObject != null) { ((Styx.Helpers.Settings)pgClass.SelectedObject).Save(); } this.Close(); } catch (Exception ex) { CLULogger.DiagnosticLog("ERROR saving settings: {0}", ex); } }
// Displays information about the current target on the debug tab private void button4_Click(object sender, EventArgs e) { try { var target = StyxWoW.Me.CurrentTarget; string output = target == null ? "<No target>" : "Name : " + target.Name; textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "Guid : " + target.Guid.ToString(CultureInfo.InvariantCulture); textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "Distance : " + Math.Round(target.Distance, 3).ToString(CultureInfo.InvariantCulture); textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "DistanceToTargetBoundingBox : " + Math.Round(Unit.DistanceToTargetBoundingBox(target), 3).ToString(CultureInfo.InvariantCulture); textBox2.Text += output + Environment.NewLine; output = "IsBehind : " + (target != null && StyxWoW.Me.IsBehind(target)).ToString(CultureInfo.InvariantCulture); textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "ThreatInfo : " + target.ThreatInfo.RawPercent.ToString(CultureInfo.InvariantCulture); textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "Location : " + target.Location; textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "SingleTargethealingParty : " + CLUSettings.Instance.Priest.SingleTargethealingParty; textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "PrayerofHealingPartymaxAH : " + CLUSettings.Instance.Priest.PrayerofHealingPartymaxAH; textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "Me.CurrentHolyPower : " + Me.CurrentHolyPower; textBox2.Text += output + Environment.NewLine; output = target == null ? string.Empty : "PetSlotSelection : " + (int)CLUSettings.Instance.Hunter.PetSlotSelection; textBox2.Text += output + Environment.NewLine; //output = target == null ? string.Empty : "Thunder Clap (" + SpellManager.Spells["Thunder Clap"].Id + ") Cooldown : " + Spell.SpellCooldown("Thunder Clap").TotalSeconds; //textBox2.Text += output + Environment.NewLine; //output = target == null ? string.Empty : "Thunder Clap Cooldown : " + Spell.CooldownTimeLeft6343; //textBox2.Text += output + Environment.NewLine; //output = target == null ? string.Empty : "Explosive Shot (" + SpellManager.Spells["Explosive Shot"].Id + ") Cooldown : " + Spell.SpellCooldown("Explosive Shot").TotalSeconds; //textBox2.Text += output + Environment.NewLine; //output = target == null ? string.Empty : "Explosive Shot Cooldown : " + Spell.CooldownTimeLeft33878; //textBox2.Text += output + Environment.NewLine; if (target != null) { // facing var me = StyxWoW.Me.Location; var ta = target.Location; output = "FacingTowardsUnitDegrees : " + Math.Round(Unit.FacingTowardsUnitDegrees(me, ta), 2) + "°"; } textBox2.Text += output + Environment.NewLine; } catch (Exception ex) { CLULogger.DiagnosticLog("Current Target Information : {0}", ex); } }
/// <summary> /// Handle spellcast succeeded /// </summary> /// <param name="sender">sender</param> /// <param name="raw">raw Lua Events</param> public void UnitSpellcastSucceeded(object sender, LuaEventArgs raw) { var args = raw.Args; var player = Convert.ToString(args[0]); // Not me ... Im out! if (player != "player") { return; } // get the english spell name, not the localized one! var spellID = Convert.ToInt32(args[4]); var spell = WoWSpell.FromId(spellID).Name; // increments or decrements int value; if (spellList.TryGetValue(spell, out value)) { spellList[spell] = value + 1; } this.spellCasts++; // Add the spell to our spell list with a timestamp if (!this.spellInterval.ContainsKey(spell)) { this.spellInterval[spell] = new List <DateTime>(); } if (!this.spellInterval[spell].Contains(DateTime.Now)) { CLULogger.DiagnosticLog("Adding " + DateTime.Now + " for " + spell); this.spellInterval[spell].Add(DateTime.Now); } // initialize or increment the count for this item try { this.healingStats[DateTime.Now] = CLULogger.SafeName(Me.CurrentTarget) + ", " + spell + ", MaxHealth: " + Me.CurrentTarget.MaxHealth + ", CurrentHealth: " + Me.CurrentTarget.CurrentHealth + ", Deficit: " + (Me.CurrentTarget.MaxHealth - Me.CurrentTarget.CurrentHealth); CLULogger.DiagnosticLog("[CLU SUCCEED] " + CLU.Version + ": " + CLULogger.SafeName(Me.CurrentTarget) + ", " + spell + ", MaxHealth: " + Me.CurrentTarget.MaxHealth + ", CurrentHealth: " + Me.CurrentTarget.CurrentHealth + ", Deficit: " + (Me.CurrentTarget.MaxHealth - Me.CurrentTarget.CurrentHealth) + ", HealthPercent: " + Math.Round(Me.CurrentTarget.HealthPercent * 10.0) / 10.0); } catch { this.healingStats[DateTime.Now] = this.healingStats.ContainsKey(DateTime.Now) ? this.healingStats[DateTime.Now] = CLULogger.SafeName(Me.CurrentTarget) + ", " + spell + ", MaxHealth: " + Me.CurrentTarget.MaxHealth + ", CurrentHealth: " + Me.CurrentTarget.CurrentHealth + ", Deficit: " + (Me.CurrentTarget.MaxHealth - Me.CurrentTarget.CurrentHealth) : "blank"; CLULogger.DiagnosticLog("[CLU SUCCEED] " + CLU.Version + ": " + CLULogger.SafeName(Me.CurrentTarget) + ", " + spell + ", MaxHealth: " + Me.CurrentTarget.MaxHealth + ", CurrentHealth: " + Me.CurrentTarget.CurrentHealth + ", Deficit: " + (Me.CurrentTarget.MaxHealth - Me.CurrentTarget.CurrentHealth) + ", HealthPercent: " + Math.Round(Me.CurrentTarget.HealthPercent * 10.0) / 10.0); } }
/// <summary> /// Destroys the totem described by type. /// </summary> /// <remarks> /// Created 3/26/2011. /// </remarks> /// <param name = "type">The type.</param> public static void DestroyTotem(WoWTotemType type) { if (type == WoWTotemType.None) { return; } try { Lua.DoString("DestroyTotem({0})", (int)type); } catch { CLULogger.DiagnosticLog("Lua failed in DestroyTotem"); } }
/// <summary> /// the main cast pet spell method (uses Lua) /// </summary> /// <param name="name">the name of the spell to cast</param> private static void CastMyPetSpell(string name) { var spell = Me.PetSpells.FirstOrDefault(p => p.ToString() == name); if (spell == null) { return; } try { Lua.DoString("CastPetAction({0})", spell.ActionBarIndex + 1); } catch { CLULogger.DiagnosticLog("Lua failed in CastMyPetSpell"); } }
/// <summary> /// Checks the equiped item cooldown is 0 and its usable /// </summary> /// <param name="item">the item to query</param> /// <returns>true of false</returns> private static bool CanUseEquippedItem(WoWItem item) { try { // Check for engineering tinkers! var itemSpell = Lua.GetReturnVal <string>("return GetItemSpell(" + item.Entry + ")", 0); if (string.IsNullOrEmpty(itemSpell)) { return(false); } return(item.Usable && item.Cooldown <= 0); } catch { CLULogger.DiagnosticLog("Lua failed in CanUseEquippedItem"); return(false); } }
public void Player_OnMapChanged(BotEvents.Player.MapChangedEventArgs args) { try { if ((CLU.LocationContext == GroupLogic.Battleground || CLU.LocationContext == GroupLogic.PVE) && TalentManager.CurrentSpec != WoWSpec.DruidFeral) { DetachCombatLogEvent(); } else { AttachCombatLogEvent(); } //Why would we create same behaviors all over ? if (CLU.LastLocationContext == CLU.LocationContext) { return; } CLULogger.TroubleshootLog("Context changed. New context: " + CLU.LocationContext + ". Rebuilding behaviors."); CLU.Instance.CreateBehaviors(); if (CLU.IsHealerRotationActive && StyxWoW.IsInGame) { CLULogger.TroubleshootLog("CombatLogEvents: Party Members Changed - Re-Initialize list Of HealableUnits"); switch (CLUSettings.Instance.SelectedHealingAquisition) { case HealingAquisitionMethod.Proximity: HealableUnit.HealableUnitsByProximity(); break; case HealingAquisitionMethod.RaidParty: HealableUnit.HealableUnitsByPartyorRaid(); break; } } } catch (Exception ex) { CLULogger.DiagnosticLog("Player_OnMapChanged : {0}", ex); } }
/// <summary> /// Sets up the healing grid and binds our datasource to listOfHealableUnits /// </summary> private void InitializeHealingGrid() { try { HealingGrid.SelectionMode = DataGridViewSelectionMode.FullRowSelect; // Automatically generate the DataGridView columns. HealingGrid.AutoGenerateColumns = true; // Automatically resize the visible rows. HealingGrid.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders; // Automatically resize the visible columns HealingGrid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.ColumnHeader; // Set the DataGridView control's border. HealingGrid.BorderStyle = BorderStyle.Fixed3D; // Put the cells in edit mode when user enters them. HealingGrid.EditMode = DataGridViewEditMode.EditOnEnter; // Set the RowHeaders visibility to invisible HealingGrid.RowHeadersVisible = false; // Dissalow user from adding rows HealingGrid.AllowUserToAddRows = false; // Clipboard copying. HealingGrid.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithoutHeaderText; // Bind to our Datasource (BindingList) healingGridBindingSource = new BindingSource { DataSource = HealableUnit.ListofHealableUnits }; HealingGrid.DataSource = healingGridBindingSource; // Create events for HealingGrid: HealingGrid.CurrentCellDirtyStateChanged += this.HealingGrid_CurrentCellDirtyStateChanged; //HealingGrid.CellMouseClick += this.HealingGrid_OnCellMouseUp; } catch (Exception ex) { CLULogger.DiagnosticLog("InitializeHealingGrid : {0}", ex); } }
/// <summary>Returns a summoned pet</summary> /// <param name="name">the name 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(string name, CanRunDecoratorDelegate cond, string label) { try { var isWarlock = Me.Class == WoWClass.Warlock && SpellManager.Spells[name].Name.StartsWith("Summon "); if (isWarlock) { Spell.KnownChanneledSpells.Add(name); } return(new Decorator( delegate(object a) { if (!cond(a)) { return false; } if (!Spell.CanCast(name, Me)) { 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(name)), 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())))))); } catch { CLULogger.DiagnosticLog("Summon Spell {0} not supported for your Class / Specc ({1}/{2})", name, Me.Class, Me.Specialization); return(null); } }
/// <summary> /// Checks if the player is weilding a TwoHanded Weapon /// </summary> /// <returns>returns true if the player is weilding a TwoHanded Weapon</returns> public static bool IsWieldingTwoHandedWeapon() { try { switch (Me.Inventory.Equipped.MainHand.ItemInfo.WeaponClass) { case WoWItemWeaponClass.ExoticTwoHand: case WoWItemWeaponClass.MaceTwoHand: case WoWItemWeaponClass.AxeTwoHand: case WoWItemWeaponClass.SwordTwoHand: return(true); } return(false); } catch (Exception ex) { CLULogger.DiagnosticLog("IsWieldingBigWeapon : {0}", ex); } return(false); }
private static double Traveltime(double travelSpeed) { { if (travelSpeed < 1) { return(0); } if (Me.CurrentTarget != null && Me.CurrentTarget.Distance < 1) { return(0); } if (Me.CurrentTarget != null) { double t = Me.CurrentTarget.Distance / travelSpeed; CLULogger.DiagnosticLog("Travel time: {0}", t); return(t); } return(0); } }
// Provides information from the healing helper window on the selected row item (displays it on teh debug tab.) private void CheckerClick(object sender, EventArgs e) { try { if (this.HealingGrid.SelectedRows.Count > 0) { for (int i = 0; i < this.HealingGrid.SelectedRows[0].Cells.Count; i++) { textBox1.Text += string.Format(" {0} : {1}", this.HealingGrid.SelectedRows[0].Cells[i].OwningColumn.HeaderText, this.HealingGrid.SelectedRows[0].Cells[i].Value) + Environment.NewLine; } } else { MessageBox.Show( "Please select a row to gather information. check the debug log for the output.", "Important Note for Healing Helper", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1); } } catch (Exception ex) { CLULogger.DiagnosticLog("Checker_Click : {0}", ex); } }
/// <summary> /// Removes a unit from our listOfHealableUnits by the currently selected row /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void removeUnitHealingGrid_Click(object sender, EventArgs e) { try { if (this.HealingGrid.SelectedRows.Count > 0) { CLULogger.TroubleshootLog(" Removing: {0} because of user request.", this.HealingGrid.SelectedRows[0].Cells[6].Value); HealableUnit.ListofHealableUnits.RemoveAt(this.HealingGrid.SelectedRows[0].Index); } else { MessageBox.Show( "Please select a row to delete", "Important Note", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1); } this.RefreshDataGridView(); // update } catch (Exception ex) { this.RefreshDataGridView(); // update CLULogger.DiagnosticLog("removeUnitHealingGrid_Click : {0}", ex); } }
private void HandlePartyMembersChanged(object sender, LuaEventArgs args) { try { if (CLU.IsHealerRotationActive && StyxWoW.IsInGame) { CLULogger.TroubleshootLog("CombatLogEvents: Party Members Changed - Re-Initialize list Of HealableUnits"); switch (CLUSettings.Instance.SelectedHealingAquisition) { case HealingAquisitionMethod.Proximity: HealableUnit.HealableUnitsByProximity(); break; case HealingAquisitionMethod.RaidParty: HealableUnit.HealableUnitsByPartyorRaid(); break; } } } catch (Exception ex) { CLULogger.DiagnosticLog("HandlePartyMembersChanged : {0}", ex); } }
/// <summary> /// Main MultiCastMacro call: checks if MultiCastMacro MT or FT is active, also checks for LoS and if we can cast the specified spell /// If zero(0) is present: return to primary or previous rotation /// If one(1) is present: run MT or FT then return to primary or previous rotation /// </summary> public static void isMultiCastMacroInUse() { using (StyxWoW.Memory.AcquireFrame()) { try { MultiCastMacroMT = Lua.GetReturnVal <int>("return MultiCastMT", 0); MultiCastMacroFT = Lua.GetReturnVal <int>("return MultiCastFT", 0); whatSpell = Lua.GetReturnVal <String>("return spellName", 0); } catch { CLULogger.DiagnosticLog("Lua failed in Macro.isMultiCastMacroInUse"); } } if (MultiCastMacroMT > 0 || MultiCastMacroFT > 0) { if (whatSpell == null) { CLULogger.Log("Please enter a spell!"); resetAllMacros(); } else { SpellManager.Spells.TryGetValue(whatSpell, out _Spell); if (!_Spell.IsValid) { CLULogger.Log("Can't Cast Spell, invalid!"); resetAllMacros(); } if (_Spell.CooldownTimeLeft > SpellManager.GlobalCooldownLeft) { CLULogger.Log("Can't Cast Spell, on CD!"); resetAllMacros(); } } } if (MultiCastMacroMT > 0) { if (SpellManager.GlobalCooldown || Me.IsCasting) { return; } if (Me.CurrentTarget.InLineOfSight) { if (SpellManager.CanCast(whatSpell)) { try { Lua.DoString("RunMacroText(\"/cast " + whatSpell + "\")"); } catch { CLULogger.DiagnosticLog("Lua failed in Macro.isMultiCastMacroInUse"); } SpellManager.ClickRemoteLocation(Me.CurrentTarget.Location); CLULogger.Log("Casting " + whatSpell); resetMacro("MultiCastMT"); } } else { resetMacro("MultiCastMT"); } } else if (MultiCastMacroFT > 0) { if (SpellManager.GlobalCooldown || Me.IsCasting) { return; } if (Me.FocusedUnit.InLineOfSight) { if (SpellManager.CanCast(whatSpell)) { try { Lua.DoString("RunMacroText(\"/cast [@focus] " + whatSpell + "\")"); } catch { CLULogger.DiagnosticLog("Lua failed in Macro.isMultiCastMacroInUse"); } SpellManager.ClickRemoteLocation(Me.FocusedUnit.Location); CLULogger.Log("Casting " + whatSpell); resetMacro("MultiCastFT"); } } else { resetMacro("MultiCastFT"); } } }
public static void Update() { // Don't bother if we're < 10 if (StyxWoW.Me.Level < 10) { CurrentSpec = WoWSpec.None; return; } // Keep the frame stuck so we can do a bunch of injecting at once. using (StyxWoW.Memory.AcquireFrame()) { CurrentSpec = StyxWoW.Me.Specialization; Talents.Clear(); var numTalents = Lua.GetReturnVal <int>("return GetNumTalents()", 0); for (int index = 0; index <= numTalents; index++) { var selected = Lua.GetReturnVal <int>(string.Format("return GetTalentInfo({0})", index), 4); switch (selected) { case 1: { var t = new Talent { Index = index, Count = 1 }; //Name = talentName CLULogger.TroubleshootLog("[TalentManager] - Talent {0} chosen", index); Talents.Add(t); } break; } } foreach (var talent in Talents) { if (StyxWoW.Me.Class == WoWClass.DeathKnight) { // Set the Blood DK Tier one Talent here switch (talent.Index) { case 1: CLUSettings.Instance.DeathKnight.DeathKnightTierOneTalent = DeathKnightTierOneTalent.RoilingBlood; CLULogger.TroubleshootLog("TalentManager - Setting DeathKnightTierOneTalent to {0}", DeathKnightTierOneTalent.RoilingBlood); break; case 2: CLUSettings.Instance.DeathKnight.DeathKnightTierOneTalent = DeathKnightTierOneTalent.PlagueLeech; CLULogger.TroubleshootLog("TalentManager - Setting DeathKnightTierOneTalent to {0}", DeathKnightTierOneTalent.PlagueLeech); break; case 3: CLUSettings.Instance.DeathKnight.DeathKnightTierOneTalent = DeathKnightTierOneTalent.UnholyBlight; CLULogger.TroubleshootLog("TalentManager - Setting DeathKnightTierOneTalent to {0}", DeathKnightTierOneTalent.UnholyBlight); break; } } } Glyphs.Clear(); var glyphCount = Lua.GetReturnVal <int>("return GetNumGlyphSockets()", 0); CLULogger.TroubleshootLog("Glyphdetection - GetNumGlyphSockets {0}", glyphCount); if (glyphCount != 0) { for (int i = 1; i <= glyphCount; i++) { List <string> glyphInfo = Lua.GetReturnValues(String.Format("return GetGlyphSocketInfo({0})", i), "glyphs.lua"); var lua = String.Format("local enabled, glyphType, glyphTooltipIndex, glyphSpellID, icon = GetGlyphSocketInfo({0});if (enabled) then return glyphSpellID else return 0 end", i); var glyphSpellId = Lua.GetReturnVal <int>(lua, 0); try { if (glyphSpellId > 0) { CLULogger.TroubleshootLog("Glyphdetection - SpellId: {0},Name:{1} ,WoWSpell: {2}", glyphSpellId, WoWSpell.FromId(glyphSpellId).Name, WoWSpell.FromId(glyphSpellId)); Glyphs.Add(WoWSpell.FromId(glyphSpellId).Name.Replace("Glyph of ", "")); } else { CLULogger.TroubleshootLog("Glyphdetection - Couldn't find all values to detect the Glyph in slot {0}", i); } } catch (Exception ex) { CLULogger.DiagnosticLog("We couldn't detect your Glyphs"); CLULogger.DiagnosticLog("Report this message to us: " + ex); } } } } }
private void OnSpellFired(bool success, bool spellCast, LuaEventArgs raw) { var args = raw.Args; var player = Convert.ToString(args[0]); if (player != "player") { return; } // get the english spell name, not the localized one! var spellId = Convert.ToInt32(args[4]); var spellName = WoWSpell.FromId(spellId).Name; var sourceGuid = ulong.Parse(args[3].ToString().Replace("0x", string.Empty), NumberStyles.HexNumber); if (!success && spellCast) { CLULogger.DiagnosticLog("Woops, '{0}' cast failed: {1}", spellName, raw.EventName); } // if the spell is locked, let's extend it (spell travel time + client lag) / or reset it... if (Locks.ContainsKey(spellName)) { if (success) { // yay! Locks[spellName] = DateTime.Now.AddSeconds(ClientLag + 4.0); } else { if (spellCast) { // interrupted while casting Locks[spellName] = DateTime.Now; } else { // failed to cast it. moar spam! Locks[spellName] = DateTime.Now; } } } // We need to 'sleep' for these spells. Otherwise, we'll end up double-casting them. Which will cause issues switch (spellName) { case "Rejuvenation": case "Lifebloom": case "Regrowth": case "Nourish": case "Healing Touch": case "Remove Corruption": case "Holy Light": case "Holy Radiance": case "Divine Light": case "Holy Shock": CLULogger.DiagnosticLog("Sleeping for heal success. ({0})", spellName); StyxWoW.SleepForLagDuration(); break; case "Nature's Swiftness": CLULogger.DiagnosticLog("PrevNaturesSwiftness. ({0})", spellName); if (sourceGuid == StyxWoW.Me.Guid) { Classes.Druid.Common.PrevNaturesSwiftness = spellId == 132158; } break; } }