rendered paste bodyobjectdef oClass inherits oBase
{
;----------------------------------;
; Variables...All 5 Of Them ;
;----------------------------------;
variable int MaxRange = 30
variable int MFRange = 20
variable guidlist AggroList
variable int PotTimer = 0
variable oHeal Heal
variable oIQ IQ
variable bool HookBGPrebuff = TRUE
variable bool HookFlee = TRUE
variable int PullTimer
;----------------------------------;
; Rest Pulses & Checks ;
;----------------------------------;
member NeedRest()
{
if ${Me.InCombat}
{
This:CustOutput["Resting in combat",1]
return FALSE
}
if ${Targeting.realAgg}
{
This:CustOutput["I have aggro in rest",1]
return FALSE
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
This:CustOutput["Got Rez sickness in rest",1]
return TRUE
}
if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]}
{
This:CustOutput["Need to rest health",1]
return TRUE
}
if (${Me.PctMana} < ${Class.UseIntVar[RestMP]})
{
This:CustOutput["Need to rest mana",1]
return TRUE
}
if ${Me.PctHPs} < ${Class.UseIntVar[StandHP]} && ${Me.Buff[Food](exists)}
{
This:CustOutput["Not finished eating yet",1]
return TRUE
}
if ${Me.PctMana} < ${Class.UseIntVar[StandMP]} && ${Me.Buff[Drink](exists)}
{
This:CustOutput["Not finished drinking yet",1]
return TRUE
}
return FALSE
}
method RestPulse()
{
if ${Me.InCombat}
{
This:CustOutput["In combat in RestPulse",1]
return
}
if ${Me.Casting}
{
This:CustOutput["Casting in RestPulse",1]
return
}
if ${Targeting.realAgg}
{
This:CustOutput["Got aggro in RestPulse",1]
return
}
Toon:Stop
if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]} && ${Spell[Cannibalize](exists)} && !${Spell[Cannibalize].Cooldown} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)})
{
This:CustOutput["Using Cannibalize - rest pulse",1]
Toon:CastSpell[Cannibalize]
return
}
if ${Heal.NeedHeal}
{
This:CustOutput["Need a heal in RestPulse",1]
Heal:HealPulse[TRUE]
return
}
if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)}
{
This:CustOutput["Eating in RestPulse",1]
Consumable:useFood
if ${Class.canBuff[Shadowmeld]}
{
This:CustOutput["Need to shadowmeld/eat in RestPulse",1]
Toon:CastSpell["Shadowmeld"]
}
return
}
if ${Me.PctMana} < ${Class.UseIntVar[RestMP]} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)}
{
if ${Me.PctMana} < ${Class.UseIntVar[SpiritTapMP]} && ${Me.Buff[Spirit Tap](exists)}
{
This:CustOutput["Waiting on spirit tap regen in RestPulse",1]
return
}
This:CustOutput["Drinking in RestPulse",1]
Consumable:useDrink
if ${Class.canBuff[Shadowmeld]}
{
This:CustOutput["Need to shadowmeld/drink in RestPulse",1]
Toon:CastSpell["Shadowmeld"]
}
return
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
This:CustOutput["Got rez sickness in RestPulse. Sitting.",1]
Toon:Sitdown
if ${Class.canBuff[Shadowmeld]}
{
This:CustOutput["Shadowmelding with res sickness. RestPulse.",1]
Toon:CastSpell["Shadowmeld"]
}
return
}
if ${Me.PctMana} >= ${Class.UseIntVar[StandMP]} && ${Me.PctHPs} >= ${Class.UseIntVar[StandHP]} && !${Me.Buff[Resurrection Sickness](exists)}
{
This:CustOutput["All done resting in RestPulse.",1]
Toon:Standup
return
}
return
}
;----------------------------------;
; Buff Pulse & Checks ;
;----------------------------------;
member NeedBuff()
{
variable string OilType = ${Class.ChooseOilType[${Class.ChooseOil}]}
if ${Class.canBuff[Power Word: Fortitude]} && !${Me.Buff[Prayer of Fortitude](exists)} && ${Class.UseVar[PWF]}
{
This:CustOutput["Need Fort",1]
return TRUE
}
if ${Class.canBuff[Shadow Protection]} && !${Me.Buff[Prayer of Shadow Protection](exists)} && ${Class.UseVar[ShadowProt]}
{
This:CustOutput["Need shadow prot",1]
return TRUE
}
if ${Class.canBuff[Inner Fire]} && ${Class.UseVar[InnerFire]}
{
This:CustOutput["Need inner fire",1]
return TRUE
}
if ${Class.canBuff[Divine Spirit]} && !${Me.Buff[Prayer of Spirit](exists)} && ${Class.UseVar[DivineSpirit]}
{
This:CustOutput["Need divine spirit",1]
return TRUE
}
if ${Class.canBuff[Fear Ward]} && ${Class.UseVar[FearWard]}
{
This:CustOutput["Need fear ward",1]
return TRUE
}
if ${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${OilType}](exists)} && ${Item[${OilType}](exists)}
{
This:CustOutput["Need a weapon enchant (oil)",1]
return TRUE
}
if ${Toon.canUseScroll}
{
This:CustOutput["Need a scroll",1]
return TRUE
}
if ${Class.canBuff[Shadowguard]}
{
This:CustOutput["Need shadowguard",1]
return TRUE
}
return FALSE
}
method BuffPulse()
{
Target ${Me.GUID}
variable string OilType = ${Class.ChooseOilType[${Class.ChooseOil}]}
if ${Class.canBuff[Power Word: Fortitude]} && !${Me.Buff[Prayer of Fortitude](exists)} && ${Class.UseVar[PWF]}
{
This:CustOutput["Buffing fort",1]
Toon:CastSpell[Power Word: Fortitude]
return
}
if ${Class.canBuff[Inner Fire]} && ${Class.UseVar[InnerFire]}
{
This:CustOutput["Buffing inner fire",1]
Toon:CastSpell[Inner Fire]
return
}
if ${Class.canBuff[Shadow Protection]} && !${Me.Buff[Prayer of Shadow Protection](exists)} && ${Class.UseVar[ShadowProt]}
{
This:CustOutput["Buffing shadow prot",1]
Toon:CastSpell[Shadow Protection]
return
}
if ${Class.canBuff[Divine Spirit]} && !${Me.Buff[Prayer of Spirit](exists)} && ${Class.UseVar[DivineSpirit]}
{
This:CustOutput["Buffing divine spirit",1]
Toon:CastSpell[Divine Spirit]
return
}
if ${Class.canBuff[Fear Ward]} && ${Class.UseVar[FearWard]}
{
This:CustOutput["Buffing fear ward",1]
Toon:CastSpell[Fear Ward]
return
}
if !${Me.InCombat}&&${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${OilType}](exists)} && ${Item[${OilType}](exists)}
{
if ${WoWScript[SpellIsTargeting()]}
{
Me.Equip[mainhand]:PickUp
This:CustOutput["Applying ${OilType} to my mainhand."]
Bot.RandomPause:Set[24]
return
}
Item[${OilType}]:Use
return
}
if ${Toon.canUseScroll}
{
This:CustOutput["Buffing a scroll",1]
Toon:UseScroll
return
}
if ${Class.canBuff[Shadowguard]}
{
Toon:CastSpell[Shadowguard]
This:CustOutput["Buffing shadowguard",1]
return
}
return
}
member NeedBGPrebuff()
{
variable guidlist Candles
variable int i = 1
variable guidlist NearbyFriends
variable objectref FriendlyTarget
Candles:Search[-items, Sacred Candle]
NearbyFriends:Search[-players,-nearest,-${Me.FactionGroup.Lower},-alive,-lineofsight,-range 1-28]
if ${NearbyFriends.Count}
{
do
{
FriendlyTarget:Set[${NearbyFriends.Object[${i}].GUID}]
if !${FriendlyTarget.Buff[Power Word: Fortitude](exists)} && ${Toon.canCast[Power Word: Fortitude]} && !${FriendlyTarget.Buff[Prayer of Fortitude](exists)}
{
This:CustOutput["Need to buff a friendly player with fort",1]
return TRUE
}
if !${FriendlyTarget.Buff[Divine Spirit](exists)} && ${Toon.canCast[Divine Spirit]} && !${FriendlyTarget.Buff[Prayer of Spirit](exists)}
{
This:CustOutput["Need to buff a friendly player with spirit",1]
return TRUE
}
if !${FriendlyTarget.Buff[Shadow Protection](exists)} && ${Toon.canCast[Shadow Protection]} && !${FriendlyTarget.Buff[Prayer of Shadow Protection](exists)}
{
This:CustOutput["Need to buff a friendly player with shadow prot",1]
return TRUE
}
}
while ${i:Inc} <= ${NearbyFriends.Count}
NearbyFriends:Clear
}
if ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", 4]}
{
This:CustOutput["Need a refreshment table",1]
return TRUE
}
if ${This.NeedBGObjects["Soulwell", "Master Healthstone", 1]}
{
This:CustOutput["Need a soulwell",1]
return TRUE
}
return FALSE
}
method BGPrebuffPulse()
{
variable guidlist Candles
variable int i = 1
variable guidlist NearbyFriends
variable objectref FriendlyTarget
Candles:Search[-items, Sacred Candle]
NearbyFriends:Search[-players,-nearest,-${Me.FactionGroup.Lower},-alive,-lineofsight,-range 1-28]
if ${Me.Casting}
{
return
}
if ${NearbyFriends.Count} > 0
{
do
{
FriendlyTarget:Set[${NearbyFriends.Object[${i}].GUID}]
if !${FriendlyTarget.Buff[Power Word: Fortitude](exists)} && ${Toon.canCast[Power Word: Fortitude]} && !${FriendlyTarget.Buff[Prayer of Fortitude](exists)}
{
This:CustOutput["Buffing ${FriendlyTarget} with fort",1]
Target ${FriendlyTarget}
Toon:CastSpell[Power Word: Fortitude]
return
}
if !${FriendlyTarget.Buff[Divine Spirit](exists)} && ${Toon.canCast[Divine Spirit]} && !${FriendlyTarget.Buff[Prayer of Spirit](exists)}
{
This:CustOutput["Buffing ${FriendlyTarget} with divine spirit",1]
Target ${FriendlyTarget}
Toon:CastSpell[Divine Spirit]
return
}
if !${FriendlyTarget.Buff[Shadow Protection](exists)} && ${Toon.canCast[Shadow Protection]} && !${FriendlyTarget.Buff[Prayer of Shadow Protection](exists)}
{
This:CustOutput["Buffing ${FriendlyTarget} with shadow prot",1]
Target ${FriendlyTarget}
Toon:CastSpell[Shadow Protection]
return
}
}
while ${i:Inc} <= ${NearbyFriends.Count}
NearbyFriends:Clear
}
if ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", 4]}
{
This:CustOutput["Need to use a refreshment table",1]
This:BGObjectsPulse["Refreshment Table","Conjured Manna Biscuit", 4]
return
}
if ${This.NeedBGObjects["Soulwell", "Master Healthstone", 1]}
{
This:CustOutput["Need to use a soulwell",1]
This:BGObjectsPulse["Soulwell", "Master Healthstone"]
}
return
}
;----------------------------------;
; CombatBuff Pulse & Checks ;
;----------------------------------;
member NeedCombatBuff()
{
if ${Class.UseVar[Shield]} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && (${Me.PctHPs} <= ${Class.UseIntVar[ShieldMyHP]}) && (${Target.PctHPs} <= ${Class.UseIntVar[ShieldMobHP]}) && !${Me.Buff[Forbearance](exists)}
{
This:CustOutput["Need shield needcombatbuff",1]
return TRUE
}
if ${Class.UseVar[PainSup]} && ${Me.PctHPs} < ${Class.UseIntVar[PSHP]} && ${Class.canBuff[Pain Suppression]}
{
This:CustOutput["Need pain supp needcombatbuff",1]
return TRUE
}
if ${Me.PctHPs} < ${Class.UseIntVar[HPotAt]} && ${Class.UseVar[HPots]} && ${Consumable.HasHPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Need health pot needcombatbuff",1]
return TRUE
}
if ${Me.PctMana} < ${Class.UseIntVar[MPotAt]} && ${Class.UseVar[MPots]} && ${Consumable.HasMPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Need mana pot needcombatbuff",1]
return TRUE
}
if ${Target.Type.Equal["Player"]} && ${Class.HasMultiAggro[TRUE]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
{
This:CustOutput["Have multi aggro with a player target. needcombatbuff",1]
return TRUE
}
if ${Class.HasMultiAggro}
{
This:CustOutput["Need multiaggro needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Symbol of Hope]} && ${Me.PctMana} < 40
{
This:CustOutput["Need symbol of hope needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Shadow Word: Pain,"Target"]} && ${Class.UseVar[SWP]} && (${Target.PctHPs} > ${Class.UseVar[SWPHP]})
{
This:CustOutput["Need SWP needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Vampiric Embrace,"Target"]} && ${Class.UseVar[VE]} && (${Target.PctHPs} > ${Class.UseIntVar[VEHP]}) && (${Me.PctHPs} < ${Class.UseIntVar[VEMyHP]})
{
This:CustOutput["Need ve needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Starshards,"Target"]}
{
This:CustOutput["Need starshards needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Devouring Plague,"Target"]} && ${Class.UseVar[DP]} && (${Target.PctHPs} > ${Class.UseIntVar[DPHP]})
{
This:CustOutput["Need DP needcombatbuff",1]
return TRUE
}
if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
{
This:CustOutput["Need a heal on party member needcombatbuff",1]
return TRUE
}
if ${Class.UseVar[Heals]} && ${Heal.NeedHeal}
{
This:CustOutput["Need a heal on self needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
{
This:CustOutput["Need shadowform needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Berserking]}
{
This:CustOutput["Need beserking needcombatbuff",1]
return TRUE
}
if ${Class.canBuff[Hex of Weakness, "Target"]}
{
This:CustOutput["Need hex of weakness needcombatbuff",1]
return TRUE
}
return FALSE
}
method CombatBuffPulse()
{
if ${Me.Casting} || ${Me.GlobalCooldown} > 0 || ${This.Wanding}
{
This:CustOutput["Casting in CombatBuff",1]
return
}
if ${Class.UseVar[Shield]} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && ${Me.PctHPs} < ${Class.UseIntVar[ShieldMyHP]} && ${Target.PctHPs} < ${Class.UseIntVar[ShieldMobHP]} && !${Me.Buff[Forbearance](exists)}
{
This:CustOutput["Buffing shield combatbuff",1]
Toon:CastSpell[Power Word: Shield]
return
}
if ${Class.UseVar[PainSup]} && ${Me.PctHPs} < ${Class.UseIntVar[PSHP]} && ${Class.canBuff[Pain Suppression]}
{
This:CustOutput["Buffing ps combat buff",1]
Toon:CastSpell[Pain Supression]
return
}
if ${Me.PctHPs} < ${Class.UseIntVar[HPotAt]} && ${Class.UseVar[HPots]} && ${Consumable.HasHPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Using a health pot combatbuff",1]
Consumable:useHPot
Class.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Me.PctMana} < ${Class.UseIntVar[MPotAt]} && ${Class.UseVar[MPots]} && ${Consumable.HasMPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Using a mana pot combatbuff",1]
Consumable:useMPot
Class.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Target.Type.Equal["Player"]} && ${Class.HasMultiAggro[TRUE]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
{
This:CustOutput["Got player multiaggro combatbuff",1]
This:MultiAggro[TRUE]
return
}
if ${Class.HasMultiAggro}
{
This:CustOutput["Got multiaggro combatbuff",1]
This:MultiAggro
return
}
if ${Class.canBuff[Symbol of Hope]} && ${Me.PctMana} < 40
{
This:CustOutput["Buffing symbol of hope combatbuff",1]
Toon:CastSpell[Symbol of Hope]
return
}
if ${Class.canBuff[Shadow Word: Pain,"Target"]} && ${Class.UseVar[SWP]} && ${Target.PctHPs} > ${Class.UseVar[SWPHP]}
{
This:CustOutput["Buffing swp on target combatbuff",1]
Toon:CastSpell[Shadow Word: Pain]
return
}
if ${Class.canBuff[Vampiric Embrace,"Target"]} && ${Class.UseVar[VE]} && ${Target.PctHPs} > ${Class.UseIntVar[VEHP]} && ${Me.PctHPs} < ${Class.UseIntVar[VEMyHP]}
{
This:CustOutput["Buffing VE on target combatbuff",1]
Toon:CastSpell[Vampiric Embrace]
return
}
if ${Class.canBuff[Starshards, "Target"]}
{
This:CustOutput["Buffing starshards on target combatbuff",1]
Toon:CastSpell[Starshards]
return
}
if ${Class.canBuff[Devouring Plague, "Target"]} && ${Class.UseVar[DP]} && ${Target.PctHPs} > ${Class.UseIntVar[DPHP]}
{
This:CustOutput["Buffing DP combatbuff",1]
if ${Class.canBuff[Inner Focus]}
{
This:CustOutput["Buffing inner focus for DP combatbuff",1]
Toon:CastSpell[Inner Focus]
}
Toon:CastSpell[Devouring Plague]
return
}
if ${Class.UseVar[Heals]} && ${Heal.NeedHeal}
{
This:CustOutput["Heal on myself combatbuff",1]
Heal:HealPulse[TRUE]
return
}
if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
{
This:CustOutput["Healing a friendly player combatbuff",1]
Heal:HealPulse
return
}
if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
{
This:CustOutput["Buffing shadowform combatbuff",1]
Toon:CastSpell[Shadowform]
return
}
if ${Class.canBuff[Berserking]}
{
This:CustOutput["Buffing beserking combatbuff",1]
Toon:CastSpell[Berserking]
return
}
if ${Class.canBuff[Hex of Weakness,"Target"]}
{
This:CustOutput["Buffing HoW on target combatbuff",1]
Toon:CastSpell[Hex of Weakness]
return
}
return
}
;----------------------------------;
; PullBuff/Pull Pulses & Checks ;
;----------------------------------;
member NeedPullBuff()
{
if ${Class.canBuff[Power Word: Shield]} && ${Class.UseVar[ShieldOnPull]} && !${Me.Buff[Weakened Soul](exists)} && !${Me.Buff[Forbearance](exists)}
{
This:CustOutput["Need shield on pull",1]
return TRUE
}
if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
{
This:CustOutput["Need shadowform on pull",1]
return TRUE
}
return FALSE
}
method PullBuffPulse()
{
if ${Class.canBuff[Power Word: Shield]} && ${Class.UseVar[ShieldOnPull]} && !${Me.Buff[Weakened Soul](exists)} && !${Me.Buff[Forbearance](exists)}
{
This:CustOutput["Buffing shield on pull",1]
Toon:CastSpell[Power Word: Shield]
return
}
if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
{
This:CustOutput["Buffing shadowform on pull",1]
Toon:CastSpell[Shadowform]
return
}
return
}
method PullPulse()
{
if ${Target.Classification.Equal[Elite]}
{
This:CustOutput["Target is elite. Blacklisting..."]
GlobalBlacklist:Insert[${Target.GUID},3600000]
WoWScript ClearTarget()
move -stop
return
}
if !${Toon.ValidTarget[${Target.GUID}]}
{
This:CustOutput["Need a target"]
Toon:NeedTarget[1]
return
}
if !${Toon.TargetIsBestTarget}
{
This:CustOutput["Target is no longer best target. Getting new target"]
Toon:BestTarget
return
}
if ${Toon.TargetIsNew}
{
WoWScript SpellStopCasting()
return
}
if ${Target.Distance} > ${Class.MaxRange} && !${Me.Casting}
{
This:CustOutput["Too far away. Moving closer"]
WoWPress -hold moveforward
return
}
if ${Target.Distance} <= ${Math.Calc[${Class.MaxRange} - 5]} && !${Me.Casting}
{
Toon:Stop
}
if ${Toon.canCast[${This.UseVar[PullSpell]}]} && !${Movement.Speed} && ${This.PullTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Casting ${This.UseVar[PullSpell]} - Pull"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[${Class.UseVar[PullSpell]}]
return
}
if ${Toon.canCast[Shadow Word: Pain]} && !${Target.Buff[Shadow Word: Pain](exists)} && !${Movement.Speed}
{
This:CustOutput["Pulling with SW:P because we can't use ${This.UseVar[PullSpell]}!"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Shadow Word: Pain]
return
}
return
}
;----------------------------------;
; Main Attack Logic ;
;----------------------------------;
method AttackPulse()
{
if !${Toon.ValidTarget[${Target.GUID}]}
{
Toon:Stop
Toon:NeedTarget[1]
return
}
if !${Toon.TargetIsBestTarget} && ${Object[${Toon.BestTarget}](exists)} && ${Toon.BestTarget.NotEqual[NULL]}
{
Toon:BestTarget
return
}
if ${Toon.TargetIsNew}
{
Class.TimesCCd:Set[0]
This:SetStarting
}
if ${Movement.Speed} && (${Target.PctHPs} > 20 || !${Toon.isFacingAway[90]})
{
Toon:Stop
}
if ${Target.IsTotem}
{
Me.Action[Shoot]:Use
return
}
if !${This.UseVar[Wand]} || !${Me.Equip[Ranged](exists)}
{
Toon:AutoAttack
}
if ${Me.PctHPs} < 20 && ${Target.PctHPs} > 30
{
Toon:Flee
return
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${Me.Casting}
{
Toon:Stop
return
}
This:CrowdControl
if ${Target.Fleeing} && ${Toon.canCast[Mind Flay]} && ${Class.UseVar[MindflayRunners]}
{
Class:CustOutput["Run faster ${Target.Name}!"]
Toon:CastSpell[Mind Flay]
return
}
if ${Target.Distance} > ${Class.MaxRange}
{
Navigator:MoveToMob[${Target.GUID}]
return
}
if ${Target.Distance} < ${Class.MaxRange}
{
if ${Toon.canCast[Vampiric Touch]} && ${Target.PctHPs} > 80 && ${Me.PctMana} < 10
{
Toon:CastSpell[Vampiric Touch]
}
if ${Toon.canCast[Shadowfiend]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 50
{
Toon:CastSpell[Shadowfiend]
return
}
if ${Me.Buff[Feared](exists)} && ${Toon.canCast[Will of the Forsaken]}
{
Toon:CastSpell[Will of the Forsaken]
return
}
if ${Toon.canCast[Mana Tap]} && ${Target.PctMana} > 0
{
Toon:CastSpell[Mana Tap]
return
}
if ${Me.PctMana} < 85 && ${Toon.canCast[Arcane Torrent]} && ${Me.Buff[Mana Tap].Application} == 3
{
Toon:CastSpell[Arcane Torrent]
return
}
if ${Class.canBuff[Silence, "Target"]} && ${Target.Casting(exists)}
{
Toon:CastSpell[Silence]
return
}
if ${Me.Buff[Surge of Light](exists)}
{
Class:CustOutput["Casting Smite for free on ${Target.Name}"]
Toon:CastSpell[Smite]
return
}
if ${Class.UseVar[SWD]} && (${Target.PctHPs} < ${Class.UseIntVar[SWDMaxMobHP]}) && ${Toon.canCast[Shadow Word: Death]}
{
Class:CustOutput["Casting SW:D on ${Target.Name}"]
Toon:CastSpell[Shadow Word: Death]
return
}
AggroList:Search[-units,-nearest,-aggro,-attackable,-alive,-lineofsight,-range 0-${MaxRange}]
if ${Target.Type.Equal["Player"]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
{
if ${Target.Buff[Power Word: Shield](exists)} && ${Toon.canCast[Dispel Magic]}
{
Class:CustOutput["Dispelling a shield on ${Target.Name}"]
Toon:CastSpell[Dispel Magic]
return
}
This:PvP
return
}
if ${This.ShouldWand} && ${Me.Equip[ranged](exists)} && ${Target.Distance} <= 30 && !${Me.Action[Shoot].AutoRepeat} && !${Me.Action[Shoot].Cooldown}
{
Class:CustOutput["Shooting my wand!"]
Me.Action[Shoot]:Use
return
}
if ${AggroList.Count} == 1 && !${Me.Action[Shoot].AutoRepeat}
{
This:SingleMob
}
if ${AggroList.Count} == 2
{
This:DoubleMob
}
if ${AggroList.Count} > 2
{
This:MultiAggro
}
AggroList:Clear
return
}
return
}
method SingleMob()
{
if ${Class.UseVar[MindBlast]} && (${Target.PctHPs} > ${Class.UseIntVar[MindBlastMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[MindBlastMaxMobHP]}) && ${Toon.canCast[Mind Blast]} && !${This.Wanding}
{
Class:CustOutput["Casting Mind Blast on ${Target.Name}"]
Toon:CastSpell[Mind Blast]
return
}
if ${Class.UseVar[MindFlay]} && (${Target.PctHPs} > ${Class.UseIntVar[MindFlayMinMobHP]}) && ${Toon.canCast[Mind Flay]} && !${This.Wanding}
{
if ${Target.Distance} > ${This.MFRange} && !${Movement.Speed}
{
Move Forward 500
Class:CustOutput["Target too far away for Mind Flay, moving closer"]
return
}
Class:CustOutput["Casting Mind Flay on ${Target.Name}"]
Toon:CastSpell[Mind Flay]
return
}
if ${Class.UseVar[HolyFire]} && (${Target.PctHPs} > ${Class.UseIntVar[HolyFireMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[HolyFireMaxMobHP]}) && ${Toon.canCast[Holy Fire]} && !${This.Wanding}
{
Class:CustOutput["Casting Holy Fire on ${Target.Name}"]
Toon:CastSpell[Holy Fire]
return
}
if ${Class.UseVar[Smite]} && (${Target.PctHPs} > ${Class.UseIntVar[SmiteMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[SmiteMaxMobHP]}) && ${Toon.canCast[Smite]} && !${This.Wanding}
{
Class:CustOutput["Casting Smite on ${Target.Name}"]
Toon:CastSpell[Smite]
return
}
return
}
method DoubleMob(int NumMobs = 1)
{
variable guidlist ScreamList
ScreamList:Search[-units,-nearest,-alive,-targetingme,-nonfriendly,-range 0-10]
if ${ScreamList.Count} > ${NumMobs} && ${Class.UseVar[Scream]} && ${Toon.canCast[Psychic Scream]}
{
Class:CustOutput["AHHHHHHHHHHHHHH!"]
Toon:CastSpell[Psychic Scream]
return
}
if ${Object[${Targeting.TargetCollection.Get[2]}](exists)} && !${Object[${Targeting.TargetCollection.Get[2]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]}
{
Target ${Targeting.TargetCollection.Get[2]}
Class:CustOutput["Casting SW:P on ${Target.Name}"]
Toon:CastSpell[Shadow Word: Pain]
Bot.RandomPause:Set[10]
if ${Object[${Targeting.TargetCollection.Get[2]}].Buff[Vampiric Embrace](exists)}
{
Target ${Targeting.TargetCollection.Get[1]}
}
}
if ${Object[${Targeting.TargetCollection.Get[2]}](exists)} && !${Object[${Targeting.TargetCollection.Get[2]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]}
{
Target ${Targeting.TargetCollection.Get[2]}
Class:CustOutput["Casting VE on ${Target.Name}"]
Toon:CastSpell[Vampiric Embrace]
Bot.RandomPause:Set[10]
Target ${Targeting.TargetCollection.Get[1]}
return
}
This:SingleMob
return
}
method PvP()
{
variable guidlist AddsList
switch ${Target.Class}
{
case Druid
if ${Target.Power.Equal[Mana]} && ${Toon.canCast[Silence]} && (${Target.PctMana} > 5)
{
Toon:CastSpell[Silence]
return
}
This:DoubleMob[0]
break
case Hunter
This:DoubleMob[0]
break
case Mage
if ${Target.Buff[Ice Block](exists)} && ${Toon.canCast[Mass Dispel]}
{
Toon:CastSpell[Mass Dispel]
ISXWoW:ClickTerrain[${Target.X},${Target.Y},${Target.Z}]
return
}
This:DoubleMob[0]
break
case Paladin
if (${Target.Buff[Divine Shield](exists)} || ${Target.Buff[Divine Protection](exists)} || ${Target.Buff[Blessing of Protection](exists)}) && ${Toon.canCast[Mass Dispel]}
{
Toon:CastSpell[Mass Dispel]
ISXWoW:ClickTerrain[${Target.X},${Target.Y},${Target.Z}]
return
}
This:DoubleMob[0]
break
case Priest
if ${Target.PctMana} > 2 && ${Toon.canCast[Mana Burn]}
{
Toon:CastSpell[Mana Burn]
return
}
This:DoubleMob[0]
break
case Rogue
This:DoubleMob[0]
break
case Shaman
if ${Toon.canCast[Silence]}
{
Toon:CastSpell[Silence]
}
AddsList:Search[-units,-totem,-notowner,-lineofsight,-attackable,-range 0-30]
if ${AddsList.Count} > 0 && ${Toon.canShoot}
{
Target ${AddsList.Object[1].GUID}
Toon:Shoot
}
This:DoubleMob[0]
break
case Warrior
This:DoubleMob[0]
break
case Warlock
This:DoubleMob[0]
break
default
This:DoubleMob[0]
break
}
}
method FleePulse()
{
if ${Flee.Avoiding} && !${Mount.IsMounted}
{
if ${Me.InCombat} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)}
{
Toon:CastSpell[Power Word: Shield]
return
}
}
if ${Class.canBuff["Elune's Grace"]}
{
Toon:CastSpell["Elune's Grace"]
return
}
if ${Class.canBuff[Renew]}
{
Toon:CastSpell[Renew]
return
}
if ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && ${Me.PctMana} > 20
{
Toon:CastSpell[Power Word: Shield]
return
}
if ${Toon.canCast[Psychic Scream]}
{
Toon:CastSpell[Psychic Scream]
return
}
if ${Class.canBuff[Pain Suppression]}
{
Toon:CastSpell[Pain Suppression]
return
}
if ${Me.Attacking}
{
WoWScript AttackTarget()
return
}
}
variable bool HookBGGuard = TRUE
member NeedBGGuard()
{
if ${This.NeedBGPrebuff}
{
return TRUE
}
if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
{
return TRUE
}
return FALSE
}
method BGGuardPulse()
{
if ${This.NeedBGPrebuff}
{
This:BGPrebuffPulse
}
if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
{
Heal:HealPulse
}
return
}
;----------------------------------;
; Multiple Aggro Logic & Checks ;
;----------------------------------;
variable int LastCCTime = 0
variable int TimesCCd = 0
method CrowdControl()
{
variable guidlist CCList
variable objectref CCTarget
CCList:Search[-units,-nearest,-hostile,-undead,-nonfriendly,-range 0-30]
CCTarget:Set[${CCList.Object[2].GUID}]
if ${Toon.canCast[Shackle Undead]} && ${CCList.Count} > 0 && (${Class.TimesCCd} <= 3) && !${CCTarget.Buff[Shackled](exists)} && (${Class.LastCCTime} < ${LavishScript.RunningTime}) && ${CCTarget.Type.Equal[Undead]}
{
Target ${CCTarget}
Class:CustOutput["Casting Shackle on ${Target.Name}"]
Toon:CastSpell[Shackle Undead]
Class.TimesCCd:Inc
Class.LastCCTime:Set[${This.InSeconds[3]}]
return
}
return
}
member HasMultiAggro(bool PvP = FALSE)
{
variable guidlist AggrosList
variable objectref AggTarget
variable int i = 1
AggrosList:Clear
if ${PvP}
{
AggrosList:Search[-units,-nearest,-alive,-lineofsight,-zfilter 7,-pvp,-attackable,-range 0-${Class.MaxRange}]
}
else
{
AggrosList:Search[-units,-nearest,-aggro,-alive,-lineofsight,-attackable,-zfilter 7,-range 0-${Class.MaxRange}]
}
if ${AggrosList.Count} > 2
{
for (i:Set[1]; ${i} <= ${AggrosList.Count}; i:Inc)
{
if ${Toon.ValidTarget[${AggrosList.GUID[${i}]}]}
{
if !${Object[${AggrosList.GUID[${i}]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
{
return TRUE
}
if !${Object[${AggrosList.GUID[${i}]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
{
return TRUE
}
return FALSE
}
return FALSE
}
return FALSE
}
return FALSE
}
method MutliAggro(bool PvP = FALSE)
{
variable guidlist AggrosList
variable objectref AggTarget
variable int i = 1
AggrosList:Clear
if ${PvP}
{
AggrosList:Search[-units,-nearest,-alive,-lineofsight,-attackable,-zfilter 7,-pvp,-range 0-${Class.MaxRange}]
}
else
{
AggrosList:Search[-units,-nearest,-aggro,-alive,-lineofsight,-attackable,-zfilter 7,-range 0-${Class.MaxRange}]
}
if ${AggrosList.Count} > 2
{
for (i:Set[1]; ${i} <= ${AggrosList.Count}; i:Inc)
{
if ${Toon.ValidTarget[${AggrosList.GUID[${i}]}]}
{
if !${Object[${AggrosList.GUID[${i}]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
{
Target ${AggrosList.GUID[${i}]}
Class:CustOutput["Casting SW:P on ${Target.Name}"]
Bot.RandomPause:Set[10]
Toon:CastSpell[Shadow Word: Pain]
return
}
if !${Object[${AggrosList.GUID[${i}]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
{
Target ${AggrosList.GUID[${i}]}
Class:CustOutput["Casting VE on ${Target.Name}"]
Bot.RandomPause:Set[10]
Toon:CastSpell[Vampiric Embrace]
return
}
}
}
Toon:NeedTarget[1]
}
return
}
;----------------------------------;
; Chasing Logic & Checks ;
;----------------------------------;
variable float StartX
variable float StartY
variable float StartZ
variable int ChaseDistance = 90
variable int ChastingTargetBL = 5
member ChasingTooFar()
{
if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Class.StartX},${Class.StartY},${Class.StartZ}]} > ${Class.ChaseDistance}
{
return TRUE
}
return FALSE
}
method StopChasing()
{
if ${Me.Target(exists)} && ${Class.ChasingTooFar}
{
This:CustOutput["Chasing too far. Giving up on target"]
GlobalBlacklist:Insert[${Target.GUID},${This.InSeconds[${Class.ChasingTargetBL}]}]
WoWScript ClearTarget()
return
}
return
}
method SetStarting()
{
if ${Me.Target(exists)}
{
Class:CustOutput["New target! Setting start to ${Me.Location}"]
Class.StartX:Set[${Me.X}]
Class.StartY:Set[${Me.Y}]
Class.StartZ:Set[${Me.X}]
return
}
return
}
;----------------------------------;
; Misc Functions ;
;----------------------------------;
member Wanding()
{
if ${Me.Action[Shoot].AutoRepeat}
{
WoWScript SpellStopCasting()
return TRUE
}
return FALSE
}
member ShouldWand()
{
if !${This.UseVar[Wand]}
{
return FALSE
}
if ${Target.PctHPs} < ${This.UseIntVar[WandMobHP]} && ${This.UseVar[Wand]}
{
return TRUE
}
if ${Me.PctMana} < ${This.UseIntVar[WandAtMP]} && ${This.UseVar[Wand]}
{
return TRUE
}
return FALSE
}
member canBuff(string spellname, string myObj="Me")
{
if ${Toon.canCast[${spellname}]} && !${${myObj}.Buff[${spellname}](exists)} && !${${myObj}.IsTotem}
{
return TRUE
}
return FALSE
}
member ChooseOilType(string OilType)
{
variable int i = 1
variable index:string OilName
OilName:Insert["Minor ${OilType}"]
OilName:Insert["Lesser ${OilType}"]
OilName:Insert["${OilType}"]
OilName:Insert["Greater ${OilType}"]
OilName:Insert["Superior ${OilType}"]
OilName:Insert["Brilliant ${OilType}"]
do
{
if ${Item[${OilName.Get[${i}]}](exists)}
{
return "${OilName.Get[${i}]}"
}
}
while ${OilName.Get[${i:Inc}](exists)}
return "NONE"
}
member GetSpellRange(int base, string spellTree)
{
if ${spellTree.Equal[shadow]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Shadow Reach]}))-1].Round}
}
if ${spellTree.Equal[holy]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Holy Reach]}))-1].Round}
}
return ${base}
}
method SetDistances()
{
if ${Class.GetSpellRange[30, "shadow"]} > ${Class.GetSpellRange[30, "holy"]}
{
Class.MaxRange:Set[${Class.GetSpellRange[30, "shadow"]}]
This:CustOutput["Setting New MaxRange to ${Class.MaxRange}"]
Class.MFRange:Set[${Class.GetSpellRange[20, "shadow"]}]
This:CustOutput["Setting New Mind Flay range to ${Class.MFRange}"]
}
else
{
Class.MaxRange:Set[${Class.GetSpellRange[30, "holy"]}]
This:CustOutput["Setting New MaxRange to ${Class.MaxRange"]
}
}
variable int BuffNum = 0
variable bool debuffStatus = FALSE
method debuffAll()
{
if ${Me.PctMana} < 15 || ${Me.Casting}
{
return
}
BuffNum:Inc
if ${BuffNum} > 56
{
BuffNum:Set[1]
}
if ${Me.Buff[${BuffNum}].Harmful}
{
debuffStatus:Set[TRUE]
if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
{
if ${Toon.canCast[Cure Disease]}
{
Target ${Me}
This:CustOutput[${ShowOutput}, "Cleansing a disease"]
Toon:CastSpell[Cure Disease]
debuffStatus:Set[FALSE]
return
}
}
if ${Me.Buff[${BuffNum}].DispelType.Equal[Magic]}
{
if ${Toon.canCast[Dispel Magic]}
{
Target ${Me}
This:CustOutput[${ShowOutput}, "Dispelling a magic debuff"]
Toon:CastSpell[Dispel Magic]
debuffStatus:Set[FALSE]
return
}
}
return
}
if !${Target.Buff[${BuffNum}].Harmful} && ${Target.Buff[${BuffNum}].DispelType.Equal[Magic]}
{
debuffStatus:Set[TRUE]
if ${Toon.canCast[Dispel Magic]}
{
Toon:CastSpell[Dispel Magic]
debuffStatus:Set[FALSE]
return
}
}
return
}
method CustOutput(string Txt, int Debug = 0)
{
if ${This.UseVar[Output]} && ${Debug} == 0
{
UIElement[ClassGUI].FindChild[Pages].FindChild[Output].FindChild[Console]:Echo["${Txt}"]
}
if ${Debug} == 1
{
echo "[${Time.Time24}] ${Txt}"
redirect -append "${Script.CurrentDirectory}/routines/PriestDebug/PriestDebug.txt" echo "[${Time.Time24}] ${Txt}"
}
}
member NeedBGObjects(string objectName, string objectItem, int objectValue)
{
variable int i = 1
variable guidlist UsableObjs
variable objectref UseableObject
UsableObjs:Search[-gameobjects, -usable, -range 0-40]
i:Set[1]
if ${UsableObjs.Count}
{
do
{
UseableObject:Set[${UsableObjs.Object[${i}].GUID}]
This:Output["We have at the moment ${This.InventoryCountItem[${objectItem}]} ${objectItem}!"]
This:Output["And there is a ${UseableObject.Name} arount."]
if ${UseableObject.Name.Equal[${objectName}]} && ${This.InventoryCountItem[${objectItem}]} < ${objectValue}
{
return TRUE
}
}
while ${i:Inc} <= ${objectref.Count}
}
UsableObjs:Clear
return FALSE
}
method BGObjectsPulse(string objectName, string objectItem, int objectValue)
{
variable int i = 1
variable guidlist UsableObjs
variable objectref UseableObject
UsableObjs:Search[-gameobjects, -usable, -range 0-40]
i:Set[1]
if ${UsableObjs.Count}
{
do
{
UseableObject:Set[${UsableObjs.Object[${i}].GUID}]
if ${UseableObject.Name.Equal[${objectName}]} && ${This.InventoryCountItem[${objectItem}]} < ${objectValue}
{
if ${UseableObject.Distance} > 4 && !${Navigator.MovingToPoint[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]}
{
This:Output["Moving towards ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
Navigator:MoveToLoc[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]
}
if ${Object[${UseableObject}].Distance} < 4
{
Toon:Stop
This:Output["Using ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
UseableObject:Use
Bot.RandomPause:Set[16]
}
return
}
}
while ${i:Inc} <= ${objectref.Count}
}
UsableObjs:Clear
return
}
member InventoryCountItem(string itemName)
{
variable guidlist countItem
countItem:Search[-items,-inventory, ${itemName}]
return ${countItem.Count}
}
method SetSpellTimer(string eventid,string text,string Who,string spellname)
{
if ${spellname.Equal[${This.UseVar[PullSpell]}]}
{
This.PullTimer:Set[${This.InSeconds[3]}]
}
}
;----------------------------------;
; All The GUI Shit ;
;----------------------------------;
variable string RealmChar = "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
method Initialize()
{
LavishScript:RegisterEvent[UNIT_SPELLCAST_SUCCEEDED]
Event[UNIT_SPELLCAST_SUCCEEDED]:AttachAtom[This:SetSpellTimer]
This:SetGUI
This:InitPriestGUI
This:SetDistances
Bot:AddPulse["Class","HealTargetsPulse",3,FALSE,FALSE,1]
This:CustOutput["Apoc's Priest Routine v5.2 Loaded!"]
}
method Shutdown()
{
This:SaveGUI
}
method InitPriestGUI()
{
variable int i
for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.UseVar[PullSpell].Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.UseVar[ChooseOil].Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
if ${This.UseVar[HPots]}
{
UIElement[HPots@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[MPots]}
{
UIElement[MPots@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Wand]}
{
UIElement[Wand@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Smite]}
{
UIElement[Smite@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[HolyFire]}
{
UIElement[HolyFire@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[MindFlay]}
{
UIElement[MindFlay@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[MindFlayRunners]}
{
UIElement[MindFlayRunners@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[MindBlast]}
{
UIElement[MindBlast@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[SWD]}
{
UIElement[SWD@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[DP]}
{
UIElement[DP@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[VE]}
{
UIElement[VE@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[SWP]}
{
UIElement[SWP@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Scream]}
{
UIElement[Scream@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Heals]}
{
UIElement[Heals@Heal@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[HealerMode]}
{
UIElement[HealerMode@Heal@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[PWF]}
{
UIElement[PWF@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[ShadowProt]}
{
UIElement[ShadowProt@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[DivineSpirit]}
{
UIElement[DivineSpirit@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[UseCandles]}
{
UIElement[UseCandles@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[InnerFire]}
{
UIElement[InnerFire@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Shadowform]}
{
UIElement[Shadowform@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[FearWard]}
{
UIElement[FearWard@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Shield]}
{
UIElement[Shield@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[PainSup]}
{
UIElement[PainSup@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[ShieldOnPull]}
{
UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.UseVar[Output]}
{
UIElement[EnableOutput@Output@Pages@ClassGUI]:SetChecked
}
if ${This.UseIntVar[WandMobHP]} != ${UIElement[WandMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[WandMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandMobHP]}]
}
if ${This.UseIntVar[RestHP]} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value}
{
UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[RestHP]}]
}
if ${This.UseIntVar[StandHP]} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value}
{
UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[StandHP]}]
}
if ${This.UseIntVar[RestMP]} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value}
{
UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[RestMP]}]
}
if ${This.UseIntVar[StandMP]} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value}
{
UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[StandMP]}]
}
if ${This.UseIntVar[SpiritTapMP]} != ${UIElement[SpiritTapMP@Main@Pages@ClassGUI].Value}
{
UIElement[SpiritTapMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[SpiritTapMP]}]
}
if ${This.UseIntVar[HPotAt]} != ${UIElement[HPotAt@Main@Pages@ClassGUI].Value}
{
UIElement[HPotAt@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[HPotAt]}]
}
if ${This.UseIntVar[MPotAt]} != ${UIElement[MPotAt@Main@Pages@ClassGUI].Value}
{
UIElement[MPotAt@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[MPotAt]}]
}
if ${This.UseIntVar[WandAtMP]} != ${UIElement[WandAtMP@Main@Pages@ClassGUI].Value}
{
UIElement[WandAtMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandAtMP]}]
}
if ${This.UseIntVar[WandMobHP]} != ${UIElement[WandMobHP@Main@Pages@ClassGUI].Value}
{
UIElement[WandMobHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandMobHP]}]
}
if ${This.UseIntVar[SmiteMinMobHP]} != ${UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SmiteMinMobHP]}]
}
if ${This.UseIntVar[SmiteMaxMobHP]} != ${UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SmiteMaxMobHP]}]
}
if ${This.UseIntVar[HolyFireMinMobHP]} != ${UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[HolyFireMinMobHP]}]
}
if ${This.UseIntVar[HolyFireMaxMobHP]} != ${UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[HolyFireMaxMobHP]}]
}
if ${This.UseIntVar[MindFlayMinMobHP]} != ${UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindFlayMinMobHP]}]
}
if ${This.UseIntVar[MindBlastMinMobHP]} != ${UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindBlastMinMobHP]}]
}
if ${This.UseIntVar[MindBlastMaxMobHP]} != ${UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindBlastMaxMobHP]}]
}
if ${This.UseIntVar[SWDMaxMobHP]} != ${UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI].Value}
{
UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SWDMaxMobHP]}]
}
if ${This.UseIntVar[DPHP]} != ${UIElement[DPHP@Spells@Pages@ClassGUI].Value}
{
UIElement[DPHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[DPHP]}]
}
if ${This.UseIntVar[VEMyHP]} != ${UIElement[VEMyHP@Spells@Pages@ClassGUI].Value}
{
UIElement[VEMyHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[VEMyHP]}]
}
if ${This.UseIntVar[VEHP]} != ${UIElement[VEHP@Spells@Pages@ClassGUI].Value}
{
UIElement[VEHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[VEHP]}]
}
if ${This.UseIntVar[HealRenewHP]} != ${UIElement[HealRenewHP@Heal@Pages@ClassGUI].Value}
{
UIElement[HealRenewHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealRenewHP]}]
}
if ${This.UseIntVar[HealFlashHP]} != ${UIElement[HealFlashHP@Heal@Pages@ClassGUI].Value}
{
UIElement[HealFlashHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealFlashHP]}]
}
if ${This.UseIntVar[HealGreaterHP]} != ${UIElement[HealGreaterHP@Heal@Pages@ClassGUI].Value}
{
UIElement[HealGreaterHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealGreaterHP]}]
}
if ${This.UseIntVar[DruidWeight]} != ${UIElement[DruidWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[DruidWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[DruidWeight]}]
}
if ${This.UseIntVar[HunterWeight]} != ${UIElement[HunterWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[HunterWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HunterWeight]}]
}
if ${This.UseIntVar[MageWeight]} != ${UIElement[MageWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[MageWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[MageWeight]}]
}
if ${This.UseIntVar[PaladinWeight]} != ${UIElement[PaladinWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[PaladinWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[PaladinWeight]}]
}
if ${This.UseIntVar[PriestWeight]} != ${UIElement[PriestWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[PriestWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[PriestWeight]}]
}
if ${This.UseIntVar[RogueWeight]} != ${UIElement[RogueWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[RogueWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[RogueWeight]}]
}
if ${This.UseIntVar[ShamanWeight]} != ${UIElement[ShamanWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[ShamanWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShamanWeight]}]
}
if ${This.UseIntVar[WarlockWeight]} != ${UIElement[WarlockWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[WarlockWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[WarlockWeight]}]
}
if ${This.UseIntVar[WarriorWeight]} != ${UIElement[WarriorWeight@Heal@Pages@ClassGUI].Value}
{
UIElement[WarriorWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[WarriorWeight]}]
}
if ${This.UseIntVar[ShieldMyHP]} != ${UIElement[ShieldMyHP@Buffs@Pages@ClassGUI].Value}
{
UIElement[ShieldMyHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShieldMyHP]}]
}
if ${This.UseIntVar[ShieldMobHP]} != ${UIElement[ShieldMobHP@Buffs@Pages@ClassGUI].Value}
{
UIElement[ShieldMobHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShieldMobHP]}]
}
if ${This.UseIntVar[PSHP]} != ${UIElement[PSHP@Buffs@Pages@ClassGUI].Value}
{
UIElement[PSHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[PSHP]}]
}
if ${THis.UseIntVar[SWPHP]} != ${UIElement[SWPHP@Spells@Pages@ClassGUI].Value}
{
UIElement[SWPHP@Spells@Pages@ClassGUI]:SetValue[${THis.UseIntVar[SWPHP]}]
}
}
method SetGUI()
{
This:SetUse[PullSpell,${Config.GetSetting["${RealmChar}","PullSpell"]}]
This:SetUse[HPots,${Config.GetSetting["${RealmChar}","HPots"]}]
This:SetUse[MPots,${Config.GetSetting["${RealmChar}","MPots"]}]
This:SetUse[Wand,${Config.GetSetting["${RealmChar}","Wand"]}]
This:SetUse[Smite,${Config.GetSetting["${RealmChar}","Smite"]}]
This:SetUse[HolyFire,${Config.GetSetting["${RealmChar}","HolyFire"]}]
This:SetUse[MindFlay,${Config.GetSetting["${RealmChar}","MindFlay"]}]
This:SetUse[MindFlayRunners,${Config.GetSetting["${RealmChar}","MindFlayRunners"]}]
This:SetUse[MindBlast,${Config.GetSetting["${RealmChar}","MindBlast"]}]
This:SetUse[SWD,${Config.GetSetting["${RealmChar}","SWD"]}]
This:SetUse[DP,${Config.GetSetting["${RealmChar}","DP"]}]
This:SetUse[VE,${Config.GetSetting["${RealmChar}","VE"]}]
This:SetUse[SWP,${Config.GetSetting["${RealmChar}","SWP"]}]
This:SetUse[Scream,${Config.GetSetting["${RealmChar}","Scream"]}]
This:SetUse[Heals,${Config.GetSetting["${RealmChar}","Heals"]}]
This:SetUse[HealerMode,${Config.GetSetting["${RealmChar}","HealerMode"]}]
This:SetUse[PWF,${Config.GetSetting["${RealmChar}","PWF"]}]
This:SetUse[ShadowProt,${Config.GetSetting["${RealmChar}","ShadowProt"]}]
This:SetUse[DivineSpirit,${Config.GetSetting["${RealmChar}","DivineSpirit"]}]
This:SetUse[UseCandles,${Config.GetSetting["${RealmChar}","UseCandles"]}]
This:SetUse[InnerFire,${Config.GetSetting["${RealmChar}","InnerFire"]}]
This:SetUse[Shadowform,${Config.GetSetting["${RealmChar}","Shadowform"]}]
This:SetUse[FearWard,${Config.GetSetting["${RealmChar}","FearWard"]}]
This:SetUse[Shield,${Config.GetSetting["${RealmChar}","Shield"]}]
This:SetUse[PainSup,${Config.GetSetting["${RealmChar}","PainSup"]}]
This:SetUse[ChooseOil,${Config.GetSetting["${RealmChar}","ChooseOil"]}]
This:SetUse[ShieldOnPull,${Config.GetSetting["${RealmChar}","ShieldOnPull"]}]
This:SetUse[Output,${Config.GetSetting["${RealmChar}","Output"]}]
This:SetUseInt[RestHP,${Config.GetSetting["${RealmChar}","RestHP"]}]
This:SetUseInt[StandHP,${Config.GetSetting["${RealmChar}","StandHP"]}]
This:SetUseInt[RestMP,${Config.GetSetting["${RealmChar}","RestMP"]}]
This:SetUseInt[StandMP,${Config.GetSetting["${RealmChar}","StandMP"]}]
This:SetUseInt[SpiritTapMP,${Config.GetSetting["${RealmChar}","SpiritTapMP"]}]
This:SetUseInt[HPotAt,${Config.GetSetting["${RealmChar}","HPotAt"]}]
This:SetUseInt[MPotAt,${Config.GetSetting["${RealmChar}","MPotAt"]}]
This:SetUseInt[WandAtMP,${Config.GetSetting["${RealmChar}","WandAtMP"]}]
This:SetUseInt[WandMobHP,${Config.GetSetting["${RealmChar}","WandMobHP"]}]
This:SetUseInt[SmiteMinMobHP,${Config.GetSetting["${RealmChar}","SmiteMinMobHP"]}]
This:SetUseInt[SmiteMaxMobHP,${Config.GetSetting["${RealmChar}","SmiteMaxMobHP"]}]
This:SetUseInt[HolyFireMinMobHP,${Config.GetSetting["${RealmChar}","HolyFireMinMobHP"]}]
This:SetUseInt[HolyFireMaxMobHP,${Config.GetSetting["${RealmChar}","HolyFireMaxMobHP"]}]
This:SetUseInt[MindFlayMinMobHP,${Config.GetSetting["${RealmChar}","MindFlayMinMobHP"]}]
This:SetUseInt[MindBlastMinMobHP,${Config.GetSetting["${RealmChar}","MindBlastMinMobHP"]}]
This:SetUseInt[MindBlastMaxMobHP,${Config.GetSetting["${RealmChar}","MindBlastMaxMobHP"]}]
This:SetUseInt[SWDMaxMobHP,${Config.GetSetting["${RealmChar}","SWDMaxMobHP"]}]
This:SetUseInt[DPHP,${Config.GetSetting["${RealmChar}","DPHP"]}]
This:SetUseInt[VEMyHP,${Config.GetSetting["${RealmChar}","VEMyHP"]}]
This:SetUseInt[VEHP,${Config.GetSetting["${RealmChar}","VEHP"]}]
This:SetUseInt[HealRenewHP,${Config.GetSetting["${RealmChar}","HealRenewHP"]}]
This:SetUseInt[HealFlashHP,${Config.GetSetting["${RealmChar}","HealFlashHP"]}]
This:SetUseInt[HealGreaterHP,${Config.GetSetting["${RealmChar}","HealGreaterHP"]}]
This:SetUseInt[HealerMode,${Config.GetSetting["${RealmChar}","HealerMode"]}]
This:SetUseInt[DruidWeight,${Config.GetSetting["${RealmChar}","DruidWeight"]}]
This:SetUseInt[HunterWeight,${Config.GetSetting["${RealmChar}","HunterWeight"]}]
This:SetUseInt[MageWeight,${Config.GetSetting["${RealmChar}","MageWeight"]}]
This:SetUseInt[PaladinWeight,${Config.GetSetting["${RealmChar}","PaladinWeight"]}]
This:SetUseInt[PriestWeight,${Config.GetSetting["${RealmChar}","PriestWeight"]}]
This:SetUseInt[RogueWeight,${Config.GetSetting["${RealmChar}","RogueWeight"]}]
This:SetUseInt[ShamanWeight,${Config.GetSetting["${RealmChar}","ShamanWeight"]}]
This:SetUseInt[WarlockWeight,${Config.GetSetting["${RealmChar}","WarlockWeight"]}]
This:SetUseInt[WarriorWeight,${Config.GetSetting["${RealmChar}","WarriorWeight"]}]
This:SetUseInt[PSHP,${Config.GetSetting["${RealmChar}","PSHP"]}]
This:SetUseInt[ShieldMyHP,${Config.GetSetting["${RealmChar}","ShieldMyHP"]}]
This:SetUseInt[ShieldMobHP,${Config.GetSetting["${RealmChar}","ShieldMobHP"]}]
This:SetUseInt[SWPHP,${Config.GetSetting["${RealmChar}","SWPHP"]}]
}
method SaveGUI()
{
Config:SetSetting["${RealmChar}","PullSpell",${This.UseVar[PullSpell]}]
Config:SetSetting["${RealmChar}","RestHP",${This.UseIntVar[RestHP]}]
Config:SetSetting["${RealmChar}","StandHP",${This.UseIntVar[StandHP]}]
Config:SetSetting["${RealmChar}","RestMP",${This.UseIntVar[RestMP]}]
Config:SetSetting["${RealmChar}","StandMP",${This.UseIntVar[StandMP]}]
Config:SetSetting["${RealmChar}","SpiritTapMP",${This.UseIntVar[SpiritTapMP]}]
Config:SetSetting["${RealmChar}","HPots",${This.UseVar[HPots]}]
Config:SetSetting["${RealmChar}","MPots",${This.UseVar[MPots]}]
Config:SetSetting["${RealmChar}","HPotAt",${This.UseIntVar[HPotAt]}]
Config:SetSetting["${RealmChar}","MPotAt",${This.UseIntVar[MPotAt]}]
Config:SetSetting["${RealmChar}","Wand",${This.UseVar[Wand]}]
Config:SetSetting["${RealmChar}","WandAtMP",${This.UseIntVar[WandAtMP]}]
Config:SetSetting["${RealmChar}","WandMobHP",${This.UseIntVar[WandMobHP]}]
Config:SetSetting["${RealmChar}","Smite",${This.UseVar[Smite]}]
Config:SetSetting["${RealmChar}","SmiteMinMobHP",${This.UseIntVar[SmiteMinMobHP]}]
Config:SetSetting["${RealmChar}","SmiteMaxMobHP",${This.UseIntVar[SmiteMaxMobHP]}]
Config:SetSetting["${RealmChar}","HolyFire",${This.UseVar[HolyFire]}]
Config:SetSetting["${RealmChar}","HolyFireMinMobHP",${This.UseIntVar[HolyFireMinMobHP]}]
Config:SetSetting["${RealmChar}","HolyFireMaxMobHP",${This.UseIntVar[HolyFireMaxMobHP]}]
Config:SetSetting["${RealmChar}","MindFlay",${This.UseVar[MindFlay]}]
Config:SetSetting["${RealmChar}","MindFlayRunners",${This.UseVar[MindFlayRunners]}]
Config:SetSetting["${RealmChar}","MindFlayMinMobHP",${This.UseIntVar[MindFlayMinMobHP]}]
Config:SetSetting["${RealmChar}","MindBlast",${This.UseVar[MindBlast]}]
Config:SetSetting["${RealmChar}","MindBlastMinMobHP",${This.UseIntVar[MindBlastMinMobHP]}]
Config:SetSetting["${RealmChar}","MindBlastMaxMobHP",${This.UseIntVar[MindBlastMaxMobHP]}]
Config:SetSetting["${RealmChar}","SWD",${This.UseVar[SWD]}]
Config:SetSetting["${RealmChar}","SWDMaxMobHP",${This.UseIntVar[SWDMaxMobHP]}]
Config:SetSetting["${RealmChar}","DP",${This.UseVar[DP]}]
Config:SetSetting["${RealmChar}","DPHP",${This.UseIntVar[DPHP]}]
Config:SetSetting["${RealmChar}","VE",${This.UseVar[VE]}]
Config:SetSetting["${RealmChar}","VEMyHP",${This.UseIntVar[VEMyHP]}]
Config:SetSetting["${RealmChar}","VEHP",${This.UseIntVar[VEHP]}]
Config:SetSetting["${RealmChar}","Scream",${This.UseVar[Scream]}]
Config:SetSetting["${RealmChar}","Heals",${This.UseVar[Heals]}]
Config:SetSetting["${RealmChar}","HealRenewHP",${This.UseIntVar[HealRenewHP]}]
Config:SetSetting["${RealmChar}","HealFlashHP",${This.UseIntVar[HealFlashHP]}]
Config:SetSetting["${RealmChar}","HealGreaterHP",${This.UseIntVar[HealGreaterHP]}]
Config:SetSetting["${RealmChar}","HealerMode",${This.UseVar[HealerMode]}]
Config:SetSetting["${RealmChar}","DruidWeight",${This.UseIntVar[DruidWeight]}]
Config:SetSetting["${RealmChar}","HunterWeight",${This.UseIntVar[HunterWeight]}]
Config:SetSetting["${RealmChar}","MageWeight",${This.UseIntVar[MageWeight]}]
Config:SetSetting["${RealmChar}","PaladinWeight",${This.UseIntVar[PaladinWeight]}]
Config:SetSetting["${RealmChar}","PriestWeight",${This.UseIntVar[PriestWeight]}]
Config:SetSetting["${RealmChar}","RogueWeight",${This.UseIntVar[RogueWeight]}]
Config:SetSetting["${RealmChar}","ShamanWeight",${This.UseIntVar[ShamanWeight]}]
Config:SetSetting["${RealmChar}","WarlockWeight",${This.UseIntVar[WarlockWeight]}]
Config:SetSetting["${RealmChar}","WarriorWeight",${This.UseIntVar[WarriorWeight]}]
Config:SetSetting["${RealmChar}","PWF",${This.UseVar[PWF]}]
Config:SetSetting["${RealmChar}","ShadowProt",${This.UseVar[ShadowProt]}]
Config:SetSetting["${RealmChar}","DivineSpirit",${This.UseVar[DivineSpirit]}]
Config:SetSetting["${RealmChar}","UseCandles",${This.UseVar[UseCandles]}]
Config:SetSetting["${RealmChar}","InnerFire",${This.UseVar[InnerFire]}]
Config:SetSetting["${RealmChar}","Shadowform",${This.UseVar[Shadowform]}]
Config:SetSetting["${RealmChar}","FearWard",${This.UseVar[FearWard]}]
Config:SetSetting["${RealmChar}","Shield",${This.UseVar[Shield]}]
Config:SetSetting["${RealmChar}","ShieldMyHP",${This.UseIntVar[ShieldMyHP]}]
Config:SetSetting["${RealmChar}","ShieldMobHP",${This.UseIntVar[ShieldMobHP]}]
Config:SetSetting["${RealmChar}","PainSup",${This.UseVar[PainSup]}]
Config:SetSetting["${RealmChar}","PSHP",${This.UseIntVar[PSHP]}]
Config:SetSetting["${RealmChar}","ChooseOil",${This.UseVar[ChooseOil]}]
Config:SetSetting["${RealmChar}","ShieldOnPull",${This.UseVar[ShieldOnPull]}]
Config:SetSetting["${RealmChar}","Output",${This.UseVar[Output]}]
Config:SetSetting["${RealmChar}","SWP",${This.UseVar[SWP]}]
Config:SetSetting["${RealmChar}","SWPHP",${This.UseIntVar[SWPHP]}]
}
method ClassGUIChange(string Action)
{
switch ${Action}
{
case PullSpell
Class:SetUse[PullSpell,${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}]
break
case RestHP
Class:SetUseInt[RestHP,${UIElement[RestHP@Main@Pages@ClassGUI].Value}]
break
case StandHP
Class:SetUseInt[StandHP,${UIElement[StandHP@Main@Pages@ClassGUI].Value}]
break
case RestMP
Class:SetUseInt[RestMP,${UIElement[RestMP@Main@Pages@ClassGUI].Value}]
break
case StandMP
Class:SetUseInt[StandMP,${UIElement[StandMP@Main@Pages@ClassGUI].Value}]
break
case SpiritTapMP
Class:SetUseInt[SpiritTapMP,${UIElement[SpiritTapMP@Main@Pages@ClassGUI].Value}]
break
case HPots
Class:SetUse[HPots,${UIElement[HPots@Main@Pages@ClassGUI].Checked}]
break
case MPots
Class:SetUse[MPots,${UIElement[MPots@Main@Pages@ClassGUI].Checked}]
break
case HPotAt
Class:SetUseInt[HPotAt,${UIElement[HPotAt@Main@Pages@ClassGUI].Value}]
break
case MPotAt
Class:SetUseInt[MPotAt,${UIElement[MPotAt@Main@Pages@ClassGUI].Value}]
break
case Wand
Class:SetUse[Wand,${UIElement[Wand@Main@Pages@ClassGUI].Checked}]
break
case WandAtMP
Class:SetUseInt[WandAtMP,${UIElement[WandAtMP@Main@Pages@ClassGUI].Value}]
break
case WandMobHP
Class:SetUseInt[WandMobHP,${UIElement[WandMobHP@Main@Pages@ClassGUI].Value}]
break
case Smite
Class:SetUse[Smite,${UIElement[Smite@Spells@Pages@ClassGUI].Checked}]
break
case SmiteMinMobHP
Class:SetUseInt[SmiteMinMobHP,${UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI].Value}]
break
case SmiteMaxMobHP
Class:SetUseInt[SmiteMaxMobHP,${UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI].Value}]
break
case HolyFire
Class:SetUse[HolyFire,${UIElement[HolyFire@Spells@Pages@ClassGUI].Checked}]
break
case HolyFireMinMobHP
Class:SetUseInt[HolyFireMinMobHP,${UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI].Value}]
break
case HolyFireMaxMobHP
Class:SetUseInt[HolyFireMaxMobHP,${UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI].Value}]
break
case MindFlay
Class:SetUse[MindFlay,${UIElement[MindFlay@Spells@Pages@ClassGUI].Checked}]
break
case MindFlayRunners
Class:SetUse[MindFlayRunners,${UIElement[MindFlayRunners@Spells@Pages@ClassGUI].Checked}]
break
case MindFlayMinMobHP
Class:SetUseInt[MindFlayMinMobHP,${UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI].Value}]
break
case MindBlast
Class:SetUse[MindBlast,${UIElement[MindBlast@Spells@Pages@ClassGUI].Checked}]
break
case MindBlastMinMobHP
Class:SetUseInt[MindBlastMinMobHP,${UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI].Value}]
break
case MindBlastMaxMobHP
Class:SetUseInt[MindBlastMaxMobHP,${UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI].Value}]
break
case SWD
Class:SetUse[SWD,${UIElement[SWD@Spells@Pages@ClassGUI].Checked}]
break
case SWDMaxMobHP
Class:SetUseInt[SWDMaxMobHP,${UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI].Value}]
break
case DP
Class:SetUse[DP,${UIElement[DP@Spells@Pages@ClassGUI].Checked}]
break
case DPHP
Class:SetUseInt[DPHP,${UIElement[DPHP@Spells@Pages@ClassGUI].Value}]
break
case VE
Class:SetUse[VE,${UIElement[VE@Spells@Pages@ClassGUI].Checked}]
break
case VEMyHP
Class:SetUseInt[VEMyHP,${UIElement[VEMyHP@Spells@Pages@ClassGUI].Value}]
break
case VEHP
Class:SetUseInt[VEHP,${UIElement[VEHP@Spells@Pages@ClassGUI].Value}]
break
case SWP
Class:SetUse[SWP,${UIElement[SWP@Spells@Pages@ClassGUI].Checked}]
break
case SWPHP
Class:SetUseInt[SWPHP,${UIElement[SWPHP@Spells@Pages@ClassGUI].Value}]
break
case Scream
Class:SetUse[Scream,${UIElement[Scream@Spells@Pages@ClassGUI].Checked}]
break
case Heals
Class:SetUse[Heals,${UIElement[Heals@Heal@Pages@ClassGUI].Checked}]
break
case HealRenewHP
Class:SetUseInt[HealRenewHP,${UIElement[HealRenewHP@Heal@Pages@ClassGUI].Value}]
break
case HealFlashHP
Class:SetUseInt[HealFlashHP,${UIElement[HealFlashHP@Heal@Pages@ClassGUI].Value}]
break
case HealGreaterHP
Class:SetUseInt[HealGreaterHP,${UIElement[HealGreaterHP@Heal@Pages@ClassGUI].Value}]
break
case HealerMode
Class:SetUse[HealerMode,${UIElement[HealerMode@Heal@Pages@ClassGUI].Checked}]
break
case DruidWeight
Class:SetUseInt[DruidWeight,${UIElement[DruidWeight@Heal@Pages@ClassGUI].Value}]
break
case HunterWeight
Class:SetUseInt[HunterWeight,${UIElement[HunterWeight@Heal@Pages@ClassGUI].Value}]
break
case MageWeight
Class:SetUseInt[MageWeight,${UIElement[MageWeight@Heal@Pages@ClassGUI].Value}]
break
case PaladinWeight
Class:SetUseInt[PaladinWeight,${UIElement[PaladinWeight@Heal@Pages@ClassGUI].Value}]
break
case PriestWeight
Class:SetUseInt[PriestWeight,${UIElement[PriestWeight@Heal@Pages@ClassGUI].Value}]
break
case RogueWeight
Class:SetUseInt[RogueWeight,${UIElement[RogueWeight@Heal@Pages@ClassGUI].Value}]
break
case ShamanWeight
Class:SetUseInt[ShamanWeight,${UIElement[ShamanWeight@Heal@Pages@ClassGUI].Value}]
break
case WarlockWeight
Class:SetUseInt[WarlockWeight,${UIElement[WarlockWeight@Heal@Pages@ClassGUI].Value}]
break
case WarriorWeight
Class:SetUseInt[WarriorWeight,${UIElement[WarriorWeight@Heal@Pages@ClassGUI].Value}]
break
case PWF
Class:SetUse[PWF,${UIElement[PWF@Buffs@Pages@ClassGUI].Checked}]
break
case ShadowProt
Class:SetUse[ShadowProt,${UIElement[ShadowProt@Buffs@Pages@ClassGUI].Checked}]
break
case DivineSpirit
Class:SetUse[DivineSpirit,${UIElement[DivineSpirit@Buffs@Pages@ClassGUI].Checked}]
break
case UseCandles
Class:SetUse[UseCandles,${UIElement[UseCandles@Buffs@Pages@ClassGUI].Checked}]
break
case InnerFire
Class:SetUse[InnerFire,${UIElement[InnerFire@Buffs@Pages@ClassGUI].Checked}]
break
case Shadowform
Class:SetUse[Shadowform,${UIElement[Shadowform@Buffs@Pages@ClassGUI].Checked}]
break
case FearWard
Class:SetUse[FearWard,${UIElement[FearWard@Buffs@Pages@ClassGUI].Checked}]
break
case Shield
Class:SetUse[Shield,${UIElement[Shield@Buffs@Pages@ClassGUI].Checked}]
break
case ShieldMyHP
Class:SetUseInt[ShieldMyHP,${UIElement[ShieldMyHP@Buffs@Pages@ClassGUI].Value}]
break
case ShieldMobHP
Class:SetUseInt[ShieldMobHP,${UIElement[ShieldMobHP@Buffs@Pages@ClassGUI].Value}]
break
case PainSup
Class:SetUse[PainSup,${UIElement[PainSup@Buffs@Pages@