/*
Glave's Openbot Warlock Routine
v .94
Roads? Where we're going, we don't need roads.
Changes:
v.94
Safe rez enabled only if using soulstones
Fixed a bug that left you waiting to release if soulstone was on cooldown
v.93
Fears won't attempt to cast if you have Fel Dom buff
Fear and Howl will not interrupt themselves anymore
Selecting the safe rez option in the gui makes you wait 10 seconds on death, then you test to see
if you can res safely with soulstone, else you res at the graveyard
Fixed summoning a pet after a dismount
Added DOTTY to PVP
PVP is in, but only works in BG right now, no options for it
v.92
CoR forced to rank 1
Tweaked CoR on not casting right after a fear
Corrected wanding on no mana, will also melee if no wand
Tweak on resting. Nothing really changed, just better syntax
Always loot before resting (Cause what if we got ganked and corpse camped! My loot will rot!)
Reported Issues:
Cannablize gets goofy on elementals
Fear pull won't work yet till pulling ranges are fixed
Dynamic ranges won't work either
DotAdds isn't even checking for spells
TODO:
Shadow ward
Dot adds, continue on first target, give em choices via gui
Add handling
Potions/scrolls
Wizard Oils
Auto UE on swimming
*/
objectdef oClass inherits oBase
{
/************************************************************************************************************************************************************************************************
Vars
************************************************************************************************************************************************************************************************/
variable string version="Glave's Warlock v.94"
variable string tagline="Roads? Where we're going, we don't need roads."
variable int LastBuffCast = 1
variable int PullTimeDelay = ${LavishScript.RunningTime}
variable int PetPulled = 1
variable int MaxCombatRange = 28
variable guidlist ShardList
variable guidlist Aggro
variable string MyPet="Imp"
variable string RealmChar="${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
variable int CorruCast = 1
variable int AmpCast = 1
variable int CoACast = 1
variable int CoRCast = 1
variable int SLCast = 1
variable int FearCast=1
variable int ImmoCast = 1
variable int UACast = 1
variable int PetSummon = 1
variable int HSCreated = 1
variable int SSCreated = 1
variable int PullRange = 28
variable int MinPullRange = 10
variable int Pull = 1
variable int PullSpellCast = 1
variable string PullSpell = "Shadow Bolt"
variable int MinMana = 50
variable int MinHealth = 60
variable int HSHealth = 40
variable int WandHealth = 0
variable int PanicHealth = 20 /* Health % that I Deathcoil & Fear */
variable int ComDPMyMana = 85 /* Minimum mana I have before I combat dark pact */
variable int ComDPPetMana = 15 /* Minimum mana pet has before combat dark pact */
variable int ComLTHealth = 50 /* Minimum health before I won't life tap in combat */
variable int ComLTMana = 80 /* Minimum mana before I life tap in combat */
variable int DrainSoulHP = 30 /* Health amount I begin drain soul if needed */
variable int DrainLifeHP = 90 /* Minimum health I have before I drain life instead of nuke */
variable int FunnelPetHP = 50 /* Health Funnel pet if below this during rest */
variable int FunnelMyHP = 70 /* Minimum health I have in order to health funnel during rest */
variable int RestDPMyMana = 85 /* Minimum mana I have before I rest dark pact */
variable int RestDPPetMana = 15 /* Minimum mana pet has before rest dark pact */
variable int RestLTHealth = 50 /* Minimum health before I won't life tap in rest */
variable int RestLTMana = 80 /* Minimum mana before I life tap in rest */
variable int PetWait = 5000 /* Wait this long for pet to pet to aggro */
variable int VWSackHP = 30
variable int conflPop = 4000
variable int ApocWantsShards = 5
variable int TimeOfDeath = 1
variable string OppositeFaction
variable bool useCorruption = TRUE
variable bool useAmp = TRUE
variable bool FearJuggle = FALSE
variable bool useCoA = TRUE
variable bool useSiphonLife = TRUE
variable bool useUnstableAffliction = TRUE
variable bool useImmolate = TRUE
variable bool useConflag = TRUE
variable bool useSearingPain = TRUE
variable bool useIncinerate = TRUE
variable bool useDrainLife = TRUE
variable bool FearElites = FALSE
variable bool useUnendingBreath = FALSE
variable bool useSoulstone = FALSE
variable bool usePull = TRUE
variable bool useRestBoth = TRUE
variable bool WandNoNuke = FALSE
variable bool AllDotted = TRUE
/************************************************************************************************************************************************************************************************
Main
************************************************************************************************************************************************************************************************/
method AttackPulse()
{
if ${Target.Dead}
{
WowScript ClearTarget()
return
}
if ${This.IsStunned}
return
if ${Target.Name.NotEqual[${Me.Name}]} && ${Target(exists)}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
;Set your max spell distance based on talents. Unsure if working in latest ob
This:SetDistances
;Chase down runners
if ${Target.Distance} > ${This.MaxCombatRange} && !${This.InBG}
{
This:Output["Chasing down ${Target.Name}"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
wowpress -hold moveforward
return
}
;Stop moving when in range- Do I still need this??
if ${Target.Distance}<=${This.MaxCombatRange}
Toon:Stop
;Use healthstone on low health
if ${Me.PctHPs} < ${This.HSHealth}
{
if ${Item[Healthstone](exists)} && !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
Item[Healthstone]:Use
}
;Sacrifice voidwalker if we need to
if ${Me.PctHPs} < ${This.VWSackHP}
{
if ${Spell["Sacrifice"](exists)}
WoWScript CastPetAction(5)
}
;Death coil if they're close and I'm low on health (Need to check if they're targeting me)
if ${Target.Distance}<=7 && ${Me.PctHPs} < ${This.PanicHealth} && !${Me.Buff[Fel Domination](exists)}
{
if ${Me.Action[Death Coil].Usable} && ${Spell[Death Coil](exists)}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Death Coil]
This:Output[Death Coil]
return
}
return
}
;All panic options exhausted, fear it off
elseif ${This.HaveAdds} && ${Spell[Howl of Terror](exists)}&&${Me.Action[Howl of Terror].Usable} && ${FearCast} < ${LavishScript.RunningTime} && !${Me.Buff[Fel Domination](exists)} && !${WoWScript[UnitCastingInfo("player")].Equal["Howl of Terror"]}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Howl of Terror]
This:Output[Panic:Howl]
return
}
return
}
elseif ${Spell[Fear](exists)}&&${Me.Action[Fear].Usable} && !${Target.IsTotem} && ${FearCast} < ${LavishScript.RunningTime} && !${Me.Buff[Fel Domination](exists)}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown} && !${WoWScript[UnitCastingInfo("player")].Equal["Fear"]}
{
Toon:CastSpell[Fear]
This:Output[Panic:Fear]
return
}
return
}
}
;Target is fleeing- GET BACK HERE NOW!
if ${Target.Fleeing} && !${Target.Buff[Fear](exists)} && ${Toon.canCast[Curse of Recklessness]} && !${Target.Buff[Curse of Recklessness](exists)}&&${Me.Action[Curse of Recklessness].Usable}&&${CoRCast} < ${LavishScript.RunningTime} && ${Math.Calc[${FearCast} + 3200]}<${LavishScript.RunningTime}
{
cast "Curse of Recklessness" 1
This:Output[Curse of Recklessness]
return
}
ShardList:Clear
ShardList:Search[-items,-inventory,Soul Shard]
;Stop everything and so I can drain soul when mob is low on health and we need shards
if ${WoWScript[UnitCastingInfo("player")].NotEqual[Drain Soul]} && ${ShardList.Count}< ${This.NumShards} && ${Target.PctHPs} < ${This.DrainSoulHP} &&${Spell[Drain Soul](exists)}
{
WoWScript SpellStopCasting()
return
}
;Stop draining soul if the mob gained more health than the threshold for drain soul
if ${WoWScript[UnitCastingInfo("player")].Equal[Drain Soul]} && ${Target.PctHPs} > ${This.DrainSoulHP}
{
WoWScript SpellStopCasting()
return
}
;Its a totem so make the pet attack and get a better target
if ${Target.IsTotem}
{
if ${Me.Pet(exists)}
wowscript PetAttack()
WowScript ClearTarget()
Toon:BestTarget
return
}
;Make sure pet is attacking
if ${Me.Pet(exists)} && !${Me.Pet.Target(exists)}
wowscript PetAttack()
;If I'm not in combat yet, the pet hasn't engaged combat (For waiting until the pet has aggro)
if !${Me.InCombat}
{
PetPulled:Set[${LavishScript.RunningTime} + ${PetWait}]
}
if ${Me.Casting} || ${Me.GlobalCooldown} > 0 || ${Target.Distance}>${This.MaxCombatRange} || ${PetWait} && ${PetPulled} > ${LavishScript.RunningTime}
return
;Attack if I'm not wanding- work those melee skills!
if !${Me.Attacking} && !${Me.Action[Shoot].AutoRepeat} && !${This.WandHealth}
WoWScript AttackTarget()
;Arcane torrent racial- who the heck added this?
if ${Me.PctMana} < 85 && ${Spell[Arcane Torrent](exists)} && !${Spell[Arcane Torrent].Cooldown} && ${Me.Buff[Mana Tap].Application} == 3
{
Toon:CastSpell[Arcane Torrent]
This:Output["Arcane Torrent"]
return
}
;Get mana from Dark Pact
if ${Me.Pet(exists)} && ${Spell[Dark Pact](exists)}
{
if ${Me.Pet.PctMana} > ${This.ComDPPetMana} && ${Me.PctMana} < ${This.ComDPMyMana}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Dark Pact]
This:Output[Dark Pact]
return
}
return
}
}
;Get mana from life tap
if ${Me.PctHPs} > ${ComLTHealth} && ${Me.PctMana} < ${ComLTMana} && ${Spell[Life Tap](exists)}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Life Tap]
This:Output[Life Tap]
return
}
return
}
;PVP TIME!
if ${This.InBG}
{
This:DotPVPAdds
if !${AllDotted}
return
}
AllDotted:Set[FALSE]
;No Pet! Fel Dom and get one if we can
if !${Me.Pet(exists)}&&${Spell["Summon ${MyPet}"](exists)}
{
if ${ShardList.Count}>= 1 || ${This.MyPet.Equal["Imp"]}
{
if ${Me.Action[Fel Domination].Usable} && ${Me.CurrentPower} >= (${Math.Calc[${Spell[Fel Domination].Mana} + ${Spell["Summon ${MyPet}"].Mana}]})
{
This:Output[We need a pet- NOW!]
Toon:CastSpell[Fel Domination]
return
}
if ${Me.Buff[Fel Domination](exists)}
{
if ${This.MyPet.Equal["Imp"]}&&${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon Imp]
}
elseif ${ShardList.Count}>= 1 &&${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon ${MyPet}]
}
elseif ${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon Imp]
}
}
}
}
;Drain soul when mob is low and we need shards
if ${ShardList.Count}< ${This.NumShards} && ${Target.PctHPs} < ${This.DrainSoulHP} &&${Spell[Drain Soul](exists)}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Drain Soul]
This:Output[Drain Soul]
return
}
return
}
;Nightfall has proc'd so throw a insta-shadow bolt
elseif ${Me.Buff[Shadow Trance](exists)}&&${Me.Action[Shadow Bolt].Usable}&&${Target(exists)}
{
if !${This.AmWanding} && !${Me.Action[Shoot].Cooldown}
{
Toon:CastSpell[Shadow Bolt]
This:Output[NIGHTFALL! Shadow Bolt]
return
}
return
}
;Pet is dieing- health funnel it
elseif ${Me.Pet(exists)} && ${Me.Pet.PctHPs}<= ${This.FunnelPetHP} && ${Me.PctHPs} >= ${This.FunnelMyHP}
{
if ${Me.Pet(exists)} && ${Me.Pet.Distance} > 19
{
This:Output["Getting in funnel range"]
Navigator:FaceXYZ[${Me.Pet.X},${Me.Pet.Y},${Me.Pet.Z}]
wowpress -hold moveforward
return
}
This:Output[Health Funnel]
Toon:CastSpell[Health Funnel]
}
;Wand it to death at a certain health %
elseif ${Target.PctHPs} < ${This.WandHealth} && ${Me.Equip[ranged](exists)} && ${Target.Distance}<=30
{
if !${Me.Action[Shoot].AutoRepeat} && !${Me.Action[Shoot].Cooldown}
{
This:Output[Wanding at low health]
Me.Action[Shoot]:Use
This:Wait[100]
}
return
}
;Fear juggle by keeping it feared no matter what
if ${FearJuggle} && ${Me.Action[Fear].Usable} && !${Target.Buff[Fear](exists)} && ${FearCast} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Fear]
This:Output[Fear]
return
}
;Fear elites away
if ${FearElites} && (${Target.Classification.Equal["Elite"]} || ${Target.Classification.Equal["RareElite"]}) && ${Spell[Fear](exists)}&&${Me.Action[Fear].Usable} && ${FearCast} < ${LavishScript.RunningTime} && !${Target.Buff[Fear](exists)}
{
Toon:CastSpell[Fear]
This:Output[Fear Elite]
return
}
;Mana tap racial- who added this?
if ${Spell[Mana Tap](exists)} && !${Spell[Mana Tap].Cooldown} && ${Target.CurrentMana} > 0
{
Target ${Targeting.TargetCollection.Get[1]}
Toon:CastSpell[Mana Tap]
This:Output["Mana tap"]
return
}
;Pop conflagrate- I tested this once.... no idea currently
if ${useConflag} && ${Target.Buff[Immolate](exists)} && ${Me.Action[Conflagrate].Usable} && (${ImmoCast}+${conflPop}) < ${LavishScript.RunningTime}
{
Toon:CastSpell[Conflagrate]
This:Output[Conflagrate]
return
}
This:DotAdds
;Amplify curse when not on cooldown
if ${useAmp} && ${Me.Action[Amplify Curse].Usable} && !${Target.Buff[Curse of Agony](exists)}
{
This:Output[Amplify Curse]
Toon:CastSpell[Amplify Curse]
return
}
;Curse of Agony - rumored to not always cast
elseif ${useCoA} && !${Target.Buff[Curse of Agony](exists)}&& !${Target.Buff[Curse of Recklessness](exists)}&&${Me.Action[Curse of Agony].Usable}&&${CoACast} < ${LavishScript.RunningTime}&&${AmpCast} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Curse of Agony]
This:Output[Curse of Agony]
return
}
;Corruption
if ${useCorruption} && !${Target.Buff[Corruption](exists)}&& !${Target.Buff[Seed of Corruption](exists)}&&${Me.Action[Corruption].Usable}&&${CorruCast} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Corruption]
This:Output[Corruption]
return
}
;Siphon Life
if ${useSiphonLife} && !${Target.Buff[Siphon Life](exists)}&&${Me.Action[Siphon Life].Usable}&&${SLCast} < ${LavishScript.RunningTime} && !${Target.CreatureType.Equal["Mechanical"]}
{
This:Output[Siphon Life]
Toon:CastSpell[Siphon Life]
return
}
;Unstable Affliction
if ${useUnstableAffliction} && !${Target.Buff[Unstable Affliction](exists)}&&${Me.Action[Unstable Affliction].Usable}&&${UACast} < ${LavishScript.RunningTime}
{
This:Output[Unstable Affliction]
Toon:CastSpell[Unstable Affliction]
return
}
;Immolate
if ${useImmolate} && !${Target.Buff[Immolate](exists)} && ${Me.Action[Immolate].Usable}&&${ImmoCast} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Immolate]
This:Output[Immolate]
return
}
;Drain life
if ${useDrainLife} && ${Me.Action[Drain Life].Usable} && ${Me.PctHPs} < ${This.DrainLifeHP} && !${Target.CreatureType.Equal["Mechanical"]}
{
This:Output[Drain Life]
Toon:CastSpell[Drain Life]
return
}
;No direct damage if fear juggling, dots only
if ${FearJuggle}
{
This:Output[Fear Juggling]
return
}
;Wand it instead of direct damage spells
if ${WandNoNuke} && ${Me.Equip[ranged](exists)} && ${Target.Distance}<=30
{
if !${Me.Action[Shoot].AutoRepeat} && !${Me.Action[Shoot].Cooldown}
{
This:Output[...Wanding]
Me.Action[Shoot]:Use
This:Wait[100]
}
return
}
;Incinerate
if ${useIncinerate} && ${Me.Action[Incinerate].Usable}
{
This:Output[Incinerate]
Toon:CastSpell[Incinerate]
return
}
;Searing Pain
elseif ${useSearingPain} && ${Me.Action[Searing Pain].Usable}
{
This:Output[Searing Pain]
Toon:CastSpell[Searing Pain]
return
}
;Shadow bolt
elseif ${Me.Action[Shadow Bolt].Usable}
{
This:Output[Shadow Bolt]
Toon:CastSpell[Shadow Bolt]
return
}
;No mana!! Smack on it!
if ${Me.Equip[ranged](exists)} && ${Target.Distance}<=30
{
if !${Me.Action[Shoot].AutoRepeat} && !${Me.Action[Shoot].Cooldown}
{
Me.Action[Shoot]:Use
This:Wait[100]
This:Output[Out of mana: Harry Potter this!]
}
}
elseif !${Me.Equip[ranged](exists)} && !${Me.Attacking}
{
WoWScript AttackTarget()
Toon:ToMelee
This:Output[Out of mana: Going OldSchool]
}
return
}
/************************************************************************************************************************************************************************************************
Buff Pulse and Need
************************************************************************************************************************************************************************************************/
member NeedBuff()
{
if ${Mount.IsMounted} || ${Mount.NeedMount}
return FALSE
ShardList:Clear
ShardList:Search[-items,-inventory,Soul Shard]
;Do we have a pet
if !${Me.Pet(exists)} && ${Spell[Summon ${MyPet}](exists)}
{
return TRUE
}
;Do we have a healthstone
if !${Item[Healthstone](exists)} && ${Spell[Create Healthstone](exists)}
{
if ${ShardList.Count} >= 2 && ${Inventory.FreeSlots} >= 2
{
return TRUE
}
}
;Do we need a soulstone
if ${useSoulstone} && ${Spell[Create Soulstone](exists)} && !${Me.Buff[Soulstone Resurrection](exists)} && ${WoWScript[GetItemCooldown("${Item[Soulstone].Name}"),1]} == 0
{
if ${ShardList.Count} >= 2 && ${Inventory.FreeSlots} >= 2
{
return TRUE
}
}
;Does our demon need health
if ${Me.Pet(exists)} && ${Me.Pet.PctHPs}<=${This.FunnelPetHP} && ${Spell[Health Funnel](exists)} && ${Me.PctHPs} >= ${This.FunnelMyHP}
{
return TRUE
}
;Do we need our armor
if !${Me.Buff[Fel Armor](exists)} && !${Me.Buff[Demon Armor](exists)} && !${Me.Buff[Demon Skin](exists)}
{
if ${Spell[Fel Armor](exists)}
{
return TRUE
}
elseif ${Spell[Demon Armor](exists)}
{
return TRUE
}
elseif ${Spell[Demon Skin](exists)}
{
return TRUE
}
}
;Do we need soul link
if (!${Me.Buff[Soul Link](exists)} && ${Spell[Soul Link](exists)}) && ${Me.Pet(exists)}
{
return TRUE
}
if (!${Me.Buff[Unending Breath](exists)} && ${Spell[Unending Breath](exists)}) && ${Me.Action["Unending Breath"].Usable} && ${This.useUnendingBreath}
{
return TRUE
}
return FALSE
}
method BuffPulse()
{
if ${Me.PctHPs} == 100 && ${Me.PctMana} == 100
Toon:Standup
if ${Me.Casting} || ${Me.Buff[Food](exists)} || ${Me.Buff[Drink](exists)} || ${Math.Calc[${LavishScript.RunningTime} - ${This.LastBuffCast}]} < 100
return
Toon:Standup
;Cast armor
if !${Me.Buff[Demon Skin](exists)} && !${Spell["Demon Armor"](exists)} && !${Spell["Fel Armor"](exists)}
{
if ${Toon.EnsureBuff[${Me.GUID},Demon Skin]}
This.LastBuffCast:Set[${LavishScript.RunningTime} + 1200]
}
elseif !${Me.Buff[Demon Armor](exists)} && !${Spell["Fel Armor"](exists)}
{
if ${Toon.EnsureBuff[${Me.GUID},Demon Armor]}
This.LastBuffCast:Set[${LavishScript.RunningTime} + 1200]
}
elseif !${Me.Buff[Fel Armor](exists)}
{
if ${Toon.EnsureBuff[${Me.GUID},Fel Armor]}
This.LastBuffCast:Set[${LavishScript.RunningTime} + 1200]
}
;Make healthstone
ShardList:Clear
ShardList:Search[-items,-inventory,Soul Shard]
if !${Item[Healthstone](exists)} && ${ShardList.Count}>= 2 && ${This.HSCreated} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Create Healthstone]
}
;Make and use soulstone
if ${useSoulstone}
{
WowScript ClearTarget()
if !${Item[Soulstone](exists)} && ${ShardList.Count}>= 2 && ${This.SSCreated} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Create Soulstone]
}
elseif ${Item[Soulstone](exists)} && !${Me.Buff[Soulstone Resurrection](exists)} && ${WoWScript[GetItemCooldown("${Item[Soulstone].Name}"),1]} == 0
{
Toon:Stop
Item[Soulstone]:Use
This.LastBuffCast:Set[${LavishScript.RunningTime} + 3200]
}
}
;Cast unending breath
if !${Me.Buff[Unending Breath](exists)} && ${Spell["Unending Breath"](exists)} && ${This.useUnendingBreath}
{
if ${Toon.EnsureBuff[${Me.GUID},Unending Breath]}
This.LastBuffCast:Set[${LavishScript.RunningTime} + 1200]
}
;Summon a demon
if ${Math.Calc[${LavishScript.RunningTime} - ${Mount.LastDismount}]} < 5000
return
if !${Me.Pet(exists)}&&${Spell["Summon ${MyPet}"](exists)}
{
if ${This.MyPet.Equal["Imp"]}&&${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon Imp]
}
elseif ${ShardList.Count}>= 1 &&${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon ${MyPet}]
}
elseif ${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Summon Imp]
}
}
;Health funnel the pet or tell voidwalker to consume shadows
elseif ${Me.Pet(exists)} && ${Me.Pet.PctHPs}<= ${This.FunnelPetHP} && ${Me.PctHPs} >= ${This.FunnelMyHP} && ${PetSummon} < ${LavishScript.RunningTime}
{
Toon:Stop
Toon:CastSpell[Health Funnel]
if ${Spell["Consume Shadows"](exists)}
WoWScript CastPetAction(6)
}
;Cast soul link
if !${Me.Buff[Soul Link](exists)} && ${Me.Pet(exists)} && ${Spell["Soul Link"](exists)}
{
Toon:CastSpell[Soul Link]
This.LastBuffCast:Set[${LavishScript.RunningTime} + 1200]
}
}
/************************************************************************************************************************************************************************************************
Rest Pulse and Need
************************************************************************************************************************************************************************************************/
member NeedRest()
{
if ${Me.Buff[Resurrection Sickness](exists)}
return TRUE
if ${Me.Pet.Casting(exists)}
return TRUE
if ${This.LootFirst}
return FALSE
if ${Me.PctHPs} == 100 && ${Me.PctMana} == 100
return FALSE
if ${Mount.IsMounted}
return FALSE
if ${Me.Pet.PctHPs}<=${This.FunnelPetHP} && ${Me.PctHPs} < ${This.FunnelMyHP}
return TRUE
;I think this is where I tap while moving and not causing a buffstate
if ${Me.Pet(exists)} && ${Spell[Dark Pact](exists)} && ${Me.Action[Dark Pact].Usable} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Me.Casting}
{
if ${Me.Pet.PctMana} > ${This.RestDPPetMana} && ${Me.PctMana} < ${This.RestDPMyMana}
{
Toon:CastSpell[Dark Pact]
return FALSE
}
}
if ${Me.PctHPs} > ${This.RestLTHealth} && ${Me.PctMana} < ${This.RestLTMana} &&${Spell[Life Tap](exists)}&&${Me.Action[Life Tap].Usable} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Me.Casting}
{
Toon:CastSpell[Life Tap]
return FALSE
}
;Health AND mana must both need replenishing to trigger a rest here
if ${useRestBoth}
{
if ${Me.PctHPs} < ${This.MinHealth} && ${Me.PctMana} < ${This.MinMana} || ${Me.Buff[Food](exists)} || ${Me.Buff[Drink](exists)}
{
return TRUE
}
}
else
{
if ${Me.PctHPs} < ${This.MinHealth} || ${Me.PctMana} < ${This.MinMana} || ${Me.Buff[Food](exists)} || ${Me.Buff[Drink](exists)}
return TRUE
}
return FALSE
}
method RestPulse()
{
if ${Me.Casting}
return
/* bandage if you got em */
if ${Me.PctHPs} < ${This.MinHealth} && ${Toon.canBandage} && !${Me.Sitting}
{
Toon:Bandage
return
}
;Cannibalize- this is a bit buggy, it wants to eat elementals?
if ${Me.Race.Equal["Undead"]} && !${Me.Sitting} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)}
{
if ${Me.PctHPs} < ${This.MinHealth} && ${Toon.canCast[Cannibalize]} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)})
{
Toon:CastSpell["Cannibalize"]
This:Output["Cannibalize"]
return
}
}
if ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && ${Me.PctMana} < 90
{
Toon:Stop
Consumable:useDrink
}
if ${Consumable.HasFood} && !${Me.Buff[Food](exists)} && ${Me.PctHPs} < 90
{
Toon:Stop
Consumable:useFood
}
}
/**************************************
PVP
**************************************/
method DotPVPAdds()
{
variable int i = 1
variable bool Corrup = ${Toon.canCast[Corruption]}
variable bool CoA = ${Toon.canCast[Curse of Agony]}
variable bool SL = ${Toon.canCast[Siphon Life]}
variable bool SB = ${Toon.canCast[Shadow Bolt]}
variable guidlist DotList
DotList:Clear
;DotList:Search[-units,-alive,-noself,-hostile,-nearest,-pvp,-nopets,-health 10,-range 0-30]
;DotList:Search[-units,-alive,-noself,-hostile,-pvp,-nopets,-players,-range 0-30,-lineofsight]
DotList:Search[-noself,-nopets,-players,-pvp,-alive,-notflying,-attackable,-range 0-30]
for(i:Set[1]; ${i} <= ${DotList.Count}; i:Inc)
{
if !${DotList.Object[${i}].Buff[Siphon Life](exists)} && !${Unit[${DotList[${i}].GUID}].IsTotem} && !${DotList.Object[${i}].Dead}
{
Target ${DotList.Object[${i}]}
Toon:CastSpell[Siphon Life]
This:Output["Dotty:Siphon Life on ${DotList.Object[${i}].Name}"]
return
}
}
for(i:Set[1]; ${i} <= ${DotList.Count}; i:Inc)
{
if ${DotList.Object[${i}].Class.Equal[Paladin]} || (${DotList.Object[${i}].Class.Equal[Priest]} && !${DotList.Object[${i}].Buff[Shadowform](exists)})
{
if !${DotList.Object[${i}].Buff[Curse of Tongues](exists)} && !${Unit[${DotList[${i}].GUID}].IsTotem} && !${DotList.Object[${i}].Dead}
{
Target ${DotList.Object[${i}]}
Toon:CastSpell[Curse of Tongues]
This:Output["Dotty:${DotList.Object[${i}].Class} Curse of Tongues on ${DotList.Object[${i}].Name}"]
return
}
}
elseif !${DotList.Object[${i}].Buff[Curse of Agony](exists)} && !${Unit[${DotList[${i}].GUID}].IsTotem} && !${DotList.Object[${i}].Dead}
{
Target ${DotList.Object[${i}]}
Toon:CastSpell[Curse of Agony]
This:Output["Dotty:Curse of Agony on ${DotList.Object[${i}].Name}"]
return
}
}
for(i:Set[1]; ${i} <= ${DotList.Count}; i:Inc)
{
if !${DotList.Object[${i}].Buff[Corruption](exists)} && !${Unit[${DotList[${i}].GUID}].IsTotem} && !${DotList.Object[${i}].Dead}
{
Target ${DotList.Object[${i}]}
Toon:CastSpell[Corruption]
This:Output["Dotty:Corruption on ${DotList.Object[${i}].Name}"]
return
}
}
AllDotted:Set[TRUE]
}
variable bool HookBGGuard = TRUE
member NeedBGGuard()
{
return TRUE
}
method BGGuardPulse()
{
if ${This.NeedBGPrebuff}
{
This:BGPrebuffPulse
}
if ${Mount.IsMounted}
{
Mount:Dismount
}
This:VigilantGuard
return
}
method VigilantGuard()
{
variable int random = ${Math.Rand[100]}
variable int randomheading = ${Math.Rand[360]}
variable int headingdiff
if ${random} == 13
{
do
{
randomheading:Set[${Math.Rand[360]}]
headingdiff:Set[${Math.Abs[${Me.Heading}-${randomheading}]}]
if ${headingdiff} > 180
{
headingdiff:Set[${Math.Calc[360-${headingdiff}]}]
}
}
while ${headingdiff} < 30
Face -heading ${randomheading}
}
}
/************************************************************************************************************************************************************************************************
Core
************************************************************************************************************************************************************************************************/
member LootFirst()
{
if ${Me.Sitting} || ${Me.Casting}
{
return FALSE
}
if ${Unit[-dead,-lootable,-range 0-4](exists)}
{
return TRUE
}
if ${Toon.HasSkill[Skinning]}
{
if ${Unit[-dead,-skinnable,-range 0-4](exists)} && ${Item[-inventory,"Skinning Knife"](exists)}
{
return TRUE
}
}
if ${LavishScript.RunningTime} <= ${State.LOOTState_Loot_Wait_Until}
{
return TRUE
}
return FALSE
}
variable bool NeedCombatIdle = TRUE
method CombatIdle()
{
; stuff to do while Idle in Combat
if ${Me.PctHPs} < ${This.MinHealth} && ${Toon.canBandage} && !${Me.Sitting}
{
Toon:Bandage
return
}
Toon:NeedTarget[1]
}
;------------------
;--- Flee SetUp ---
;------------------
variable bool HookFlee = FALSE
method FleePulse()
{
; stuff to do while fleeing
}
member IsStunned()
{
variable int i
for (i:Set[0]; ${i} < 20; i:Inc)
{
if ${Me.Buff[${i}].Harmful} && ${Me.Buff[${i}].Mechanic.Equal[stunned]}
{
return TRUE
}
}
return FALSE
}
member IsFeared()
{
variable int i
for (i:Set[0]; ${i} < 20; i:Inc)
{
if ${Me.Buff[${i}].Harmful} && ${Me.Buff[${i}].Mechanic.Equal[stunned]}
{
return TRUE
}
}
return FALSE
}
;Safe to rez from SS? UNUSED as of yet
member CanUseSS()
{
if ${Navigator.PointIsSafe[${Me.Location}]}
{
return TRUE
}
return FALSE
}
member NeedDead()
{
return TRUE
}
;This doesn't release if they don't have a SS
method DeadPulse()
{
if ${Config.GetCheckBox[chkSafeSS]} && ${useSoulstone}
{
if ${TimeOfDeath} < ${LavishScript.RunningTime}
{
if ${WoWScript[StaticPopup1:IsVisible()]}
{
if ${Navigator.PointIsSafe[${Me.Location}]}
{
This:Output["Safe to rez"]
WoWScript UseSoulstone()
WoWScript RepopMe()
}
else
{
This:Output["Not safe"]
WoWScript RepopMe()
}
}
}
return
}
else
{
if ${WoWScript[StaticPopup1:IsVisible()]}
{
WoWScript UseSoulstone()
WoWScript RepopMe()
}
}
}
;What is this and where did it come from? UNUSED
member GotAggro()
{
Aggro:Clear
Aggro:Search[-units,-nearest,-aggro,-alive,-range 0-30]
if ${Aggro.Count} >= ${This.inScreamAtMobCount}
{
This:Debug[Aggro: I have aggro!]
return TRUE
}
return FALSE
}
;Dynamic range adjustment based on talents
member GetSpellRange(int base, string spellTree)
{
if ${spellTree.Equal[affl]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Grim Reach]}))-1].Round}
}
if ${spellTree.Equal[destro]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Destructive Reach]}))-1].Round}
}
return ${base}
}
;Test for wanding and turn it off- possibly broken now
member AmWanding()
{
if ${Me.Action[Shoot].AutoRepeat}
{
This:Debug["Turning Wand Off"]
WoWScript SpellStopCasting()
return TRUE
}
return FALSE
}
method PullPulse()
{
if ${Mount.IsMounted}
Mount:Dismount
if ${PullTimeDelay}>${LavishScript.RunningTime}
{
; We shouldnt do anything
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
return
}
if !${Toon.ValidTarget[${Target.GUID}]}
{
; ensure we target is valid
This:Output["I need a target"]
Toon:NeedTarget[1]
if ${Me.Pet(exists)}
{
wowscript PetFollow()
}
return
}
if !${Toon.TargetIsBestTarget}
{
; ensure our target is the best target
This:Output["Target is no longer best target, aquire new target."]
Toon:BestTarget
return
}
; If I am currently casting or have global cooldown return
if ${Me.Casting} || ${Me.GlobalCooldown}
{
return
}
if !${Toon.withinRanged[TRUE]}
{
Toon:ToRanged
return
}
if ${Movement.Speed}
{
Toon:Stop
return
}
; Tell the pet to attack
if ${Me.Pet(exists)}
{
wowscript PetAttack()
PetPulled:Set[${LavishScript.RunningTime} + ${PetWait}]
}
; Bust Blood Fury if we got it and we can
if ${Spell[Blood Fury](exists)} && !${Spell[Blood Fury].Cooldown}
{
Toon:CastSpell["Blood Fury"]
return
}
; Pull it
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if !${This.usePull}
{
This:AttackPulse()
return
}
else
{
Toon:CastSpell["${This.PullSpell}"]
This:Output[Pull:${This.PullSpell}]
PullTimeDelay:Set[${Math.Calc[ ${LavishScript.RunningTime} + ${Spell[${This.PullSpell}].CastTime} + 1000 ]}]
}
}
method SetDistances()
{
if (${WandHealth} || ${WandNoNuke}) && ${Me.Equip[ranged](exists)}
{
This.MaxCombatRange:Set[29]
}
elseif ${This.GetSpellRange[30, "affl"]} < ${This.GetSpellRange[30, "destro"]}
{
This.MaxCombatRange:Set[${This.GetSpellRange[30, "affl"]}]
}
else
{
This.MaxCombatRange:Set[${This.GetSpellRange[30, "destro"]}]
}
if ${This.PullSpell.Equal["Fear"]}
{
This.MaxPullRange:Set[${This.GetSpellRange[20, "affl"]}]
}
else
{
This.MaxPullRange:Set[${This.GetSpellRange[30, "destro"]}]
}
}
;How many shards do we need to fill our shard bag (defaults to 5 if no shard bag)
member NumShards()
{
variable int Bags = 0
variable int Slots = 0
do
{
if ${Inventory.GetBagType[${Me.Bag[${Bags}].Name}].Equal["lock"]}
{
Slots:Inc[${Me.Bag[${Bags}].Slots}]
}
}
while ${Me.Bag[${Bags:Inc}](exists)}
if ${Slots}==0
{
Slots:Set[${This.ApocWantsShards}]
}
return ${Slots}
}
;Catches spells on successful cast and sets timers to avoid double casting
method CastCheck(string eventid , text, Who, SpellCast)
{
if ${SpellCast.Equal[Corruption]}
{
CorruCast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Amplify Curse]}
{
This:Debug["Amplify Curse successfully cast"]
AmpCast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Curse of Agony]}
{
This:Debug["CoA successfully cast"]
CoACast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Siphon Life]}
{
This:Debug["SL successfully cast"]
SLCast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Immolate]}
{
This:Debug["Immolate successfully cast"]
ImmoCast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Unstable Affliction]}
{
This:Debug["UA successfully cast"]
UACast:Set[${LavishScript.RunningTime} + 800]
}
if ${SpellCast.Equal[Summon Imp]}
{
This:Debug["Imp successfully cast"]
PetSummon:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Summon Voidwalker]}
{
This:Debug["VW successfully cast"]
PetSummon:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Summon Succubus]}
{
This:Debug["Succubus successfully cast"]
PetSummon:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Summon Felhunter]}
{
This:Debug["Felpup successfully cast"]
PetSummon:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Summon Felguard]}
{
This:Debug["Felguard successfully cast"]
PetSummon:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Create Healthstone]}
{
This:Debug["Healthstone created"]
HSCreated:Set[${LavishScript.RunningTime} + 3000]
}
if ${SpellCast.Equal[Create Soulstone]}
{
This:Debug["Soulstone created"]
SSCreated:Set[${LavishScript.RunningTime} + 3000]
}
if ${SpellCast.Equal[Fear]}
{
This:Debug["Fear successfully cast"]
FearCast:Set[${LavishScript.RunningTime} + 5000]
PullSpellCast:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Howl of Terror]}
{
This:Debug["Howl of Terror successfully cast"]
FearCast:Set[${LavishScript.RunningTime} + 5000]
}
if ${SpellCast.Equal[Shadow Bolt]}
{
This:Debug["Shadow Bolt successfully cast"]
PullSpellCast:Set[${LavishScript.RunningTime} + 1500]
}
if ${SpellCast.Equal[Curse of Recklessness]}
{
This:Debug["Curse of Recklessness"]
CoRCast:Set[${LavishScript.RunningTime} + 1500]
}
}
method YouDied()
{
TimeOfDeath:Set[${LavishScript.RunningTime} + 10000]
This:Output["You're a WARLOCK! How can you die?!"]
}
member InBG()
{
if ${WoWScript[GetRealZoneText()].Equal["Alterac Valley"]} || ${WoWScript[GetRealZoneText()].Equal["Eye of the Storm"]} || ${WoWScript[GetRealZoneText()].Equal["Warsong Gulch"]} || ${WoWScript[GetRealZoneText()].Equal["Arathi Basin"]}
return TRUE
else
return FALSE
}
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
}
method DotAdds()
{
if ${This.HaveAdds}
{
variable guidlist AggroList
AggroList:Clear
AggroList:Search[-units,-nearest,-nopets,-aggro,-alive,-range 0-30]
variable int i
for (i:Set[1]; ${i}<=${AggroList.Count}; i:Inc)
{
if ${Toon.ValidTarget[${AggroList.GUID[${i}]}]}
{
if !${Unit[${AggroList.GUID[${i}]}].Buff[Siphon Life](exists)} && !${Unit[${AggroList.GUID[${i}]}].IsTotem}
{
target ${AggroList.GUID[${i}]}
Toon:CastSpell[Siphon Life]
This:Output[Add: Siphon Life]
}
}
}
}
}
/************************************************************************************************************************************************************************************************
Load and Save
************************************************************************************************************************************************************************************************/
method Initialize()
{
LavishScript:RegisterEvent[TOON_GUI_CHANGE]
LavishScript:RegisterEvent[TOON_SLIDE_CHANGE]
LavishScript:RegisterEvent[PLAYER_DEAD]
Event[TOON_SLIDE_CHANGE]:AttachAtom[${This.ObjectName}:SliderChange]
Event[UNIT_SPELLCAST_SUCCEEDED]:AttachAtom[${This.ObjectName}:CastCheck]
Event[PLAYER_DEAD]:AttachAtom[${This.ObjectName}:YouDied]
Event[TOON_GUI_CHANGE]:AttachAtom[${This.ObjectName}:ClassGUIChange]
This:LoadConfig
This:InitLockGui[spells]
This:SetDistances
if ${Me.FactionGroup.Equal[Alliance]}
OppositeFaction:Set["Horde"]
if ${Me.FactionGroup.Equal[Horde]}
OppositeFaction:Set["Alliance"]
This:Output["${This.version}"]
This:Output["${This.tagline}"]
}
method LoadConfig()
{
/** Pet Variables **/
This.MyPet:Set[${Config.GetSetting["${RealmChar}","MyPet","Imp"]}]
This.FunnelPetHP:Set[${Config.GetSetting["${RealmChar}","FunnelPetHP",50]}]
This.FunnelMyHP:Set[${Config.GetSetting["${RealmChar}","FunnelMyHP",70]}]
This.PetWait:Set[${Config.GetSetting["${RealmChar}","PetWait",5000]}]
This.ApocWantsShards:Set[${Config.GetSetting["${RealmChar}","ApocWantsShards",5]}]
/** Dot Variables **/
This.useCorruption:Set[${Config.GetSetting["${RealmChar}","useCorruption",TRUE]}]
This.useAmp:Set[${Config.GetSetting["${RealmChar}","useAmp",TRUE]}]
This.useCoA:Set[${Config.GetSetting["${RealmChar}","useCoA",TRUE]}]
This.useSiphonLife:Set[${Config.GetSetting["${RealmChar}","useSiphonLife",TRUE]}]
This.useUnstableAffliction:Set[${Config.GetSetting["${RealmChar}","useUnstableAffliction",TRUE]}]
This.useImmolate:Set[${Config.GetSetting["${RealmChar}","useImmolate",TRUE]}]
/** Direct Damage Variables **/
This.WandNoNuke:Set[${Config.GetSetting["${RealmChar}","WandNoNuke",FALSE]}]
This.useSearingPain:Set[${Config.GetSetting["${RealmChar}","useSearingPain",TRUE]}]
This.useIncinerate:Set[${Config.GetSetting["${RealmChar}","useIncinerate",TRUE]}]
This.useDrainLife:Set[${Config.GetSetting["${RealmChar}","useDrainLife",TRUE]}]
This.useConflag:Set[${Config.GetSetting["${RealmChar}","useConflag",TRUE]}]
This.conflPop:Set[${Config.GetSetting["${RealmChar}","conflPop",4000]}]
/** Lifetap Variables **/
This.ComLTHealth:Set[${Config.GetSetting["${RealmChar}","ComLTHealth",50]}]
This.ComLTMana:Set[${Config.GetSetting["${RealmChar}","ComLTMana",80]}]
This.RestLTHealth:Set[${Config.GetSetting["${RealmChar}","RestLTHealth",50]}]
This.RestLTMana:Set[${Config.GetSetting["${RealmChar}","RestLTMana",80]}]
/** Darkpact Variables **/
This.ComDPPetMana:Set[${Config.GetSetting["${RealmChar}","ComDPPetMana",15]}]
This.ComDPMyMana:Set[${Config.GetSetting["${RealmChar}","ComDPMyMana",85]}]
This.RestDPPetMana:Set[${Config.GetSetting["${RealmChar}","RestDPPetMana",15]}]
This.RestDPMyMana:Set[${Config.GetSetting["${RealmChar}","RestDPMyMana",85]}]
/** Vitality Variables **/
This.MinMana:Set[${Config.GetSetting["${RealmChar}","MinMana",50]}]
This.MinHealth:Set[${Config.GetSetting["${RealmChar}","MinHealth",60]}]
This.useRestBoth:Set[${Config.GetSetting["${RealmChar}","useRestBoth",TRUE]}]
This.DrainLifeHP:Set[${Config.GetSetting["${RealmChar}","DrainLifeHP",90]}]
This.HSHealth:Set[${Config.GetSetting["${RealmChar}","HSHealth",40]}]
This.PanicHealth:Set[${Config.GetSetting["${RealmChar}","PanicHealth",20]}]
This.VWSackHP:Set[${Config.GetSetting["${RealmChar}","VWSackHP",30]}]
/** Misc Variables **/
This.usePull:Set[${Config.GetSetting["${RealmChar}","usePull",TRUE]}]
/* This.PullRange:Set[${Config.GetSetting["${RealmChar}","PullRange",30]}] */
This.PullSpell:Set[${Config.GetSetting["${RealmChar}","PullSpell","Shadow Bolt"]}]
This.MaxCombatRange:Set[${Config.GetSetting["${RealmChar}","MaxCombatRange",28]}]
This.FearJuggle:Set[${Config.GetSetting["${RealmChar}","FearJuggle",FALSE]}]
This.FearElites:Set[${Config.GetSetting["${RealmChar}","FearElites",FALSE]}]
This.useUnendingBreath:Set[${Config.GetSetting["${RealmChar}","useUnendingBreath",FALSE]}]
This.useSoulstone:Set[${Config.GetSetting["${RealmChar}","useSoulstone",FALSE]}]
This.DrainSoulHP:Set[${Config.GetSetting["${RealmChar}","DrainSoulHP",30]}]
This.WandHealth:Set[${Config.GetSetting["${RealmChar}","WandHealth",30]}]
/* New Config Based */
Config:SetCheckBox[${uniqueToon},"chkSafeSS","chkSafeSS@Vitality@Pages@ClassGUI",TRUE]
}
method SaveConfig()
{
/** Pet Variables **/
Config:SetSetting["${RealmChar}","MyPet",${This.MyPet}]
Config:SetSetting["${RealmChar}","FunnelPetHP",${This.FunnelPetHP}]
Config:SetSetting["${RealmChar}","FunnelMyHP",${This.FunnelMyHP}]
Config:SetSetting["${RealmChar}","PetWait",${This.PetWait}]
Config:SetSetting["${RealmChar}","ApocWantsShards",${This.ApocWantsShards}]
/** Dot Variables **/
Config:SetSetting["${RealmChar}","useCorruption",${This.useCorruption}]
Config:SetSetting["${RealmChar}","useAmp",${This.useAmp}]
Config:SetSetting["${RealmChar}","useCoA",${This.useCoA}]
Config:SetSetting["${RealmChar}","useSiphonLife",${This.useSiphonLife}]
Config:SetSetting["${RealmChar}","useUnstableAffliction",${This.useUnstableAffliction}]
Config:SetSetting["${RealmChar}","useImmolate",${This.useImmolate}]
/** Direct Damage Variables **/
Config:SetSetting["${RealmChar}","WandNoNuke",${This.WandNoNuke}]
Config:SetSetting["${RealmChar}","useSearingPain",${This.useSearingPain}]
Config:SetSetting["${RealmChar}","useIncinerate",${This.useIncinerate}]
Config:SetSetting["${RealmChar}","useDrainLife",${This.useDrainLife}]
Config:SetSetting["${RealmChar}","useConflag",${This.useConflag}]
Config:SetSetting["${RealmChar}","conflPop",${This.conflPop}]
/** Lifetap Variables **/
Config:SetSetting["${RealmChar}","ComLTHealth",${This.ComLTHealth}]
Config:SetSetting["${RealmChar}","ComLTMana",${This.ComLTMana}]
Config:SetSetting["${RealmChar}","RestLTHealth",${This.RestLTHealth}]
Config:SetSetting["${RealmChar}","RestLTMana",${This.RestLTMana}]
/** Darkpact Variables **/
Config:SetSetting["${RealmChar}","ComDPPetMana",${This.ComDPPetMana}]
Config:SetSetting["${RealmChar}","ComDPMyMana",${This.ComDPMyMana}]
Config:SetSetting["${RealmChar}","RestDPPetMana",${This.RestDPPetMana}]
Config:SetSetting["${RealmChar}","RestDPMyMana",${This.RestDPMyMana}]
/** Vitality Variables **/
Config:SetSetting["${RealmChar}","MinMana",${This.MinMana}]
Config:SetSetting["${RealmChar}","MinHealth",${This.MinHealth}]
Config:SetSetting["${RealmChar}","useRestBoth",${This.useRestBoth}]
Config:SetSetting["${RealmChar}","DrainLifeHP",${This.DrainLifeHP}]
Config:SetSetting["${RealmChar}","HSHealth",${This.HSHealth}]
Config:SetSetting["${RealmChar}","PanicHealth",${This.PanicHealth}]
Config:SetSetting["${RealmChar}","VWSackHP",${This.VWSackHP}]
/** Misc Variables **/
Config:SetSetting["${RealmChar}","usePull",${This.usePull}]
/* Config:SetSetting["${RealmChar}","PullRange",${This.PullRange}] */
Config:SetSetting["${RealmChar}","PullSpell",${This.PullSpell}]
Config:SetSetting["${RealmChar}","MaxCombatRange",${This.MaxCombatRange}]
Config:SetSetting["${RealmChar}","FearJuggle",${This.FearJuggle}]
Config:SetSetting["${RealmChar}","FearElites",${This.FearElites}]
Config:SetSetting["${RealmChar}","useUnendingBreath",${This.useUnendingBreath}]
Config:SetSetting["${RealmChar}","useSoulstone",${This.useSoulstone}]
Config:SetSetting["${RealmChar}","DrainSoulHP",${This.DrainSoulHP}]
Config:SetSetting["${RealmChar}","WandHealth",${This.WandHealth}]
Config:SaveCheckBox[${uniqueToon},"chkSafeSS"]
}
method Shutdown()
{
This:SaveConfig
Event[UI_ERROR_MESSAGE]:DetachAtom[${This.ObjectName}:ErrorMessage]
Event[TOON_GUI_VISIBLE]:Unregister
Event[UNIT_SPELLCAST_SUCCEEDED]:DetachAtom[${This.ObjectName}:CastCheck]
Event[PLAYER_DEAD]:DetachAtom[${This.ObjectName}:YouDied]
Event[TOON_SLIDE_CHANGE]:DetachAtom[${This.ObjectName}:SliderChange]
Event[TOON_GUI_CHANGE]:DetachAtom[${This.ObjectName}:ClassGUIChange]
Event[PLAYER_DEAD]:Unregister
Event[TOON_GUI_CHANGE]:Unregister
Event[TOON_SLIDE_CHANGE]:Unregister
}
/************************************************************************************************************************************************************************************************
GUI
************************************************************************************************************************************************************************************************/
method SliderChange(string Action)
{
variable int Value
switch ${Action}
{
case wandmonsterhealth
Value:Set[${UIElement[sldWandMonsterHealth@Spells@Pages@ClassGUI].Value}]
if ${Value}
{
This.WandHealth:Set[${Value}]
UIElement[txtWandMonsterHealth@Spells@Pages@ClassGUI]:SetText["Wand Monster at ${Value} pct"]
}
else
{
This.WandHealth:Set[0]
UIElement[txtWandMonsterHealth@Spells@Pages@ClassGUI]:SetText["Disabled"]
}
break
case petaggrowait
Value:Set[${UIElement[sldPetAggroWait@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.PetWait:Set[${Math.Calc[${Value} * 1000]}]
UIElement[txtPetAggroWait@Pet@Pages@ClassGUI]:SetText["Pet aggros ${Value} secs before attack"]
}
else
{
This.PetWait:Set[0]
UIElement[txtPetAggroWait@Pet@Pages@ClassGUI]:SetText["Attack at same time as pet"]
}
break
case funnelpet
Value:Set[${UIElement[sldFunnelPet@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.FunnelPetHP:Set[${Value}]
UIElement[txtFunnelPet@Pet@Pages@ClassGUI]:SetText["Funnel pet at ${Value} pct"]
}
else
{
This.FunnelPetHP:Set[0]
UIElement[txtFunnelPet@Pet@Pages@ClassGUI]:SetText["Never heal pet"]
}
break
case funnelme
Value:Set[${UIElement[sldFunnelMe@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.FunnelMyHP:Set[${Value}]
UIElement[txtFunnelMe@Pet@Pages@ClassGUI]:SetText["Funnel if I'm above ${Value} pct health"]
}
else
{
This.FunnelMyHP:Set[0]
UIElement[txtFunnelMe@Pet@Pages@ClassGUI]:SetText["Funnel regardless of my health"]
}
break
case comlifetapmana
Value:Set[${UIElement[sldLTCMyMana@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.ComLTMana:Set[${Value}]
UIElement[txtLTCMyMana@Vitality@Pages@ClassGUI]:SetText["Lifetap if mana is below ${Value} pct during combat"]
}
else
{
This.ComLTMana:Set[0]
UIElement[txtLTCMyMana@Vitality@Pages@ClassGUI]:SetText["Never Lifetap"]
}
break
case comlifetaphealth
Value:Set[${UIElement[sldLTCMyHealth@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.ComLTHealth:Set[${Value}]
UIElement[txtLTCMyHealth@Vitality@Pages@ClassGUI]:SetText["Lifetap if health is above ${Value} pct during combat"]
}
else
{
This.ComLTHealth:Set[0]
UIElement[txtLTCMyHealth@Vitality@Pages@ClassGUI]:SetText["Lifetap regardless of health"]
}
break
case restlifetaphealth
Value:Set[${UIElement[sldLTRMyHealth@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.RestLTHealth:Set[${Value}]
UIElement[txtLTRMyHealth@Vitality@Pages@ClassGUI]:SetText["Lifetap if health is above ${Value} pct out of combat"]
}
else
{
This.RestLTHealth:Set[0]
UIElement[txtLTRMyHealth@Vitality@Pages@ClassGUI]:SetText["Lifetap regardless of health"]
}
break
case restlifetapmana
Value:Set[${UIElement[sldLTRMyMana@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.RestLTMana:Set[${Value}]
UIElement[txtLTRMyMana@Vitality@Pages@ClassGUI]:SetText["Lifetap if mana is below ${Value} pct out of combat"]
}
else
{
This.RestLTMana:Set[0]
UIElement[txtLTRMyMana@Vitality@Pages@ClassGUI]:SetText["Never Lifetap"]
}
break
case sacvw
Value:Set[${UIElement[sldSacVW@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.VWSackHP:Set[${Value}]
UIElement[txtSacVW@Vitality@Pages@ClassGUI]:SetText["Sacrifice voidwalker when I'm at ${Value} pct"]
}
else
{
This.VWSackHP:Set[0]
UIElement[txtSacVW@Vitality@Pages@ClassGUI]:SetText["Never Sacrifice VW"]
}
break
case conflpopwait
Value:Set[${UIElement[sldConflPop@Spells@Pages@ClassGUI].Value}]
if ${Value}
{
This.conflPop:Set[${Math.Calc[${Value} * 1000]}]
UIElement[txtConflPop@Spells@Pages@ClassGUI]:SetText["Pop Conflagrate ${Value} secs after Immolate"]
}
else
{
This.conflPop:Set[0]
UIElement[txtConflPop@Spells@Pages@ClassGUI]:SetText["Pop Conflagrate immediately"]
}
break
case panicat
Value:Set[${UIElement[sldFearAt@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.PanicHealth:Set[${Value}]
UIElement[lblFearAt@Vitality@Pages@ClassGUI]:SetText["Deathcoil/Fear At: ${Value} pct health"]
}
else
{
This.PanicHealth:Set[0]
UIElement[lblFearAt@Vitality@Pages@ClassGUI]:SetText["Never Deathcoil/Fear when health low"]
}
break
case drainsoulat
Value:Set[${UIElement[sldDrainSoulAt@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.DrainSoulHP:Set[${Value}]
UIElement[lblDrainSoulAt@Vitality@Pages@ClassGUI]:SetText["Drain Soul At: ${Value} pct health"]
}
else
{
This.DrainSoulHP:Set[0]
UIElement[lblDrainSoulAt@Vitality@Pages@ClassGUI]:SetText["Never drain souls"]
}
break
case drainlifeat
Value:Set[${UIElement[sldDrainLifeAt@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.DrainLifeHP:Set[${Value}]
UIElement[lblDrainLifeAt@Vitality@Pages@ClassGUI]:SetText["Drain Life At: ${Value} pct health"]
}
else
{
This.DrainLifeHP:Set[0]
UIElement[lblDrainLifeAt@Vitality@Pages@ClassGUI]:SetText["Never drain life"]
}
break
case minhealth
Value:Set[${UIElement[sldMinHealth@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.MinHealth:Set[${Value}]
UIElement[lblMinHealth@Vitality@Pages@ClassGUI]:SetText["Rest At: ${Value} pct health"]
}
else
{
This.MinHealth:Set[0]
UIElement[lblMinHealth@Vitality@Pages@ClassGUI]:SetText["Never rest due to health"]
}
break
case minmana
Value:Set[${UIElement[sldMinMana@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.MinMana:Set[${Value}]
UIElement[lblMinMana@Vitality@Pages@ClassGUI]:SetText["Rest At: ${Value} pct mana"]
}
else
{
This.MinMana:Set[0]
UIElement[lblMinMana@Vitality@Pages@ClassGUI]:SetText["Never rest due to mana"]
}
break
case usehealthstone
Value:Set[${UIElement[sldUseHealthstone@Vitality@Pages@ClassGUI].Value}]
if ${Value}
{
This.HSHealth:Set[${Value}]
UIElement[lblUseHealthstone@Vitality@Pages@ClassGUI]:SetText["Healthstone At: ${Value} pct health"]
}
else
{
This.HSHealth:Set[0]
UIElement[lblUseHealthstone@Vitality@Pages@ClassGUI]:SetText["Never use healthstones"]
}
case dpcpet
Value:Set[${UIElement[sldDPCPetMana@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.ComDPPetMana:Set[${Value}]
UIElement[lblDPCPetMana@Pet@Pages@ClassGUI]:SetText["Dark Pact in combat if pet is above: ${Value} pct mana"]
}
else
{
This.ComDPPetMana:Set[0]
UIElement[lblDPCPetMana@Pet@Pages@ClassGUI]:SetText["Dark Pact all of pet mana in combat"]
}
break
case dpcme
Value:Set[${UIElement[sldDPCMyMana@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.ComDPMyMana:Set[${Value}]
UIElement[lblDPCMyMana@Pet@Pages@ClassGUI]:SetText["Dark Pact in combat if I'm below: ${Value} pct mana"]
}
else
{
This.ComDPMyMana:Set[0]
UIElement[lblDPCMyMana@Pet@Pages@ClassGUI]:SetText["Never Dark Pact in combat"]
}
break
case dprpet
Value:Set[${UIElement[sldDPRPetMana@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.RestDPPetMana:Set[${Value}]
UIElement[lblDPRPetMana@Pet@Pages@ClassGUI]:SetText["Dark Pact at rest if pet is above: ${Value} pct mana"]
}
else
{
This.RestDPPetMana:Set[0]
UIElement[lblDPRPetMana@Pet@Pages@ClassGUI]:SetText["Never Dark Pact at rest"]
}
break
case dprme
Value:Set[${UIElement[sldDPRMyMana@Pet@Pages@ClassGUI].Value}]
if ${Value}
{
This.RestDPMyMana:Set[${Value}]
UIElement[lblDPRMyMana@Pet@Pages@ClassGUI]:SetText["Dark Pact at rest if I'm below: ${Value} pct mana"]
}
else
{
This.RestDPMyMana:Set[0]
UIElement[lblDPRMyMana@Pet@Pages@ClassGUI]:SetText["Never Dark Pact at rest"]
}
break
case keepnumshards
Value:Set[${UIElement[sldNumShards@Pet@Pages@ClassGUI].Value}]
variable int Bags = 0
variable int Slots = 0
variable int TotalSlots = 0
do
{
if ${Inventory.GetBagType[${Me.Bag[${Bags}].Name}].Equal["lock"]}
{
Slots:Inc[${Me.Bag[${Bags}].Slots}]
}
TotalSlots:Inc[${Me.Bag[${Bags}].Slots}]
}
while ${Me.Bag[${Bags:Inc}](exists)}
if ${Slots}==0 /* We don't have a soulbag, how many do we need? */
{
if ${Value}<=4 /* Minimum set to 5 shards */
{
This.ApocWantsShards:Set[5]
UIElement[sldNumShards@Pet@Pages@ClassGUI]:SetValue[5]
}
elseif ${TotalSlots} < ${Value} /* Are you farming more shards than you have space for? */
{
This.ApocWantsShards:Set[${TotalSlots}]
UIElement[sldNumShards@Pet@Pages@ClassGUI]:SetValue[${TotalSlots}]
}
else
{
This.ApocWantsShards:Set[${Value}]
}
UIElement[txtNumShards@Pet@Pages@ClassGUI]:SetText["Farming ${This.ApocWantsShards} shards"]
}
else /* We have a soulbag, so let's lock our shards to what it can hold */
{
This.ApocWantsShards:Set[${Slots}]
UIElement[txtNumShards@Pet@Pages@ClassGUI]:SetText["${This.ApocWantsShards} shard soulbag"]
UIElement[sldNumShards@Pet@Pages@ClassGUI]:SetValue[${Slots}]
}
break
}
}
method InitLockGui(string tab)
{
/** Pet **/
variable int i = 1
for (i:Set[1] ; ${i}<=${UIElement[cmbPet@Pet@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.MyPet.Equal[${UIElement[cmbPet@Pet@Pages@ClassGUI].Item[${i}].Text}]}
{
UIElement[cmbPet@Pet@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbDPCPetMana@Pet@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.ComDPPetMana} == ${UIElement[cmbDPCPetMana@Pet@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDPCPetMana@Pet@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbDPCMyMana@Pet@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.ComDPMyMana} == ${UIElement[cmbDPCMyMana@Pet@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDPCMyMana@Pet@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbDPRPetMana@Pet@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.RestDPPetMana} == ${UIElement[cmbDPRPetMana@Pet@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDPRPetMana@Pet@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbDPRMyMana@Pet@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.RestDPMyMana} == ${UIElement[cmbDPRMyMana@Pet@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDPRMyMana@Pet@Pages@ClassGUI]:SelectItem[${i}]
}
}
/** Vitality **/
for (i:Set[1] ; ${i}<=${UIElement[cmbDrainLifeAt@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.DrainLifeHP} == ${UIElement[cmbDrainLifeAt@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDrainLifeAt@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbDrainSoulAt@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.DrainSoulHP} == ${UIElement[cmbDrainSoulAt@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbDrainSoulAt@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbFearAt@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PanicHealth} == ${UIElement[cmbFearAt@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbFearAt@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbMinHealth@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.MinHealth} == ${UIElement[cmbMinHealth@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbMinHealth@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbMinMana@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.MinMana} == ${UIElement[cmbMinMana@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbMinMana@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbUseHealthstone@Vitality@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.HSHealth} == ${UIElement[cmbUseHealthstone@Vitality@Pages@ClassGUI].Item[${i}].Value}
{
UIElement[cmbUseHealthstone@Vitality@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i}<=${UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PullSpell.Equal[${UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI].Item[${i}].Text}]}
{
UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI]:SelectItem[${i}]
}
}
UIElement[sldWandMonsterHealth@Spells@Pages@ClassGUI]:SetValue[${This.WandHealth}]
UIElement[sldPetAggroWait@Pet@Pages@ClassGUI]:SetValue[${Math.Calc[${This.PetWait} / 1000]}]
UIElement[sldFunnelPet@Pet@Pages@ClassGUI]:SetValue[${This.FunnelPetHP}]
UIElement[sldFunnelMe@Pet@Pages@ClassGUI]:SetValue[${This.FunnelMyHP}]
UIElement[sldLTCMyMana@Vitality@Pages@ClassGUI]:SetValue[${This.ComLTMana}]
UIElement[sldLTCMyHealth@Vitality@Pages@ClassGUI]:SetValue[${This.ComLTHealth}]
UIElement[sldLTRMyHealth@Vitality@Pages@ClassGUI]:SetValue[${This.RestLTHealth}]
UIElement[sldLTRMyMana@Vitality@Pages@ClassGUI]:SetValue[${This.RestLTMana}]
UIElement[sldSacVW@Vitality@Pages@ClassGUI]:SetValue[${This.VWSackHP}]
UIElement[sldFearAt@Vitality@Pages@ClassGUI]:SetValue[${This.PanicHealth}]
UIElement[sldDrainSoulAt@Vitality@Pages@ClassGUI]:SetValue[${This.DrainSoulHP}]
UIElement[sldDrainLifeAt@Vitality@Pages@ClassGUI]:SetValue[${This.DrainLifeHP}]
UIElement[sldMinHealth@Vitality@Pages@ClassGUI]:SetValue[${This.MinHealth}]
UIElement[sldMinMana@Vitality@Pages@ClassGUI]:SetValue[${This.MinMana}]
UIElement[sldUseHealthstone@Vitality@Pages@ClassGUI]:SetValue[${This.HSHealth}]
UIElement[sldDPCPetMana@Pet@Pages@ClassGUI]:SetValue[${This.ComDPPetMana}]
UIElement[sldDPCMyMana@Pet@Pages@ClassGUI]:SetValue[${This.ComDPMyMana}]
UIElement[sldDPRPetMana@Pet@Pages@ClassGUI]:SetValue[${This.RestDPPetMana}]
UIElement[sldDPRMyMana@Pet@Pages@ClassGUI]:SetValue[${This.RestDPMyMana}]
UIElement[sldNumShards@Pet@Pages@ClassGUI]:SetValue[${This.ApocWantsShards}]
}
method ClassGUIChange(string Action)
{
switch ${Action}
{
/** Pet **/
case selectpet
if ${UIElement[cmbPet@Pet@Pages@ClassGUI].SelectedItem.Text(exists)}
{
This.MyPet:Set[${UIElement[cmbPet@Pet@Pages@ClassGUI].SelectedItem.Text}]
}
break
/** Spells **/
case usepull
This.usePull:Set[!${This.usePull}]
break
case wandnuke
This.WandNoNuke:Set[!${This.WandNoNuke}]
break
case usecorr
This.useCorruption:Set[!${This.useCorruption}]
break
case useamp
This.useAmp:Set[!${This.useAmp}]
break
case usecoa
This.useCoA:Set[!${This.useCoA}]
break
case usesl
This.useSiphonLife:Set[!${This.useSiphonLife}]
break
case useua
This.useUnstableAffliction:Set[!${This.useUnstableAffliction}]
break
case useimmo
This.useImmolate:Set[!${This.useImmolate}]
break
case useconfl
This.useConflag:Set[!${This.useConflag}]
break
case usesp
This.useSearingPain:Set[!${This.useSearingPain}]
break
case usedl
This.useDrainLife:Set[!${This.useDrainLife}]
break
case useincin
This.useIncinerate:Set[!${This.useIncinerate}]
break
case usefj
This.FearJuggle:Set[!${This.FearJuggle}]
break
case fearleet
This.FearElites:Set[!${This.FearElites}]
break
case usebreath
This.useUnendingBreath:Set[!${This.useUnendingBreath}]
break
case usesoulstone
This.useSoulstone:Set[!${This.useSoulstone}]
break
case pullspell
if ${UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI].SelectedItem.Text(exists)}
{
This.PullSpell:Set[${UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI].SelectedItem.Text}]
if ${UIElement[cmbUsePullSpell@Spells@Pages@ClassGUI].SelectedItem.Text.Equal["Fear"]}
{
This.MaxPullRange:Set[${This.GetSpellRange[20, "affl"]}]
This.MaxCombatRange:Set[${This.GetSpellRange[20, "affl"]}]
}
else
{
This.MaxPullRange:Set[${This.GetSpellRange[30, "destro"]}]
This.MaxCombatRange:Set[${This.GetSpellRange[30, "destro"]}]
}
}
break
/** Vitality **/
case useboth
This.useRestBoth:Set[!${This.useRestBoth}]
break
case defaultgeneric
break
}
}
}