rendered paste body;-----------------------------------------------|; Shaman Routine by Swolbyn v0.5 |;-----------------------------------------------/;; - Added Swimming checks in buff pulse, if your toon is swimming it will jump and try to; move towards the current target to melee range. To Prevent drowning.; - Various tweaks to combat and pull logic;; - Removed flee, when I turned it on it was bugging stuff up big time.; - Many combat tweaks; - Added Shamanistic Focus Support; - Under Spells tab you can choose "Save Shocks For Shamanistic Focus"; When this is selected you will not use shocks regularly unless you have the focused effect after a crit attack; - Immunities and Running Mobs Redesign; - Now Mob Immunities and fleeing creatures are stored in MobData.xml in the routines folder;; - Reinarcation code reworked some. Still a little flaky there is a rare occurance when you reincarnate and then die quickly after that it doesn't detect you are dead again thus sitting at graveyard. It's rare. but happens. Due to this I have implemented a checkbox on main class configuration tab you can turn it off or on as you like.; - Further adjustments to the attacking routines. FINALLY if a caster is shooting at you from afar, you'll shoot at him from afar. until he runs too close for your ranged spells, then you run to melee range as well. Works quite nicely.; - Immunities should finally work. Took a bit of work this was a bitch :);; - Reincarnation logic modifications; - Further tweaks to combat / pull logic;; - Completely overhauled the Pull routine. Much smoother now.; - Added in Disease Cleansing Totem logic to Mimic Poison Totem Logic; - Added in the ressurection logic. (needs testing, not sure if it works); - Fixed some typos i found in the shielding logic; - Fixed the Water Walking logic;; Thanks to all the many shaman routine writers out there in the openbot forums!; This bot is a giant merged hybrid of shamany goodness. It includes some modified; functions from all the many different bots that I have come across; as well as some; custom stuff that I wrote in (and continue to do so) as I botted my shaman; and notice changes that I wish to see.;; GUI kept from APOC's shaman routine, just took out some checkboxes that I found; useless, i've integrated the logic into the system so there was no need for checkboxes.;; Overall my goal with this bot was to make it smarter. Less configuration is needed; for certain aspects of it.;; You milage may vary. But I basically set it to use random shocks. I put my primary; totem for combat set. leave the other totem boxes blank. (I used magma totem).; Bot will automatically throw down stoneclaw totems on adds and uses the primary; totem (magma for me) if the danger lvl is high enough or there's adds. This results; in easier fights not wasting mana on totems.;; Curing poison and disease has been reworked. Will attempt to throw down a cure; Totem if poisoned too soon after the first cure poison (20 seconds).;; I will continue updating the bot as I level and gain access to higher lvl spells.; My shaman is currently in the 30's so if you are trying to bot higher lvl stuff; You *may* find the luxury items not working. (Ex. I don't have dual wield or; elementals to test yet.) I will get to them as I level and discover them. :);objectdef oClass inherits oBase{ /**************************************/ /************ VARIABLES ***************/ variable bool UsePull = TRUE variable string PullSpell = "None" variable int RestHP = 50 variable int RestMP = 50 variable int StandHP = 80 variable int StandMP = 80 variable string EarthTotem = "" variable string FireTotem = "" variable string AirTotem = "" variable string WaterTotem = "" variable bool UseEarthElementa = FALSE variable bool UseFireElemental = FALSE variable bool UseEarthShock = FALSE variable bool UseFlameShock = FALSE variable bool UseFrostShock = FALSE variable bool RandomShock = FALSE variable bool SaveShocks = FALSE variable int ConserveMana = 40 variable bool UseLBolt = FALSE variable bool UseChainLight = FALSE variable string MainHand = "None" variable string OffHand = "None" variable string Shield = "None" variable bool ShieldOnPull = FALSE variable bool DW = FALSE variable int HealWave = 20 variable int LHealWave = 50 variable int ChainHeal = 50 variable int GOTN = 60 variable bool Output = TRUE variable int MaxCastRange = 20 variable int MaxShockRange = 20 variable bool HasEarthTotem = FALSE variable bool HasFireTotem = FALSE variable bool HasWaterTotem = FALSE variable bool HasWindTotem = FALSE variable bool UseReincarnation = FALSE variable bool UseHPot = FALSE variable bool UseMPot = FALSE variable bool UseBandages = FALSE variable int HPot = 25 variable int MPot = 25 variable int Bandage = 25 variable int restWaitTimer = 0 variable int buffWaitTimer = 0 variable int healWaitTimer = 0 variable int curePoisonTimer = 0 variable int cureDiseaseTimer = 0 variable int jumpTimer = 0 variable int PotTimer = 0 variable int DangerMedium = 15 variable int DangerHigh = 30 variable int DangerVeryHigh = 45 variable int DangerLevel = 0 variable int Dangerlvl = 0 variable int BuffNum = 0 variable bool debuffStatus = FALSE variable string RealmChar = "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}" variable bool MeleeOnly = FALSE variable bool RunnerDealtWith = FALSE variable bool Revived = FALSE variable int ReincarnateCount = 0 variable int BackupAttempts = 0 variable string MobDataStorage = "./routines/MobData.xml" variable set MobDataImmunities variable set MobDataRunners variable collection:index:string RandomCast variable collection:int RandomCastCount /**************************************/ /***********Init & Shutdown************/ method Initialize() { LavishSettings:AddSet[MobData] LavishSettings[MobData]:Import[${MobDataStorage}] This:LoadConfig This:InitShamanGUI if ${Me.Action[Gift of the Naaru].Usable} { UIElement -toggle GOTN@Heals@Pages@ClassGUI UIElement -toggle lblGOTN@Heals@Pages@ClassGUI } This:SetDistances This:CreateUIErrorStrings This:SetTotems This:InitRandoms This:InitTriggers This.MobDataImmunities:Clear This.MobDataRunners:Clear This:LoadList[MobDataImmunities] This:LoadList[MobDataRunners] Bot:AddPulse["Class","Pulse",10,TRUE,TRUE] UIElement[ClassGUI].FindChild[Console]:Echo["^_^=================================^_^"] UIElement[ClassGUI].FindChild[Console]:Echo[" Swolbyn's Shaman Routine v0.5"] UIElement[ClassGUI].FindChild[Console]:Echo["^_^=================================^_^"] } method Shutdown() { This:SaveConfig This:RemoveTriggers This:ExportList[MobDataImmunities] This:ExportList[MobDataRunners] LavishSettings[MobData]:Export[${MobDataStorage}] } method Pulse() { ExecuteQueued } method SetDistances() { if ${This.GetSpellRange[30, "elemental"]} { This.MaxCastRange:Set[${This.GetSpellRange[30, "elemental"]}] This:CustOutput["Setting New MaxRange to ${This.MaxCastRange}"] This.MaxShockRange:Set[${This.GetSpellRange[20, "elemental"]}] This:CustOutput["Setting New MaxShockRange to ${This.MaxShockRange}"] } } member GetSpellRange(int base, string spellTree) { if ${spellTree.Equal[elemental]} return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Storm Reach]}))-1].Round} return ${base} } /**************************************/ /**********UI Error Strings************/ variable collection:string UIErrorMsgStrings method CreateUIErrorStrings() { This.UIErrorMsgStrings:Set["You are facing the wrong way!","backward"] This.UIErrorMsgStrings:Set["Target too close","backward"] This.UIErrorMsgStrings:Set["You are too far away!","forward"] This.UIErrorMsgStrings:Set["Out of range.","forward"] } variable bool needUIHook = TRUE method UIErrorMessage(string Id, string Msg) { if ${This.UIErrorMsgStrings.Element[${Msg}](exists)} && !${Bot.PauseFlag} && ${This.crazyWaitTimer} < ${LavishScript.RunningTime} { if ${Msg.Equal["Target too close"]} || (${Target.Distance} < 5 && ${Me.InCombat}) || ${This.UIErrorMsgStrings.Element[${Msg}].Equal["forward"]} && !${Me.Casting} { This:Debug[${Msg}] This:CustOutput["Moving ${This.UIErrorMsgStrings.Element[${Msg}]} - UI Error: ${Msg}"] Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] This.attackWaitTimer:Set[${This.InMilliseconds[25]}] This.pullWaitTimer:Set[${This.InMilliseconds[25]}] move ${This.UIErrorMsgStrings.Element[${Msg}]} 1000 wowpress JUMP return } } } /**************************************/ /*********External Mob Data************/ method LoadList(string loadingList) { variable iterator i if !${LavishSettings[MobData].FindSet[${loadingList}](exists)} LavishSettings[MobData]:AddSet[${loadingList}] LavishSettings[MobData].FindSet[${loadingList}]:GetSettingIterator[i] i:First while ${i.IsValid} { ${loadingList}:Add[${i.Key}] i:Next } } method ExportList(string loadingList) { variable iterator i LavishSettings[MobData].FindSet[${loadingList}]:Clear ${loadingList}:GetIterator[i] i:First while ${i.IsValid} { LavishSettings[MobData].FindSet[${loadingList}]:AddSetting[${i.Key},${i.Key}] i:Next } } /**************************************/ /**************Triggers****************/ method InitTriggers() { AddTrigger DetectRunner "[Event:@eventid@:CHAT_MSG_MONSTER_EMOTE](\"%%s attempts to run away in fear!\",\"@Mob@\",@*@" AddTrigger DetectImmune "[Event:@eventid@:CHAT_MSG_SPELL_SELF_DAMAGE](\"Your @FailedSpell@ failed. @Mob*@ is immune.@*@" } method RemoveTriggers() { RemoveTrigger DetectRunner RemoveTrigger DetectImmune } function DetectRunner(string Line, int eventid, string Mob) { if !${This.MobDataRunners.Contains[${Mob}]} { This:CustOutput["Added ${Mob} to the runner list"] This.MobDataRunners:Add[${Mob}] } } function DetectImmune(string Line, int eventid, string FailedSpell, string Mob) { variable string MobId MobId:Set[${Mob}#${FailedSpell}] if !${This.MobDataImmunities.Contains[${MobId}]} { This:CustOutput["Added ${MobId} to the mob immune list"] This.MobDataImmunities:Add[${MobId}] } } /**************************************/ /***********Character States***********/ member isRunner() { if ${This.MobDataRunners.Contains[${Target.Name}]} return TRUE return FALSE } member isImmune(string SpellName) { if ${This.MobDataImmunities.Contains[${Target.Name}#${SpellName}]} return TRUE return FALSE } member isPoisoned() { BuffNum:Set[1] while ${BuffNum} < 16 { BuffNum:Inc if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]} { return TRUE } } return FALSE } member isDiseased() { BuffNum:Set[1] while ${BuffNum} < 16 { BuffNum:Inc if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]} { return TRUE } } return FALSE } /**************************************/ /************Reincarnation*************/ member NeedDead() { if !${This.Revived} && ${This.ReincarnateCount} < 10 && (${Me.Dead} || ${Me.Ghost}) && ${This.UseReincarnation} { return TRUE } else { return FALSE } } method DeadPulse() { This:Output["Bad Shaman! you died?!"] Bot.RandomPause:Set[25] This.ReincarnateCount:Inc if ${This.CanUseAnkh} { if ${WoWScript[StaticPopup1:IsVisible()]} { This:CustOutput["Reincarnation REPOPPING!"] This.Revived:Set[TRUE] This.ReincarnateCount:Set[0] WoWScript UseSoulstone() WoWScript RepopMe() } } return } member CanUseAnkh() { if ${Navigator.PointIsSafe[${Me.X},${Me.Y},${Me.Z}]} { if ${Item[-inventory,"Ankh"](exists)} && ${Spell[Reincarnation](exists)} && !${Spell[Reincarnation].Cooldown} { This:CustOutput["We can use Reincarnation here."] return TRUE } else { This:CustOutput["Can't self res!"] } } else { This:CustOutput["Not a safe spot to use Reincarnation"] } return FALSE } /**************************************/ /****************Rest******************/ member NeedRest() { if ${Me.InCombat} || ${Targeting.realAgg} return FALSE if ${This.LootFirst} return FALSE if ${Me.Buff[Resurrection Sickness](exists)} return TRUE if ${Me.PctHPs} < ${This.RestHP} return TRUE if ${Me.PctMana} < ${This.RestMP} return TRUE if ${Me.PctHPs} < ${This.StandHP} && ${Me.Sitting} return TRUE if ${Me.PctMana} < ${This.StandMP} && ${Me.Sitting} return TRUE return FALSE } method RestPulse() { if ${Me.InCombat} || ${Targeting.realAgg} return if ${Me.Casting} return if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward} { Toon:Stop return } if ${Me.Buff[Resurrection Sickness](exists)} { Toon:Sitdown return } if !${Me.Dead} && !${Me.Ghost} This:Revived:Set[FALSE] if ${This.ShouldCallTotems} { Toon:CastSpell["Totemic Call"] This:CustOutput["Calling my totems back"] return } if ((${Me.PctMana} >= ${This.StandMP}) && (${Me.PctHPs} >= ${This.StandHP})) && ${Me.Sitting} { Toon:Standup This:Output["Standing."] return } This:debuffAll if ${Me.PctHPs} < ${This.RestHP} && ${Spell[Cannibalize](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.Sitting} && !${Me.InCombat} && !${Spell[Cannibalize].Cooldown} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)}) && !${Me.Casting} { variable string corpseTarget if ${Object[-dead,-undead,-range 0-5](exists)} { corpseTarget:Set[${Object[-dead,-undead,-range 0-5].GUID}] } if ${Object[-dead,-humanoid,-range 0-5](exists)} { corpseTarget:Set[${Object[-dead,-humanoid,-range 0-5].GUID}] } if ${Object[${corpseTarget}].Distance} > 2 { Navigator:MoveToMob[${corpseTarget}] return } else { This:Output["Cannibalizing Corpse."] Toon:CastSpell[Cannibalize] return } } if !${Consumable.HasFood} && ${Me.PctHPs} < ${RestHP} && !${Me.Buff[Drink](exists)} && !${Me.Casting} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} { if ${Toon.canCast[Lesser Healing Wave]} { Toon:CastSpell[Lesser Healing Wave] This:CustOutput["Casting Lesser Healing Wave - Rest"] This.buffWaitTimer:Set[${This.InSeconds[20]}] return } elseif ${Toon.canCast[Healing Wave]} { Toon:CastSpell[Healing Wave] This:CustOutput["Casting Healing Wave - Rest"] This.buffWaitTimer:Set[${This.InSeconds[20]}] return } } if ${Me.PctHPs} < ${This.Bandage} && ${Toon.canBandage} && !${Me.Sitting} && ${This.UseBandages} { Toon:Bandage This:CustOutput["Bandaging...."] return } if ${Me.PctHPs} < ${This.RestHP} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting} && !${This.isPoisoned} && !${This.isDiseased} && !${Me.Sitting} { Consumable:useFood This:CustOutput["Eating..."] return } if ${Me.PctMana} < ${This.RestMP} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting} && !${This.isPoisoned} && !${This.isDiseased} && !${Me.Sitting} { Consumable:useDrink This:CustOutput["Drinking..."] return } if ${Me.PctMana} < ${This.RestMP} && ${Toon.canCast[Mana Spring Totem]} && !${This.OwnedTotemsCheck[Mana Spring Totem]} && ${This.HasWaterTotem} && !${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting} { Toon:CastSpell[Mana Spring Totem] This:CustOutput["Casting Mana Spring Totem"] } if ${Me.PctMana} >= ${This.StandMP} && !${Me.Casting} && !${Me.Buff[Resurrection Sickness](exists)} { Toon:Standup This:CustOutput["Done Resting!"] return } } /**************************************/ /****************Buff******************/ member NeedBuff() { if ${Me.Swimming} return TRUE if ${Me.InCombat} || ${Targeting.realAgg} return FALSE if ${Mount.IsMounted} return FALSE if ${Me.Swimming} && ${Toon.canCast[Water Walking]} && ${Item[-inventory,"Fish Oil"](exists)} && !${Me.Buff[Water Walking](exists)} { This:CustOutput["Swimming, need water walking"] return TRUE } if ${Me.Swimming} && !${Me.Race.Find[Undead]} && ${Toon.canCast[Water Breathing]} && ${Item[-inventory,"Shiny Fish Scales"](exists)} && !${Me.Buff[Water Breathing](exists)} { This:CustOutput["Swimming, need water breathing"] return TRUE } if ${Toon.canUseScroll} { This:CustOutput["Need a scroll buff"] return TRUE } if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast["${This.MainHand} Weapon"]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]} { This:CustOutput["Need Mainhand Buff - ${This.MainHand}"] return TRUE } if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast["${This.OffHand} Weapon"]} && ${This.DW} && !${This.OffHand.Equal[None]} { This:CustOutput["Need Offhand Buff - ${This.OffHand}"] return TRUE } if !${Me.Buff[${Shield}](exists)} && ${This.canBuff[${This.Shield}]} return TRUE return FALSE } method BuffPulse() { if ${Me.Swimming} { if ${This.jumpTimer} < ${LavishScript.RunningTime} { wowpress JUMP This.jumpTimer:Set[${This.InSeconds[5]}] } if ${Target(exists)} { Toon:ToMelee } return } if ${Me.InCombat} || ${Targeting.realAgg} return if ${Me.Casting} return if ${Me.Sitting} Toon:Standup if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward} { Move -stop return } if ${Me.Swimming} && ${Toon.canCast[Water Walking]} && ${Item[-inventory,"Fish Oil"](exists)} && !${Me.Buff[Water Walking](exists)} { Toon:CastSpell[Water Walking] This:CustOutput["Casting Water Walking"] return } if ${Me.Swimming} && !${Me.Race.Find[Undead]} && ${Toon.canCast[Water Breathing]} && ${Item[-inventory,"Shiny Fish Scales"](exists)} && !${Me.Buff[Water Breathing](exists)} { Toon:CastSpell[Water Breathing] This:CustOutput["Casting Water Breathing"] return } if ${Toon.canUseScroll} { Toon:UseScroll This:CustOutput["Using a scroll"] return } if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast[${This.MainHand} Weapon]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]} { Toon:CastSpell[${This.MainHand} Weapon] This:CustOutput["Casting ${This.MainHand} Weapon"] This.buffWaitTimer:Set[${This.InSeconds[20]}] return } if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast[${This.OffHand} Weapon]} && ${This.DW} && !${This.OffHand.Equal[None]} { Toon:CastSpell[${This.OffHand} Weapon] This:CustOutput["Casting ${This.OffHand} Weapon"] return } if !${Me.Buff[${Shield}](exists)} && ${This.canBuff[${This.Shield}]} { Toon:CastSpell[${This.Shield}] return } } /**************************************/ /**************Pull Buff***************/ member NeedPullBuff() { if !${Me.Buff[${This.Shield}](exists)} && ${This.canBuff[${This.Shield}]} && !${This.isImmune[${This.Shield}]} return TRUE return FALSE } method PullBuffPulse() { if ${Me.Sitting} Toon:Standup if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward} { Toon:Stop return } if !${Me.Buff[${This.Shield}](exists)} && ${This.canBuff[${This.Shield}]} && !${This.isImmune[${This.Shield}]} { Toon:CastSpell[${Shield}] This:CustOutput["Casting ${This.Shield}"] return } return } /**************************************/ /*************Combat Buff**************/ member NeedCombatBuff() { if ${Me.Sitting} Toon:Standup if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]} return TRUE if ${This.canBuff[${This.Shield}]} && ${Target.PctHPs} > 30 && !${This.isImmune[${This.Shield}]} return TRUE if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85 return TRUE if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30 return TRUE if ${Toon.canCast[Mana Spring Totem]} && ${Me.PctMana} < 30 return TRUE if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70 return TRUE if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70 return TRUE return FALSE } method CombatBuffPulse() { if ${Me.Sitting} Toon:Standup if ${Toon.canCast["Nature's Swiftness"]} { Toon:CastSpell["Nature's Swiftness"] return } if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]} && !${Me.Casting} { Toon:CastSpell[Gift of the Naaru] This:CustOutput["Casting Gift of the Naaru"] return } if ${This.canBuff[${This.Shield}, ${Me.GUID}]} && !${Me.Buff[${This.Shield}](exists)} && !${Me.Casting} && !${This.isImmune[${This.Shield}]} { Toon:CastSpell[${Shield}] This:CustOutput["Casting ${Shield}"] return } if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30 { Toon:CastSpell[Elemental Mastery] This:CustOutput["Casting Elemental Mastery!!!"] return } if ${Toon.canCast[Mana Spring Totem]} && ${Me.PctMana} < 30 && !${This.OwnedTotemsCheck[Mana Spring Totem]} { Toon:CastSpell[Mana Spring Totem] This:CustOutput["Casting Mana Spring Totem!!!"] return } if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70 { Toon:CastSpell[Heroism] This:CustOutput["Casting Heroism!!!"] return } if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70 { Toon:CastSpell[Bloodlust] This:CustOutput["Casting Bloodlust!!!"] return } } /**************************************/ /****************Pull******************/ method PullPulse() { if ${Me.Sitting} Toon:Standup if !${Toon.ValidTarget[${Target.GUID}]} || ${Target.Dead} { Toon:NeedTarget[1] return } Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if ${Me.Casting} || ${Me.GlobalCooldown} return if !${Me.Attacking} && ${Target.Distance} <= ${Toon.MaxMelee} { WoWScript AttackTarget() This:CustOutput["Turning on autoattack"] return } if ${Target.PctHPs} == 100 { ; Creature is 100% life, assuming new target resetting runner logic This.RunnerDealtWith:Set[FALSE] This.BackupAttempts:Set[0] } if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Healing Wave] This:CustOutput["Casting Healing Wave"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Lesser Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Lesser Healing Wave] This:CustOutput["Casting Lesser Healing Wave"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Chain Heal] This:CustOutput["Casting Chain Heal"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Target.Distance} < ${Toon.MinRanged} || ${This.isImmune[${This.PullSpell}]} && !${Me.Casting} { WoWScript AttackTarget() This:CustOutput["Turning on autoattack"] Toon:ToMelee return } if !${This.UsePull} { if !${Toon.withinMelee} { Toon:ToMelee This:CustOutput["Melee Pulling ${Target.Name}"] return } } if ${This.UsePull} { if ${Toon.withinRanged} { if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward} { Toon:Stop return } if ${Target.Distance} >= ${Toon.MinRanged} && ${Me.PctMana} > ${This.ConserveMana} { if ${Toon.canCast[${This.PullSpell}]} { Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] Toon:CastSpell[${This.PullSpell}] This:CustOutput["Pulling With: ${This.PullSpell}"] return } } } elseif !${Me.Casting} { if ${Target.Distance} > ${Toon.MaxRanged} { This:CustOutput["Target too far away. Moving closer."] Toon:ToRanged } elseif ${Target.Distance} < ${Toon.MinRanged} { WoWScript AttackTarget() This:CustOutput["Turning on autoattack"] This:AttackPulse } } } Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] return } /**************************************/ /***************Attack*****************/ method AttackPulse() { if ${Me.Sitting} Toon:Standup if !${Toon.ValidTarget[${Target.GUID}]} || ${Target.Dead} { Toon:NeedTarget[1] return } if !${Toon.TargetIsBestTarget} || ${Target.IsTotem} Toon:BestTarget Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if !${Me.Attacking} && ${Target.Distance} <= ${Toon.MaxMelee} { WoWScript AttackTarget() This:CustOutput["Turning on autoattack"] } if ${Target.Distance} >= ${Toon.MinRanged} && ${Me.PctMana} > ${This.ConserveMana} { This:PullPulse } This:SetDanger if ${This.HaveAdds} && ${Toon.canCast[War Stomp]} && !${Me.Casting} { Toon:CastSpell[War Stomp] } Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] This:debuffAll if ${Target.Distance} < ${Toon.MinMelee} && ${This.BackupAttempts} < 6 && !${Me.Casting} { This:Output["Backing up... wtf"] This.BackupAttempts:Inc Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] Navigator:MoveBackward[200] return } if ${Target.Distance} > ${Toon.MaxMelee} && !${Me.Casting} { This:Output["Chasing down ${Target.Name}"] Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] wowpress -hold moveforward return } else { Toon:Stop } if ${Target.Dead} return if !${This.RunnerDealtWith} && ${Target.PctHPs} < 40 && ${This.isRunner} { Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if ${Toon.canCast[Frost Shock]} && !${This.isImmune[Frost Shock]} { Toon:CastSpell[Frost Shock] This:CustOutput["Casting Frost Shock on a runner"] This.RunnerDealtWith:Set[TRUE] return } if ${Toon.canCast[Earthbind Totem]} && !${This.OwnedTotemsCheck[Earthbind Totem]} && ${This.HasEarthTotem} { Toon:CastSpell[Earthbind Totem] This:CustOutput["Casting Earthbind Totem to catch a runner"] This.RunnerDealtWith:Set[TRUE] return } } if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Healing Wave] This:CustOutput["Casting Healing Wave"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Lesser Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Lesser Healing Wave] This:CustOutput["Casting Lesser Healing Wave"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime} { Toon:CastSpell[Chain Heal] This:CustOutput["Casting Chain Heal"] This.healWaitTimer:Set[${This.InSeconds[4]}] return } if ${Me.PctHPs} < ${This.HPot} && ${This.UseHPot} && ${Consumable.HasHPot} && ${This.PotTimer} < ${LavishScript.RunningTime} { Consumable:useHPot This:CustOutput["Quaffing a health pot"] This.PotTimer:Set[${This.InSeconds[120]}] return } if ${Me.PctMana} < ${This.MPot} && ${This.UseMPot} && ${Consumable.HasMPot} && ${This.PotTimer} < ${LavishScript.RunningTime} { Consumable:useMPot This:CustOutput["Quaffing a mana pot"] This.PotTimer:Set[${This.InSeconds[120]}] return } if ${Target.Dead} return if ${Dangerlvl} >= 1 { if ${Target.PctHPs} > 50 || ${This.HaveAdds} { Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if ${This.HaveAdds} && ${Toon.canCast[Stoneclaw Totem]} && !${This.OwnedTotemsCheck[Stoneclaw Totem]} { Toon:CastSpell[Stoneclaw Totem] This:CustOutput["Casting Stoneclaw Totem because of Add!"] return } if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem} { Toon:CastSpell[${This.EarthTotem}] This:CustOutput["Casting ${This.EarthTotem}"] return } if ${This.canCastTotem[Air]} && ${This.HasAirTotem} { Toon:CastSpell[${This.AirTotem}] This:CustOutput["Casting ${This.AirTotem}"] return } if ${This.canCastTotem[Fire]} && ${This.HasFireTotem} { Toon:CastSpell[${This.FireTotem}] This:CustOutput["Casting ${This.FireTotem}"] return } if ${This.canCastTotem[Water]} && ${This.HasWaterTotem} { Toon:CastSpell[${This.WaterTotem}] This:CustOutput["Casting ${This.WaterTotem}"] return } if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem} { Toon:CastRandom[AirTotems] This:CustOutput["Casting a random Air Totem"] This.AirTotemTimer:Set[${This.InSeconds[80]}] return } if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem} { Toon:CastRandom[EarthTotems] This:CustOutput["Casting a random Earth Totem"] This.EarthTotemTimer:Set[${This.InSeconds[80]}] return } if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem} { Toon:CastRandom[WaterTotems] This:CustOutput["Casting a random Water Totem"] This.WaterTotemTimer:Set[${This.InSeconds[80]}] return } if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem} { Toon:CastRandom[FireTotems] This:CustOutput["Casting a random Fire Totem"] This.FireTotemTimer:Set[${This.InSeconds[80]}] return } } } if ${Target.Dead} return if ${This.HaveAdds} && ${Toon.canCast[Shamanistic Rage]} { Toon:CastSpell[Shamanistic Rage] This:CustOutput["Casting Shamanistic Rage!!!"] return } Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if ${This.HaveAdds} && ${Toon.canCast[Chain Lightning]} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly} { Toon:CastSpell[Chain Lightning] This:CustOutput["Casting Chain Lightning due to an add!"] return } if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${Target.Casting(exists)} { This:StopCast This:CustOutput["Silencing ${Target} - Attack"] Toon:CastSpell[Earth Shock] } if ${Toon.canCast[Stormstrike]} && !${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange} { Toon:CastSpell[Stormstrike] This:CustOutput["Casting Stormstrike"] return } if ${Target.Dead} return Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}] if !${This.SaveShocks} || (${This.SaveShocks} && ${Me.Buff[Focused](exists)}) { if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange} { Toon:CastSpell[Earth Shock] This:CustOutput["Casting Earth Shock on Stormstruck ${Target}!"] return } if ${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange} { if (${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks} { This:CastRandom[Shocks,"Target"] return } } if ${This.canBuff[Flame Shock, ${Target.GUID}]} && !${This.isImmune[Flame Shock]} && ${This.UseFlameShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange} { Toon:CastSpell[Flame Shock] This:CustOutput["Casting Flame Shock"] return } if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${This.UseEarthShock} && !${This.RandomShock} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange} { Toon:CastSpell[Earth Shock] This:CustOutput["Casting Earth Shock"] return } if ${Toon.canCast[Frost Shock]} && !${This.isImmune[Frost Shock]} && ${This.UseFrostShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange} { Toon:CastSpell[Frost Shock] This:CustOutput["Casting Frost Shock"] return } if ${Toon.canCast[Lightning Bolt]} && !${This.isImmune[Lightning Bolt]} && ${This.UseLBolt} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly} { Toon:CastSpell[Lightning Bolt] This:CustOutput["Casting Lightning Bolt"] return } } } /**************************************/ /***************Totems*****************/ method SetTotems() { if ${Item[-items,-inventory,"Earth Totem"](exists)} { This.HasEarthTotem:Set[TRUE] This:CustOutput["We have an Earth Totem in our bags, we can use them now!"] } else { This.HasEarthTotem:Set[FALSE] This:CustOutput["No Earth Totem found! Not using them."] } if ${Item[-items,-inventory,"Fire Totem"](exists)} { This.HasFireTotem:Set[TRUE] This:CustOutput["We have an Fire Totem in our bags, we can use them now!"] } else { This.HasFireTotem:Set[FALSE] This:CustOutput["No Fire Totem found! Not using them."] } if ${Item[-items,-inventory,"Water Totem"](exists)} { This.HasWaterTotem:Set[TRUE] This:CustOutput["We have an Water Totem in our bags, we can use them now!"] } else { This.HasWaterTotem:Set[FALSE] This:CustOutput["No Water Totem found! Not using them."] } if ${Item[-items,-inventory,"Wind Totem"](exists)} { This.HasWindTotem:Set[TRUE] This:CustOutput["We have an Wind Totem in our bags, we can use them now!"] } else { This.HasWindTotem:Set[FALSE] This:CustOutput["No Wind Totem found! Not using them."] } return } member canCastTotem(string totemType) { if ${Toon.canCast[${This.${totemType}Totem}]} && !${This.OwnedTotemsCheck[${This.${totemType}Totem}]} && !${This.${totemType}Totem.Equal["Random"]} && !${This.${totemType}Totem.Equal["None"]} return TRUE return FALSE } member OwnedTotemsCheck(string totem) { if ${Unit[-units, -owner, -range 0-20, ${totem}](exists)} { return TRUE TotemList:Clear } return FALSE } member ShouldCallTotems() { if ${This.OwnedTotemsCheck[totem]} && !${This.OwnedTotemsCheck[Mana Spring Totem]} && !${This.OwnedTotemsCheck[Poison Cleansing Totem]} && !${Me.Target(exists)} && ${Toon.canCast[Totemic Call]} return TRUE return FALSE } /**************************************/ /*************Aggro & Adds*************/ method SetDanger() { variable guidlist Aggros Aggros:Search[-units,-nearest,-aggro,-alive,-targetingme,-range 0-40] This.DangerLevel:Set[${DangerLevel} * 0.5] This.DangerLevel:Set[${DangerLevel} + ${Aggros.Count}*6.5] This.DangerLevel:Set[${DangerLevel} + ((100 - ${Me.PctMana})*0.10)] if ${Target.Level} > ${Me.Level} { This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*2)] } elseif ${Me.Level} > ${Target.Level} { This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*1)] } if ${Target.Classification.Equal[Elite]} || ${Target.Classification.Equal[RareElite]} This.DangerLevel:Set[${DangerLevel} + 20] if ${Target.PctHPs} < 25 This.DangerLevel:Set[${DangerLevel} - 10] if ${DangerLevel} < 0 This.DangerLevel:Set[0] UIElement[DangerLevel@Titlebar@ClassGUI]:SetValue[${DangerLevel}] if ${DangerLevel} >= ${DangerVeryHigh} { This:CustOutput["Danger - Very High ${DangerLevel}"] This.Dangerlvl:Set[3] return } elseif ${DangerLevel} > ${DangerHigh} { This:CustOutput["Danger - High ${DangerLevel}"] This.Dangerlvl:Set[2] return } elseif ${DangerLevel} > ${DangerMedium} { ;This:CustOutput["Danger - Medium ${DangerLevel}"] This.Dangerlvl:Set[1] return } else { ;This:CustOutput["Danger - Low ${DangerLevel}"] This.Dangerlvl:Set[0] return } } member HaveAdds() { variable guidlist AggroList AggroList:Clear AggroList:Search[-units,-nearest,-nopets,-aggro,-alive,-range 0-30] if ${AggroList.Count} >= 2 { return TRUE } else { return FALSE } } /**************************************/ /***********Spells & Casting***********/ method InitRandoms() { This:SetRandoms["Earth Shock","Shocks"] This:SetRandoms["Flame Shock","Shocks"] This:SetRandoms["Frost Shock","Shocks"] This:SetRandoms["Lightning Bolt","Attacks"] This:SetRandoms["Chain Lightning","Attacks"] This:SetRandoms["Lightning Shield","Shields"] This:SetRandoms["Water Shield","Shields"] This:SetRandoms["Earth Shield","Shields"] This:SetRandoms["Earthbind Totem","EarthTotems"] This:SetRandoms["Stoneskin Totem","EarthTotems"] This:SetRandoms["Stoneclaw Totem","EarthTotems"] This:SetRandoms["Strength of Earth Totem","EarthTotems"] This:SetRandoms["Tremor Totem","EarthTotems"] This:SetRandoms["Searing Totem","FireTotems"] This:SetRandoms["Fire Nova Totem","FireTotems"] This:SetRandoms["Magma Totem","FireTotems"] This:SetRandoms["Totem of Wrath","FireTotems"] This:SetRandoms["Windwall Totem","AirTotems"] This:SetRandoms["Grounding Totem","AirTotems"] This:SetRandoms["Grace of Air Totem","AirTotems"] This:SetRandoms["Wrath of Air Totem","AirTotems"] This:SetRandoms["Healing Stream Totem","WaterTotems"] This:SetRandoms["Mana Spring Totem","WaterTotems"] } method SetRandoms(string SpellName, string RandomSet) { if ${Spell[${SpellName}](exists)} { This:AddRandom[${RandomSet},${SpellName}] } else { This:CustOutput["Couldn't add ${SpellName} into ${RandomSet} because we don't have the spell!"] } } method AddRandom(string spellGroup, string spellName) { if !${This.RandomCast.Element[${spellGroup}](exists)} && ${Bot.Started} { This.RandomCast:Set[${spellGroup}] This.RandomCastCount:Set[${spellGroup},0] } This.RandomCast.Element[${spellGroup}]:Insert[${spellName}] This.RandomCastCount.Element[${spellGroup}]:Inc } member CastRandom(string spellGroup, string checkBuff=NULL) { variable int attempts = 0 variable int spellNum = 1 spellNum:Inc[${Math.Rand[${This.RandomCastCount.Element[${spellGroup}]}]}] do { if ${spellNum} > ${This.RandomCastCount.Element[${spellGroup}]} { spellNum:Inc } if ${Toon.canCast[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]} && !${This.isImmune[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]} { if ${checkBuff.Equal[Target]} || ${checkBuff.Equal[Me]} { if !${${checkBuff}.Buff[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}](exists)} { Toon:CastSpell[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}] This:Output["Casting Random Buff#${spellNum}:${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}"] return TRUE } } else { Toon:CastSpell[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}] This:Output["Casting Random#${spellNum}:${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}"] return TRUE } } spellNum:Inc } while ${attempts:Inc} <= ${This.RandomCastCount.Element[${spellGroup}]} return FALSE } method CastRandom(string spellGroup, string checkBuff=NULL) { if !${This.CastRandom[${spellGroup},${checkBuff}]} { This:Debug[RandomCast ${spellGroup} failed] } } member canBuff(string buffName, string theGUID=NULL, string spellName=NULL) { if ${spellName.Equal[NULL]} spellName:Set[${buffName}] if ${theGUID.Equal[NULL]} theGUID:Set[${Me.GUID}] if !${Object[${theGUID}].Buff[${buffName}](exists)} && ${Toon.canCast[${spellName}]} return TRUE return FALSE } member ShouldConserveMana() { if ${Me.PctMana} > ${This.ConserveMana} return TRUE return FALSE } method debuffAll() { if ${Me.PctMana} < 15 || ${Me.Casting} return BuffNum:Set[1] while ${BuffNum} < 16 { BuffNum:Inc if ${Target.Buff.DispelType.Equal[Magic]} && !${Target.Buff.Harmful} { if ${Toon.canCast[Purge]} && !${Me.Casting} { This:CustOutput["Purging a buff on ${Target}"] Toon:CastSpell[Purge] return } } if ${Me.Buff[${BuffNum}].Harmful} { if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]} { if ${Toon.canCast[Cure Disease]} && ${This.cureDiseaseTimer} < ${LavishScript.RunningTime} { This:CustOutput["Curing a disease"] Toon:CastSpell[Cure Disease] This.cureDiseaseTimer:Set[${This.InSeconds[20]}] return } elseif ${Toon.canCast[Disease Cleansing Totem]} && !${This.OwnedTotemsCheck[Disease Cleansing Totem]} && ${This.HasWaterTotem} { Toon:CastSpell[Disease Cleansing Totem] This:CustOutput["Casting Disease Cleansing Totem"] } } if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]} { if ${Toon.canCast[Cure Poison]} && ${This.curePoisonTimer} < ${LavishScript.RunningTime} { This:CustOutput["Curing a poison"] Toon:CastSpell[Cure Poison] This.curePoisonTimer:Set[${This.InSeconds[20]}] return } elseif ${Toon.canCast[Poison Cleansing Totem]} && !${This.OwnedTotemsCheck[Poison Cleansing Totem]} && ${This.HasWaterTotem} { Toon:CastSpell[Poison Cleansing Totem] This:CustOutput["Casting Poison Cleansing Totem"] } } } } return } member LootFirst() { if ${Me.Sitting} || ${Me.Casting} return FALSE if ${Unit[-dead,-lootable,-range 0-10](exists)} return TRUE if ${Toon.HasSkill[Skinning]} { if ${Unit[-dead,-skinnable,-range 0-10](exists)} && ${Item[-inventory,"Skinning Knife"](exists)} return TRUE } if ${LavishScript.RunningTime} <= ${State.LOOTState_Loot_Wait_Until} return TRUE return FALSE } /**************************************/ /*************Other Misc***************/ method CustOutput(string myMessage) { if ${This.Output} UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"] return } /**************************************/ /***********GUI Load & Save************/ method SaveConfig() { Config:SetSetting["${RealmChar}","UsePull",${This.UsePull}] Config:SetSetting["${RealmChar}","PullSpell",${This.PullSpell}] Config:SetSetting["${RealmChar}","RestMP",${This.RestMP}] Config:SetSetting["${RealmChar}","RestHP",${This.RestHP}] Config:SetSetting["${RealmChar}","StandMP",${This.StandMP}] Config:SetSetting["${RealmChar}","StandHP",${This.StandHP}] Config:SetSetting["${RealmChar}","EarthTotem",${This.EarthTotem}] Config:SetSetting["${RealmChar}","AirTotem",${This.AirTotem}] Config:SetSetting["${RealmChar}","FireTotem",${This.FireTotem}] Config:SetSetting["${RealmChar}","WaterTotem",${This.WaterTotem}] Config:SetSetting["${RealmChar}","UseEarthElemental",${This.UseEarthElemental}] Config:SetSetting["${RealmChar}","UseFireElemental",${This.UseFireElemental}] Config:SetSetting["${RealmChar}","UseEarthShock",${This.UseEarthShock}] Config:SetSetting["${RealmChar}","UseFlameShock",${This.UseFlameShock}] Config:SetSetting["${RealmChar}","UseFrostShock",${This.UseFrostShock}] Config:SetSetting["${RealmChar}","RandomShock",${This.RandomShock}] Config:SetSetting["${RealmChar}","SaveShocks",${This.SaveShocks}] Config:SetSetting["${RealmChar}","ConserveMana",${This.ConserveMana}] Config:SetSetting["${RealmChar}","UseLBolt",${This.UseLBolt}] Config:SetSetting["${RealmChar}","UseChainLight",${This.UseChainLight}] Config:SetSetting["${RealmChar}","MainHand",${This.MainHand}] Config:SetSetting["${RealmChar}","OffHand",${This.OffHand}] Config:SetSetting["${RealmChar}","DW",${This.DW}] Config:SetSetting["${RealmChar}","ShieldOnPull",${This.ShieldOnPull}] Config:SetSetting["${RealmChar}","HealWave",${This.HealWave}] Config:SetSetting["${RealmChar}","LHealWave",${This.LHealWave}] Config:SetSetting["${RealmChar}","ChainHeal",${This.ChainHeal}] Config:SetSetting["${RealmChar}","GOTN",${This.GOTN}] Config:SetSetting["${RealmChar}","Output",${This.Output}] Config:SetSetting["${RealmChar}","UseReincarnation",${This.UseReincarnation}] Config:SetSetting["${RealmChar}","UseMPot",${This.UseMPot}] Config:SetSetting["${RealmChar}","UseHPot",${This.UseHPot}] Config:SetSetting["${RealmChar}","UseBandages",${This.UseBandages}] Config:SetSetting["${RealmChar}","MPot",${This.MPot}] Config:SetSetting["${RealmChar}","HPot",${This.HPot}] Config:SetSetting["${RealmChar}","Bandage",${This.Bandage}] Config:SetSetting["${RealmChar}","Shield",${This.Shield}] Config:SetSetting["${RealmChar}","MeleeOnly",${This.MeleeOnly}] } method LoadConfig() { This.UsePull:Set[${Config.GetSetting["${RealmChar}","UsePull"]}] This.PullSpell:Set[${Config.GetSetting["${RealmChar}","PullSpell"]}] This.RestMP:Set[${Config.GetSetting["${RealmChar}","RestMP"]}] This.RestHP:Set[${Config.GetSetting["${RealmChar}","RestHP"]}] This.StandMP:Set[${Config.GetSetting["${RealmChar}","StandMP"]}] This.StandHP:Set[${Config.GetSetting["${RealmChar}","StandHP"]}] This.EarthTotem:Set[${Config.GetSetting["${RealmChar}","EarthTotem"]}] This.AirTotem:Set[${Config.GetSetting["${RealmChar}","AirTotem"]}] This.WaterTotem:Set[${Config.GetSetting["${RealmChar}","WaterTotem"]}] This.FireTotem:Set[${Config.GetSetting["${RealmChar}","FireTotem"]}] This.UseEarthElemental:Set[${Config.GetSetting["${RealmChar}","UseEarthElemental"]}] This.UseFireElemental:Set[${Config.GetSetting["${RealmChar}","UseFireElemental"]}] This.UseEarthShock:Set[${Config.GetSetting["${RealmChar}","UseEarthShock"]}] This.UseFlameShock:Set[${Config.GetSetting["${RealmChar}","UseFlameShock"]}] This.UseFrostShock:Set[${Config.GetSetting["${RealmChar}","UseFrostShock"]}] This.RandomShock:Set[${Config.GetSetting["${RealmChar}","RandomShock"]}] This.SaveShocks:Set[${Config.GetSetting["${RealmChar}","SaveShocks"]}] This.ConserveMana:Set[${Config.GetSetting["${RealmChar}","ConserveMana"]}] This.UseLBolt:Set[${Config.GetSetting["${RealmChar}","UseLBolt"]}] This.UseChainLight:Set[${Config.GetSetting["${RealmChar}","UseChainLight"]}] This.MainHand:Set[${Config.GetSetting["${RealmChar}","MainHand"]}] This.OffHand:Set[${Config.GetSetting["${RealmChar}","OffHand"]}] This.DW:Set[${Config.GetSetting["${RealmChar}","DW"]}] This.ShieldOnPull:Set[${Config.GetSetting["${RealmChar}","ShieldOnPull"]}] This.HealWave:Set[${Config.GetSetting["${RealmChar}","HealWave"]}] This.LHealWave:Set[${Config.GetSetting["${RealmChar}","LHealWave"]}] This.ChainHeal:Set[${Config.GetSetting["${RealmChar}","ChainHeal"]}] This.GOTN:Set[${Config.GetSetting["${RealmChar}","GOTN"]}] This.Output:Set[${Config.GetSetting["${RealmChar}","Output"]}] This.UseReincarnation:Set[${Config.GetSetting["${RealmChar}","UseReincarnation"]}] This.UseMPot:Set[${Config.GetSetting["${RealmChar}","UseMPot"]}] This.UseHPot:Set[${Config.GetSetting["${RealmChar}","UseHPot"]}] This.UseBandages:Set[${Config.GetSetting["${RealmChar}","UseBandages"]}] This.MPot:Set[${Config.GetSetting["${RealmChar}","MPot"]}] This.HPot:Set[${Config.GetSetting["${RealmChar}","HPot"]}] This.Bandage:Set[${Config.GetSetting["${RealmChar}","Bandage"]}] This.Shield:Set[${Config.GetSetting["${RealmChar}","Shield"]}] This.MeleeOnly:Set[${Config.GetSetting["${RealmChar}","MeleeOnly"]}] } method InitShamanGUI() { if ${This.UsePull} UIElement[UsePull@Main@Pages@ClassGUI]:SetChecked if ${This.UseReincarnation} UIElement[UseReincarnation@Main@Pages@ClassGUI]:SetChecked if ${This.UseMPot} UIElement[UseMPot@Main@Pages@ClassGUI]:SetChecked if ${This.UseHPot} UIElement[UseHPot@Main@Pages@ClassGUI]:SetChecked if ${This.UseBandages} UIElement[UseBandages@Main@Pages@ClassGUI]:SetChecked if ${This.MeleeOnly} UIElement[MeleeOnly@Main@Pages@ClassGUI]:SetChecked if ${This.UseEarthElemental} UIElement[EarthElemental@Totems@Pages@ClassGUI]:SetChecked if ${This.UseFireElemental} UIElement[FireElemental@Totems@Pages@ClassGUI]:SetChecked if ${This.UseEarthShock} UIElement[EarthShock@Spells@Pages@ClassGUI]:SetChecked if ${This.UseFlameShock} UIElement[FlameShock@Spells@Pages@ClassGUI]:SetChecked if ${This.UseFrostShock} UIElement[FrostShock@Spells@Pages@ClassGUI]:SetChecked if ${This.RandomShock} UIElement[RandomShock@Spells@Pages@ClassGUI]:SetChecked if ${This.SaveShocks} UIElement[SaveShocks@Spells@Pages@ClassGUI]:SetChecked if ${This.UseLBolt} UIElement[LightBolt@Spells@Pages@ClassGUI]:SetChecked if ${This.UseChainLight} UIElement[UseChainLight@Spells@Pages@ClassGUI]:SetChecked if ${This.DW} UIElement[DW@Buffs@Pages@ClassGUI]:SetChecked if ${This.ShieldOnPull} UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked if ${This.Output} UIElement[EnableOutput@Other@Pages@ClassGUI]:SetChecked variable int i = 1 for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc) { if ${This.PullSpell.Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[EarthTotem@Totems@Pages@ClassGUI].Items} ; i:Inc) { if ${This.EarthTotem.Equal["${UIElement[EarthTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[EarthTotem@Totems@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[WaterTotem@Totems@Pages@ClassGUI].Items} ; i:Inc) { if ${This.WaterTotem.Equal["${UIElement[WaterTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[WaterTotem@Totems@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[FireTotem@Totems@Pages@ClassGUI].Items} ; i:Inc) { if ${This.FireTotem.Equal["${UIElement[FireTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[FireTotem@Totems@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[AirTotem@Totems@Pages@ClassGUI].Items} ; i:Inc) { if ${This.AirTotem.Equal["${UIElement[AirTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[AirTotem@Totems@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[MainHand@Buffs@Pages@ClassGUI].Items} ; i:Inc) { if ${This.MainHand.Equal["${UIElement[MainHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[MainHand@Buffs@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[OffHand@Buffs@Pages@ClassGUI].Items} ; i:Inc) { if ${This.OffHand.Equal["${UIElement[OffHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[OffHand@Buffs@Pages@ClassGUI]:SelectItem[${i}] } for (i:Set[1] ; ${i} <= ${UIElement[Shield@Buffs@Pages@ClassGUI].Items} ; i:Inc) { if ${This.Shield.Equal["${UIElement[Shield@Buffs@Pages@ClassGUI].Item[${i}].Text}"]} UIElement[Shield@Buffs@Pages@ClassGUI]:SelectItem[${i}] } if ${This.RestMP} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value} UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.RestMP}] if ${This.RestHP} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value} UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.RestHP}] if ${This.StandMP} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value} UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.StandMP}] if ${This.StandHP} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value} UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.StandHP}] if ${This.ConserveMana} != ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value} UIElement[ConserveMana@Main@Pages@ClassGUI]:SetValue[${This.ConserveMana}] if ${This.MPot} != ${UIElement[MPot@Main@Pages@ClassGUI].Value} UIElement[MPot@Main@Pages@ClassGUI]:SetValue[${This.MPot}] if ${This.HPot} != ${UIElement[HPot@Main@Pages@ClassGUI].Value} UIElement[HPot@Main@Pages@ClassGUI]:SetValue[${This.HPot}] if ${This.Bandage} != ${UIElement[Bandage@Main@Pages@ClassGUI].Value} UIElement[Bandage@Main@Pages@ClassGUI]:SetValue[${This.Bandage}] if ${This.HealWave} != ${UIElement[HealWave@Heals@Pages@ClassGUI].Value} UIElement[HealWave@Heals@Pages@ClassGUI]:SetValue[${This.HealWave}] if ${This.LHealWave} != ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value} UIElement[LHealWave@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}] if ${This.ChainHeal} != ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value} UIElement[ChainHeal@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}] if ${This.GOTN} != ${UIElement[GOTN@Heals@Pages@ClassGUI].Value} UIElement[GOTN@Heals@Pages@ClassGUI]:SetValue[${This.GOTN}] } method ClassGUIChange(string Action) { switch ${Action} { case PullSpell if ${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem.Value(exists)} This.PullSpell:Set[${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}] break case EarthTotem if ${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)} This.EarthTotem:Set[${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem}] break case FireTotem if ${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)} This.FireTotem:Set[${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem}] break case AirTotem if ${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)} This.AirTotem:Set[${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem}] break case WaterTotem if ${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)} This.WaterTotem:Set[${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem}] break case MainHand if ${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)} This.MainHand:Set[${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem}] break case OffHand if ${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)} This.OffHand:Set[${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem}] break case Shield if ${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)} This.Shield:Set[${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem}] break /* checkboxes */ case UsePull if ${UIElement[UsePull@Main@Pages@ClassGUI].Checked} This.UsePull:Set[TRUE] if !${UIElement[UsePull@Main@Pages@ClassGUI].Checked} This.UsePull:Set[FALSE] break case UseReincarnation if ${UIElement[UseReincarnation@Main@Pages@ClassGUI].Checked} This.UseReincarnation:Set[TRUE] if !${UIElement[UseReincarnation@Main@Pages@ClassGUI].Checked} This.UseReincarnation:Set[FALSE] break case UseHPot if ${UIElement[UseHPot@Main@Pages@ClassGUI].Checked} This.UseHPot:Set[TRUE] if !${UIElement[UseHPot@Main@Pages@ClassGUI].Checked} This.UseHPot:Set[FALSE] break case UseMPot if ${UIElement[UseMPot@Main@Pages@ClassGUI].Checked} This.UseMPot:Set[TRUE] if !${UIElement[UseMPot@Main@Pages@ClassGUI].Checked} This.UseMPot:Set[FALSE] break case UseBandages if ${UIElement[UseBandages@Main@Pages@ClassGUI].Checked} This.UseBandages:Set[TRUE] if !${UIElement[UseBandages@Main@Pages@ClassGUI].Checked} This.UseBandages:Set[FALSE] break case MeleeOnly if ${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked} This.MeleeOnly:Set[TRUE] if !${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked} This.MeleeOnly:Set[FALSE] break case EarthElemental if ${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked} This.UseEarthElemental:Set[TRUE] if !${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked} This.UseEarthElemental:Set[FALSE] break case FireElemental if ${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked} This.UseFireElemental:Set[TRUE] if !${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked} This.UseFireElemental:Set[FALSE] break case FlameShock if ${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked} This.UseFlameShock:Set[TRUE] if !${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked} This.UseFlameShock:Set[FALSE] break case EarthShock if ${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked} This.UseEarthShock:Set[TRUE] if !${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked} This.UseEarthShock:Set[FALSE] break case FrostShock if ${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked} This.UseFrostShock:Set[TRUE] if !${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked} This.UseFrostShock:Set[FALSE] break case RandomShock if ${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked} This.RandomShock:Set[TRUE] if !${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked} This.RandomShock:Set[FALSE] break case SaveShocks if ${UIElement[SaveShocks@Spells@Pages@ClassGUI].Checked} This.SaveShocks:Set[TRUE] if !${UIElement[SaveShocks@Spells@Pages@ClassGUI].Checked} This.SaveShocks:Set[FALSE] break case UseLBolt if ${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked} This.UseLBolt:Set[TRUE] if !${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked} This.UseLBolt:Set[FALSE] break case UseChainLight if ${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked} This.UseChainLight:Set[TRUE] if !${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked} This.UseChainLight:Set[FALSE] break case DW if ${UIElement[DW@Buffs@Pages@ClassGUI].Checked} This.DW:Set[TRUE] if !${UIElement[DW@Buffs@Pages@ClassGUI].Checked} This.DW:Set[FALSE] break case ShieldOnPull if ${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked} This.ShieldOnPull:Set[TRUE] if !${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked} This.ShieldOnPull:Set[FALSE] break case EnableOutput if ${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked} This.Output:Set[TRUE] if !${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked} This.Output:Set[FALSE] break /* sliders */ case RestMP if ${UIElement[RestMP@Main@Pages@ClassGUI].Value(exists)} This.RestMP:Set[${UIElement[RestMP@Main@Pages@ClassGUI].Value}] break case RestHP if ${UIElement[RestHP@Main@Pages@ClassGUI].Value(exists)} This.RestHP:Set[${UIElement[RestHP@Main@Pages@ClassGUI].Value}] break case StandHP if ${UIElement[StandHP@Main@Pages@ClassGUI].Value(exists)} This.StandHP:Set[${UIElement[StandHP@Main@Pages@ClassGUI].Value}] break case StandMP if ${UIElement[StandMP@Main@Pages@ClassGUI].Value(exists)} This.StandMP:Set[${UIElement[StandMP@Main@Pages@ClassGUI].Value}] break case ConserveMana if ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value(exists)} This.ConserveMana:Set[${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}] break case MPot if ${UIElement[MPot@Main@Pages@ClassGUI].Value(exists)} This.MPot:Set[${UIElement[MPot@Main@Pages@ClassGUI].Value}] break case HPot if ${UIElement[HPot@Main@Pages@ClassGUI].Value(exists)} This.HPot:Set[${UIElement[HPot@Main@Pages@ClassGUI].Value}] break case Bandage if ${UIElement[Bandage@Main@Pages@ClassGUI].Value(exists)} This.Bandage:Set[${UIElement[Bandage@Main@Pages@ClassGUI].Value}] break case HealWave if ${UIElement[HealWave@Heals@Pages@ClassGUI].Value(exists)} This.HealWave:Set[${UIElement[HealWave@Heals@Pages@ClassGUI].Value}] break case LHealWave if ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value(exists)} This.LHealWave:Set[${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}] break case ChainHeal if ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value(exists)} This.ChainHeal:Set[${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}] break case GOTN if ${UIElement[GOTN@Heals@Pages@ClassGUI].Value(exists)} This.GOTN:Set[${UIElement[GOTN@Heals@Pages@ClassGUI].Value}] break } }}