rendered paste bodyobjectdef oClass inherits oBase
{
/************ VARIABLES ***************/
variable bool UsePull = TRUE
variable string PullSpell = "None"
variable int RestHP = 50
variable int RestMP = 50
variable int StandHP = 100
variable int StandMP = 100
variable string EarthTotem = ""
variable string FireTotem = ""
variable string AirTotem = ""
variable string WaterTotem = ""
variable bool UseEarthElemental = FALSE
variable bool UseFireElemental = FALSE
variable bool EarthbindRunners = FALSE
variable bool UseEarthShock = FALSE
variable bool UseFlameShock = FALSE
variable bool UseFrostShock = FALSE
variable bool FrostShockRunners = FALSE
variable bool RandomShock = FALSE
variable int ConserveMana = 40
variable bool UseLBolt = FALSE
variable bool UseChainLight = FALSE
variable string MainHand = "None"
variable string OffHand = "None"
variable string Shield = "None"
variable bool ShieldOnPull = FALSE
variable bool DW = FALSE
variable int HealWave = 20
variable int LHealWave = 50
variable int ChainHeal = 50
variable int GOTN = 60
variable bool Output = TRUE
variable bool Flee = TRUE
variable int MaxCastRange = 30
variable int MaxShockRange = 20
variable bool HookFlee = FALSE
variable bool HasEarthTotem = FALSE
variable bool HasFireTotem = FALSE
variable bool HasWaterTotem = FALSE
variable bool HasWindTotem = FALSE
variable bool UseHPot = FALSE
variable bool UseMPot = FALSE
variable bool UseBandages = FALSE
variable int HPot = 25
variable int MPot = 25
variable int Bandage = 25
variable int restWaitTimer = 0
variable int buffWaitTimer = 0
variable int PotTimer = 0
variable int DangerMedium = 15
variable int DangerHigh = 30
variable int DangerVeryHigh = 45
variable int DangerLevel = 0
variable int Dangerlvl = 0
variable int BuffNum = 0
variable bool Fleeing = FALSE
variable bool debuffStatus = FALSE
variable string RealmChar = "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
variable bool MeleeOnly = FALSE
method RestPulse()
{
if ${Movement.Speed}
{
Toon:Stop
}
if ${This.ShouldCallTotems}
{
Toon:CastSpell["Totemic Call"]
This:CustOutput["Calling my totems back"]
return
}
if !${Consumable.HasFood} && ${Me.PctHPs} < ${StandHP} && ${Toon.canCast[Healing Wave]} && !${Me.Buff[Drink](exists)}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave - Rest"]
return
}
if ${Me.PctHPs} < ${This.Bandage} && ${Toon.canBandage} && !${Me.Sitting} && ${This.UseBandages}
{
Toon:Bandage
This:CustOutput["Bandaging...."]
return
}
if ${Me.PctHPs} < ${This.RestHP} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)} && !${Me.Casting}
{
Consumable:useFood
This:CustOutput["Eating..."]
return
}
if ${Me.PctMana} < ${This.RestMP} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Casting}
{
Consumable:useDrink
This:CustOutput["Drinking..."]
return
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
Toon:Sitdown
This:CustOutput["I've got Resurrection Sickness. Sittin the fuck down."]
return
}
if ${Me.PctMana} >= ${This.StandMP} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Me.Casting} && !${Me.Buff[Resurrection Sickness](exists)}
{
Toon:Standup
This:CustOutput["Done Resting!"]
return
}
}
member NeedRest()
{
if ${Me.InCombat} || ${Targeting.realAgg}
{
return FALSE
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
return TRUE
}
if ${Me.PctHPs} < ${This.RestHP} && !${Me.Buff[Food](exists)} && !${Me.Casting}
{
return TRUE
}
if ${Me.PctMana} < ${This.RestMP} && !${Me.Buff[Drink](exists)} && !${Me.Casting}
{
return TRUE
}
if ${Me.PctHPs} < ${This.StandHP} && ${Me.Sitting}
{
return TRUE
}
if ${Me.PctMana} < ${This.StandMP} && ${Me.Sitting}
{
return TRUE
}
if ${This.ShouldCallTotems}
{
return TRUE
}
return FALSE
}
member NeedBuff()
{
if ${Toon.canUseScroll}
{
return TRUE
This:CustOutput["Need a scroll buff"]
}
if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast["${This.MainHand} Weapon"]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
{
return TRUE
This:CustOutput["Need Mainhand Buff - ${This.MainHand}"]
}
if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast["${This.OffHand} Weapon"]} && ${This.DW} && !${This.OffHand.Equal[None]}
{
return TRUE
This:CustOutput["Need Offhand Buff - ${This.OffhHand}"]
}
if ${This.canBuff[${This.Shield}]}
{
return TRUE
}
return FALSE
}
method BuffPulse()
{
Toon:Standup
if ${Movement.Speed}
{
Toon:Stop
return
}
if ${Toon.canUseScroll}
{
Toon:UseScroll
This:CustOutput["Using a scroll"]
return
}
if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast[${This.MainHand} Weapon]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
{
Toon:CastSpell[${This.MainHand} Weapon]
This:CustOutput["Casting ${This.MainHand} Weapon"]
This.buffWaitTimer:Set[${This.InSeconds[20]}]
return
}
if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast[${This.OffHand} Weapon]} && ${This.DW} && !${This.OffHand.Equal[None]}
{
Toon:CastSpell[${This.OffHand} Weapon]
This:CustOutput["Casting ${This.OffHand} Weapon"]
return
}
if ${This.canBuff[${This.Shield}]}
{
Toon:CastSpell[${This.Shield}]
return
}
}
member NeedPullBuff()
{
if ${This.ShieldOnPull} && ${This.canBuff[${This.Shield}]}
{
return TRUE
}
if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem}
{
return TRUE
}
if ${This.canCastTotem[Air]} && ${This.HasAirTotem}
{
return TRUE
}
if ${This.canCastTotem[Fire]} && ${This.HasFireTotem}
{
return TRUE
}
if ${This.canCastTotem[Water]} && ${This.HasWaterTotem}
{
return TRUE
}
if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem}
{
return TRUE
}
if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem}
{
return TRUE
}
if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem}
{
return TRUE
}
if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem}
{
return TRUE
}
return FALSE
}
method PullBuffPulse()
{
Toon:Standup
if ${Movement.Speed}
{
Toon:Stop
}
if ${This.ShieldOnPull} && ${This.canBuff[${This.Shield}]}
{
Toon:CastSpell[${Shield}]
This:CustOutput["Casting ${This.Shield}"]
return
}
if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem}
{
Toon:CastSpell[${This.EarthTotem}]
This:CustOutput["Casting ${This.EarthTotem}"]
This:SetTotemXY[Earth]
return
}
if ${This.canCastTotem[Air]} && ${This.HasAirTotem}
{
Toon:CastSpell[${This.AirTotem}]
This:CustOutput["Casting ${This.AirTotem}"]
This:SetTotemXY[Air]
return
}
if ${This.canCastTotem[Fire]} && ${This.HasFireTotem}
{
Toon:CastSpell[${This.FireTotem}]
This:CustOutput["Casting ${This.FireTotem}"]
This:SetTotemXY[Fire]
return
}
if ${This.canCastTotem[Water]} && ${This.HasWaterTotem}
{
Toon:CastSpell[${This.WaterTotem}]
This:CustOutput["Casting ${This.WaterTotem}"]
This:SetTotemXY[Water]
return
}
if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem}
{
Toon:CastRandom[AirTotems]
This:CustOutput["Casting a random Air Totem"]
This.AirTotemTimer:Set[${This.InSeconds[80]}]
This:SetTotemXY[Air]
return
}
if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem}
{
Toon:CastRandom[EarthTotems]
This:CustOutput["Casting a random Earth Totem"]
This.EarthTotemTimer:Set[${This.InSeconds[80]}]
This:SetTotemXY[Earth]
return
}
if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem}
{
Toon:CastRandom[WaterTotems]
This:CustOutput["Casting a random Water Totem"]
This.WaterTotemTimer:Set[${This.InSeconds[80]}]
This:SetTotemXY[Water]
return
}
if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem}
{
Toon:CastRandom[FireTotems]
This:CustOutput["Casting a random Fire Totem"]
This.FireTotemTimer:Set[${This.InSeconds[80]}]
This:SetTotemXY[Fire]
return
}
return
}
member NeedCombatBuff()
{
Toon:Standup
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
{
return TRUE
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
{
return TRUE
}
if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]}
{
return TRUE
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
{
return TRUE
}
if ${This.canBuff[${This.Shield}]} && ${Target.PctHPs} > 30
{
return TRUE
}
if ${This.canCastTotem[Fire]} && ${Me.PctMana} > ${This.ConserveMana}
{
return TRUE
}
if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85
{
return TRUE
}
if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
{
return TRUE
}
if ${Toon.canCast[Mana Tide Totem]} && ${Me.PctMana} < 30
{
return TRUE
}
if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
return TRUE
}
if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
return TRUE
}
return FALSE
}
method CombatBuffPulse()
{
Toon:Standup
if ${Toon.canCast[War Stomp]}
{
Toon:CastSpell[War Stomp]
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave"]
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave"]
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
{
Toon:CastSpell[Chain Heal]
This:CustOutput["Casting Chain Heal"]
}
}
elseif ${Toon.canCast["Nature's Swiftness"]}
{
Toon:CastSpell["Nature's Swiftness"]
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave"]
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave"]
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
{
Toon:CastSpell[Chain Heal]
This:CustOutput["Casting Chain Heal"]
}
}
else
{
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave"]
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave"]
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
{
Toon:CastSpell[Chain Heal]
This:CustOutput["Casting Chain Heal"]
}
}
if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]}
{
Toon:CastSpell[Gift of the Naaru]
This:CustOutput["Casting Gift of the Naaru"]
}
if ${This.canBuff[${This.Shield}, ${Me.GUID}]} && ${Target.PctHPs} > 30 && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastSpell[${Shield}]
This:CustOutput["Casting ${Shield}"]
}
if ${This.canCastTotem[Fire]} && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastSpell[${This.FireTotem}]
This:CustOutput["Casting ${This.FireTotem}"]
This:SetTotemXY[Fire]
}
if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85
{
Toon:CastSpell[Shamanistic Rage]
This:CustOutput["Casting Shamanistic Rage!!!"]
}
if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
{
Toon:CastSpell[Elemental Mastery]
This:CustOutput["Casting Elemental Mastery!!!"]
}
if ${Toon.canCast[Mana Tide Totem]} && ${Me.PctMana} < 30
{
Toon:CastSpell[Mana Tide Totem]
This:CustOutput["Casting Mana Tide Totem!!!"]
}
if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
Toon:CastSpell[Heroism]
This:CustOutput["Casting Heroism!!!"]
}
if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
Toon:CastSpell[Bloodlust]
This:CustOutput["Casting Bloodlust!!!"]
}
}
method PullPulse()
{
Toon:Standup
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
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["I need a target"]
Toon:NeedTarget[1]
return
}
if !${Toon.TargetIsBestTarget}
{
This:CustOutput["Target is no longer best target, aquire new target."]
Toon:BestTarget
return
}
if ${This.UsePull}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${Target.Distance} > ${This.MaxCastRange}
{
This:CustOutput["Target too far away. Moving closer."]
WoWPress -hold moveforward
}
if ${Target.Distance} <= ${Math.Calc[${This.MaxCastRange}-5]}
{
Toon:Stop
}
if ${Toon.canCast[${This.PullSpell}]} && ${Target.Distance} <= ${Math.Calc[${This.MaxCastRange}-5]}
{
Toon:Stop
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[${This.PullSpell}]
This:CustOutput["Pulling With: ${This.PullSpell}"]
return
}
}
if !${This.UsePull}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if !${Toon.withinMelee[TRUE]}
{
Toon:ToMelee
This:CustOutput["Melee Pulling ${Target.Name}"]
return
}
}
if !${Me.Attacking}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
return
}
if ${Me.InCombat} && !${Me.Casting}
{
This:CustOutput["Shit, can't pull now. Going into AttackPulse"]
This:AttackPulse
return
}
return
}
method AttackPulse()
{
Toon:Standup
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${This.Flee}
{
This:SetDanger
if ${Fleeing}
{
This:CustOutput[${ShowOutput}, "Attack - Fleeing"]
Toon:Flee
return
}
variable guidlist Aggros
Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-40]
if ${Dangerlvl} >= 3 && !${Fleeing} && ${Math.Distance[${Me.X},${Me.Y},${SafeX},${SafeY}]} > 20 && (${SafeX} != 0 && ${SafeY} != 0 && ${SafeZ} != 0)
{
Fleeing:Set[TRUE]
This:CustOutput[${ShowOutput}, "Attack - So screwed - trying to run away"]
GlobalBlacklist:Insert[${Target.GUID},3600000]
return
}
}
This:debuffAll
if !${Toon.ValidTarget[${Target.GUID}]}
{
Toon:Stop
This:CustOutput["I need a target"]
Toon:NeedTarget[1]
return
}
if !${Me.Attacking}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
}
if ${Target.Distance} < ${Toon.MinMelee}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Navigator:MoveBackward[500]
}
if ${Target.Distance} > ${This.MaxShockRange}
{
WoWPress -hold moveforward
}
if ${Target.Distance} < ${This.MaxShockRange} && ${This.UsePull}
{
Toon:Stop
}
if ${Target.PctHPs} < 40 && !${Target.Target(exists)}
{
if ${Toon.canCast[Frost Shock]} && ${This.FrostShockRunners}
{
Toon:CastSpell[Frost Shock]
This:CustOutput["Casting Frost Shock on a runner"]
return
}
if ${Toon.canCast[Earthbind Totem]} && ${This.EarthbindRunners} && !${This.OwnedTotemsCheck[Earthbind Totem]} && ${This.HasEarthTotem}
{
Toon:CastSpell[Earthbind Totem]
This:CustOutput["Casting Earthbind Totem to catch a runner"]
return
}
}
if ${Me.PctHPs} < ${This.HPot} && ${This.UseHPot} && ${Consumable.HasHPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
{
Consumable:useHPot
This:CustOutput["Quaffing a health pot"]
This.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Me.PctMana} < ${This.MPot} && ${This.UseMPot} && ${Consumable.HasMPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
{
Consumable:useMPot
This:CustOutput["Quaffing a mana pot"]
This.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Toon.DetectAdds[${Target.GUID},1,10]} && ${Toon.canCast[Chain Lightning]} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
{
Toon:CastSpell[Chain Lightning]
This:CustOutput["Casting Chain Lightning due to an add!"]
return
}
if ${This.RandomShock} && ${Me.PctMana} > 15 && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastRandom[Shocks,"Target"]
This:CustOutput["Casting a random shock on ${Target.Name}"]
}
if ${This.canBuff[Flame Shock, ${Target.GUID}]} && ${This.UseFlameShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastSpell[Flame Shock]
This:CustOutput["Casting Flame Shock"]
return
}
if ${Toon.canCast[Earth Shock]} && ${This.UseEarthShock} && !${This.RandomShock} && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastSpell[Earth Shock]
This:CustOutput["Casting Earth Shock"]
return
}
if ${Toon.canCast[Stormstrike]} && !${Target.Buff[Stormstrike](exists)}
{
Toon:CastSpell[Stormstrike]
This:CustOutput["Casting Stormstrike"]
return
}
if ${Toon.canCast[Earth Shock]} && ${Target.Buff[Stormstrike](exists)}
{
Toon:CastSpell[Earth Shock]
This:CustOutput["Casting Earth Shock on Stormstrike'd ${Target}!"]
return
}
if ${Toon.canCast[Frost Shock]} && ${This.UseFrostShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
{
Toon:CastSpell[Frost Shock]
This:CustOutput["Casting Frost Shock"]
return
}
if ${Toon.canCast[Earth Shock,1]} && ${Target.Casting(exists)}
{
This:StopCast
This:CustOutput["Silencing ${Target} - Attack"]
Toon:CastSpell[Earth Shock,1]
}
if ${Toon.canCast[Lightning Bolt]} && ${This.UseLBolt} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
{
Toon:CastSpell[Lightning Bolt]
This:CustOutput["Casting Lightning Bolt"]
return
}
}
member NeedDead()
{
if ${This.CanUseAnkh}
{
return TRUE
}
return FALSE
}
method DeadPulse()
{
if ${This.CanUseAnkh}
{
WoWScript UseSoulstone()
}
return
}
member NeedCombatIdle()
{
variable guidlist TotemAggro
TotemAggro:Search[-units,-totems,-notowner,-nearest,-range 0-20]
if ${TotemAggro.Count} > 0
{
return TRUE
}
return FALSE
}
method CombatIdle()
{
variable guidlist TotemAggro
TotemAggro:Search[-units,-totems,-notowner,-nearest,-range 0-20]
if ${TotemAggro.Count} > 0
{
Target ${TotemAggro.Object[1].GUID}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:AutoAttack
return
}
else
{
This:AttackPulse
return
}
return
}
member canCastTotem(string totemType)
{
if ${Toon.canCast[${This.${totemType}Totem}]} && !${This.OwnedTotemsCheck[${This.${totemType}Totem}]} && !${This.${totemType}Totem.Equal["Random"]} && !${This.${totemType}Totem.Equal["None"]}
{
return TRUE
}
return FALSE
}
member CanUseAnkh()
{
if ${Spell[Reincarnation](exists)} && !${Spell[Reincarnation].Cooldown}
{
if ${Navigator.PointIsSafe[${Me.X},${Me.Y},${Me.Z}]}
{
AnkhList:Search[-items,-inventory, "Ankh"]
if ${AnkhList.Count} >= 1
{
This:CustOutput["We can use Reincarnation here. Popping back up to kick some ass!"]
return TRUE
}
else
{
This:CustOutput["No ankhs! Can't self res ;_;"]
return FALSE
}
}
This:CustOutput["Not a safe spot to use Reincarnation. Corpse running instead"]
return FALSE
}
return FALSE
}
member OwnedTotemsCheck(string totem)
{
if ${Unit[-units, -owner, -range 0-20, ${totem}](exists)}
{
return TRUE
TotemList:Clear
}
return FALSE
}
member ShouldCallTotems()
{
if ${This.OwnedTotemsCheck[totem]} && !${Me.Target(exists)} && ${Toon.canCast[Totemic Call]}
{
return TRUE
}
return FALSE
}
method SetDanger()
{
variable guidlist Aggros
Aggros:Search[-units,-nearest,-aggro,-alive,-targetingme,-range 0-40]
This.DangerLevel:Set[${DangerLevel} * 0.5]
This.DangerLevel:Set[${DangerLevel} + ${Aggros.Count}*6.5]
This.DangerLevel:Set[${DangerLevel} + ((100 - ${Me.PctMana})*0.10)]
if ${Target.Level} > ${Me.Level}
{
This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*2)]
}
elseif ${Me.Level} > ${Target.Level}
{
This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*1)]
}
if ${Target.Classification.Equal[Elite]} || ${Target.Classification.Equal[RareElite]}
{
This.DangerLevel:Set[${DangerLevel} + 20]
}
if ${Target.PctHPs} < 25
{
This.DangerLevel:Set[${DangerLevel} - 10]
}
if ${DangerLevel} < 0
{
This.DangerLevel:Set[0]
}
UIElement[DangerLevel@Titlebar@ClassGUI]:SetValue[${DangerLevel}]
if ${DangerLevel} >= ${DangerVeryHigh}
{
This:CustOutput[${ShowOutput}, "Danger - Very High ${DangerLevel}"]
This.Dangerlvl:Set[3]
return
}
elseif ${DangerLevel} > ${DangerHigh}
{
This:CustOutput[${ShowOutput}, "Danger - High ${DangerLevel}"]
This.Dangerlvl:Set[2]
return
}
elseif ${DangerLevel} > ${DangerMedium}
{
;This:CustOutput[${ShowOutput}, "Danger - Medium ${DangerLevel}"]
This.Dangerlvl:Set[1]
return
}
else
{
;This:CustOutput[${ShowOutput}, "Danger - Low ${DangerLevel}"]
This.Dangerlvl:Set[0]
return
}
}
member ShouldConserveMana()
{
if ${Me.PctMana} > ${This.ConserveMana}
{
return TRUE
}
return FALSE
}
method SetRandoms(string SpellName, string RandomSet)
{
if ${Spell[${SpellName}](exists)}
{
Toon:AddRandom[${RandomSet},${SpellName}]
}
else
{
This:CustOutput["Couldn't add ${SpellName} into ${RandomSet} because we don't have the spell!"]
}
}
method InitRandoms()
{
This:SetRandoms["Earth Shock","Shocks"]
This:SetRandoms["Flame Shock","Shocks"]
This:SetRandoms["Frost Shock","Shocks"]
This:SetRandoms["Lightning Bolt","Attacks"]
This:SetRandoms["Chain Lightning","Attacks"]
This:SetRandoms["Lightning Shield","Shields"]
This:SetRandoms["Water Shield","Shields"]
This:SetRandoms["Earth Shield","Shields"]
This:SetRandoms["Earthbind Totem","EarthTotems"]
This:SetRandoms["Stoneskin Totem","EarthTotems"]
This:SetRandoms["Stoneclaw Totem","EarthTotems"]
This:SetRandoms["Strength of Earth Totem","EarthTotems"]
This:SetRandoms["Tremor Totem","EarthTotems"]
This:SetRandoms["Searing Totem","FireTotems"]
This:SetRandoms["Fire Nova Totem","FireTotems"]
This:SetRandoms["Magma Totem","FireTotems"]
This:SetRandoms["Totem of Wrath","FireTotems"]
This:SetRandoms["Windwall Totem","AirTotems"]
This:SetRandoms["Grounding Totem","AirTotems"]
This:SetRandoms["Grace of Air Totem","AirTotems"]
This:SetRandoms["Wrath of Air Totem","AirTotems"]
This:SetRandoms["Healing Stream Totem","WaterTotems"]
This:SetRandoms["Mana Spring Totem","WaterTotems"]
}
method SetTotems()
{
if ${Item[-items,-inventory,"Earth Totem"](exists)}
{
This.HasEarthTotem:Set[TRUE]
This:CustOutput["We have an Earth Totem in our bags, we can use them now!"]
}
else
{
This.HasEarthTotem:Set[FALSE]
This:CustOutput["No Earth Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Fire Totem"](exists)}
{
This.HasFireTotem:Set[TRUE]
This:CustOutput["We have an Fire Totem in our bags, we can use them now!"]
}
else
{
This.HasFireTotem:Set[FALSE]
This:CustOutput["No Fire Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Water Totem"](exists)}
{
This.HasWaterTotem:Set[TRUE]
This:CustOutput["We have an Water Totem in our bags, we can use them now!"]
}
else
{
This.HasWaterTotem:Set[FALSE]
This:CustOutput["No Water Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Wind Totem"](exists)}
{
This.HasWindTotem:Set[TRUE]
This:CustOutput["We have an Wind Totem in our bags, we can use them now!"]
}
else
{
This.HasWindTotem:Set[FALSE]
This:CustOutput["No Wind Totem found! Not using them."]
}
return
}
method SetFleeHook()
{
if ${This.Flee}
{
This.HookFlee:Set[TRUE]
}
else
{
This.HookFlee:Set[FALSE]
}
return
}
method FleePulse()
{
if ${Flee.Avoiding} && !${Mount.IsMounted}
{
if ${Me.InCombat} && ${Toon.canCast[Earth Elemental Totem]}
{
Toon:CastSpell[Earth Elemental Totem]
return
}
else
{
Toon:CastSpell[Stoneclaw Totem]
return
}
if ${Me.InCombat} && ${Toon.canCast[Ghost Wolf]}
{
Toon:CastSpell[Ghost Wolf]
return
}
}
if ${Me.Attacking}
{
WoWScript AttackTarget()
return
}
}
member GetSpellRange(int base, string spellTree)
{
if ${spellTree.Equal[elemental]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Storm Reach]}))-1].Round}
}
return ${base}
}
method SetDistances()
{
if ${This.GetSpellRange[30, "elemental"]}
{
This.MaxCastRange:Set[${This.GetSpellRange[30, "elemental"]}]
This:CustOutput["Setting New MaxRange to ${This.MaxCastRange}"]
This.MaxShockRange:Set[${This.GetSpellRange[20, "elemental"]}]
This:CustOutput["Setting New MaxShockRange to ${This.MaxShockRange}"]
}
}
method CustOutput(bool xOutput, string myMessage)
{
if ${xOutput}
{
UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"]
}
return
}
method debuffAll()
{
if ${Me.PctMana} < 15 || ${Me.Casting}
{
return
}
BuffNum:Inc
if ${BuffNum} > 15
{
BuffNum:Set[1]
}
if !${Target.Buff[${BuffNum}].Harmful} && ${Target.Buff[${BuffNum}].DispelType.Equal[Magic]}
{
debuffStatus:Set[TRUE]
if ${Toon.canCast[Purge]}
{
This:CustOutput["Purging a buff on ${Target}"]
Toon:CastSpell[Purge]
debuffStatus:Set[FALSE]
return
}
}
if ${Me.Buff[${BuffNum}].Harmful}
{
debuffStatus:Set[TRUE]
if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
{
if ${Toon.canCast[Cure Disease]}
{
This:CustOutput["Curing a disease"]
Toon:CastSpell[Cure Disease]
debuffStatus:Set[FALSE]
return
}
}
if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]}
{
if ${Toon.canCast[Cure Poison]}
{
This:CustOutput["Curing a poison"]
Toon:CastSpell[Cure Poison]
debuffStatus:Set[FALSE]
return
}
}
return
}
}
member canBuff(string buffName, string theGUID=NULL, string spellName=NULL)
{
if ${spellName.Equal[NULL]}
{
spellName:Set[${buffName}]
}
if ${theGUID.Equal[NULL]}
{
theGUID:Set[${Me.GUID}]
}
if !${Object[${theGUID}].Buff[${buffName}](exists)} && ${Toon.canCast[${spellName}]}
{
return TRUE
}
return FALSE
}
member detectMobAdd()
{
if ${Config.GetCheckBox[chkRangePullOnDetectAdds]}
{
if ${Toon.DetectAdds[${Target.GUID}, 1, ${Config.GetSlider[sldRangePullOnDetectAddsRadius]}]}
{
return TRUE
}
}
return FALSE
}
method CustOutput(string myMessage)
{
if ${This.Output}
{
UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"]
}
return
}
method Initialize()
{
This:LoadConfig
This:InitShamanGUI
if ${Me.Action[Gift of the Naaru].Usable}
{
UIElement -toggle GOTN@Heals@Pages@ClassGUI
UIElement -toggle lblGOTN@Heals@Pages@ClassGUI
}
This:SetDistances
This:SetFleeHook
This:SetTotems
This:InitRandoms
UIElement[ClassGUI].FindChild[Console]:Echo["================================="]
UIElement[ClassGUI].FindChild[Console]:Echo[" Apoc's Shaman Routine v1.1"]
UIElement[ClassGUI].FindChild[Console]:Echo["================================="]
}
method Shutdown()
{
This:SaveConfig
}
method SaveConfig()
{
Config:SetSetting["${RealmChar}","UsePull",${This.UsePull}]
Config:SetSetting["${RealmChar}","PullSpell",${This.PullSpell}]
Config:SetSetting["${RealmChar}","RestMP",${This.RestMP}]
Config:SetSetting["${RealmChar}","RestHP",${This.RestHP}]
Config:SetSetting["${RealmChar}","StandMP",${This.StandMP}]
Config:SetSetting["${RealmChar}","StandHP",${This.StandHP}]
Config:SetSetting["${RealmChar}","EarthTotem",${This.EarthTotem}]
Config:SetSetting["${RealmChar}","AirTotem",${This.AirTotem}]
Config:SetSetting["${RealmChar}","FireTotem",${This.FireTotem}]
Config:SetSetting["${RealmChar}","WaterTotem",${This.WaterTotem}]
Config:SetSetting["${RealmChar}","UseEarthElemental",${This.UseEarthElemental}]
Config:SetSetting["${RealmChar}","UseFireElemental",${This.UseFireElemental}]
Config:SetSetting["${RealmChar}","EarthbindRunners",${This.EarthbindRunners}]
Config:SetSetting["${RealmChar}","UseEarthShock",${This.UseEarthShock}]
Config:SetSetting["${RealmChar}","UseFlameShock",${This.UseFlameShock}]
Config:SetSetting["${RealmChar}","UseFrostShock",${This.UseFrostShock}]
Config:SetSetting["${RealmChar}","FrostShockRunners",${This.FrostShockRunners}]
Config:SetSetting["${RealmChar}","RandomShock",${This.RandomShock}]
Config:SetSetting["${RealmChar}","ConserveMana",${This.ConserveMana}]
Config:SetSetting["${RealmChar}","UseLBolt",${This.UseLBolt}]
Config:SetSetting["${RealmChar}","UseChainLight",${This.UseChainLight}]
Config:SetSetting["${RealmChar}","MainHand",${This.MainHand}]
Config:SetSetting["${RealmChar}","OffHand",${This.OffHand}]
Config:SetSetting["${RealmChar}","DW",${This.DW}]
Config:SetSetting["${RealmChar}","ShieldOnPull",${This.ShieldOnPull}]
Config:SetSetting["${RealmChar}","HealWave",${This.HealWave}]
Config:SetSetting["${RealmChar}","LHealWave",${This.LHealWave}]
Config:SetSetting["${RealmChar}","ChainHeal",${This.ChainHeal}]
Config:SetSetting["${RealmChar}","GOTN",${This.GOTN}]
Config:SetSetting["${RealmChar}","Output",${This.Output}]
Config:SetSetting["${RealmChar}","Flee",${This.Flee}]
Config:SetSetting["${RealmChar}","UseMPot",${This.UseMPot}]
Config:SetSetting["${RealmChar}","UseHPot",${This.UseHPot}]
Config:SetSetting["${RealmChar}","UseBandages",${This.UseBandages}]
Config:SetSetting["${RealmChar}","MPot",${This.MPot}]
Config:SetSetting["${RealmChar}","HPot",${This.HPot}]
Config:SetSetting["${RealmChar}","Bandage",${This.Bandage}]
Config:SetSetting["${RealmChar}","Shield",${This.Shield}]
Config:SetSetting["${RealmChar}","MeleeOnly",${This.MeleeOnly}]
}
method LoadConfig()
{
This.UsePull:Set[${Config.GetSetting["${RealmChar}","UsePull"]}]
This.PullSpell:Set[${Config.GetSetting["${RealmChar}","PullSpell"]}]
This.RestMP:Set[${Config.GetSetting["${RealmChar}","RestMP"]}]
This.RestHP:Set[${Config.GetSetting["${RealmChar}","RestHP"]}]
This.StandMP:Set[${Config.GetSetting["${RealmChar}","StandMP"]}]
This.StandHP:Set[${Config.GetSetting["${RealmChar}","StandHP"]}]
This.EarthTotem:Set[${Config.GetSetting["${RealmChar}","EarthTotem"]}]
This.AirTotem:Set[${Config.GetSetting["${RealmChar}","AirTotem"]}]
This.WaterTotem:Set[${Config.GetSetting["${RealmChar}","WaterTotem"]}]
This.FireTotem:Set[${Config.GetSetting["${RealmChar}","FireTotem"]}]
This.UseEarthElemental:Set[${Config.GetSetting["${RealmChar}","UseEarthElemental"]}]
This.UseFireElemental:Set[${Config.GetSetting["${RealmChar}","UseFireElemental"]}]
This.EarthbindRunners:Set[${Config.GetSetting["${RealmChar}","EarthbindRunners"]}]
This.UseEarthShock:Set[${Config.GetSetting["${RealmChar}","UseEarthShock"]}]
This.UseFlameShock:Set[${Config.GetSetting["${RealmChar}","UseFlameShock"]}]
This.UseFrostShock:Set[${Config.GetSetting["${RealmChar}","UseFrostShock"]}]
This.FrostShockRunners:Set[${Config.GetSetting["${RealmChar}","FrostShockRunners"]}]
This.RandomShock:Set[${Config.GetSetting["${RealmChar}","RandomShock"]}]
This.ConserveMana:Set[${Config.GetSetting["${RealmChar}","ConserveMana"]}]
This.UseLBolt:Set[${Config.GetSetting["${RealmChar}","UseLBolt"]}]
This.UseChainLight:Set[${Config.GetSetting["${RealmChar}","UseChainLight"]}]
This.MainHand:Set[${Config.GetSetting["${RealmChar}","MainHand"]}]
This.OffHand:Set[${Config.GetSetting["${RealmChar}","OffHand"]}]
This.DW:Set[${Config.GetSetting["${RealmChar}","DW"]}]
This.ShieldOnPull:Set[${Config.GetSetting["${RealmChar}","ShieldOnPull"]}]
This.HealWave:Set[${Config.GetSetting["${RealmChar}","HealWave"]}]
This.LHealWave:Set[${Config.GetSetting["${RealmChar}","LHealWave"]}]
This.ChainHeal:Set[${Config.GetSetting["${RealmChar}","ChainHeal"]}]
This.GOTN:Set[${Config.GetSetting["${RealmChar}","GOTN"]}]
This.Output:Set[${Config.GetSetting["${RealmChar}","Output"]}]
This.Flee:Set[${Config.GetSetting["${RealmChar}","Flee"]}]
This.UseMPot:Set[${Config.GetSetting["${RealmChar}","UseMPot"]}]
This.UseHPot:Set[${Config.GetSetting["${RealmChar}","UseHPot"]}]
This.UseBandages:Set[${Config.GetSetting["${RealmChar}","UseBandages"]}]
This.MPot:Set[${Config.GetSetting["${RealmChar}","MPot"]}]
This.HPot:Set[${Config.GetSetting["${RealmChar}","HPot"]}]
This.Bandage:Set[${Config.GetSetting["${RealmChar}","Bandage"]}]
This.Shield:Set[${Config.GetSetting["${RealmChar}","Shield"]}]
This.MeleeOnly:Set[${Config.GetSetting["${RealmChar}","MeleeOnly"]}]
}
method InitShamanGUI()
{
if ${This.UsePull}
{
UIElement[UsePull@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseMPot}
{
UIElement[UseMPot@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseHPot}
{
UIElement[UseHPot@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseBandages}
{
UIElement[UseBandages@Main@Pages@ClassGUI]:SetChecked
}
if ${This.MeleeOnly}
{
UIElement[MeleeOnly@Main@Pages@ClassGUI]:SetChecked
}
if ${This.UseEarthElemental}
{
UIElement[EarthElemental@Totems@Pages@ClassGUI]:SetChecked
}
if ${This.UseFireElemental}
{
UIElement[FireElemental@Totems@Pages@ClassGUI]:SetChecked
}
if ${This.EarthbindRunners}
{
UIElement[EarthbindRunners@Totems@Pages@ClassGUI]:SetChecked
}
if ${This.UseEarthShock}
{
UIElement[EarthShock@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseFlameShock}
{
UIElement[FlameShock@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseFrostShock}
{
UIElement[FrostShock@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.FrostShockRunners}
{
UIElement[FrostShockRunners@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.RandomShock}
{
UIElement[RandomShock@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseLBolt}
{
UIElement[LightBolt@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.UseChainLight}
{
UIElement[UseChainLight@Spells@Pages@ClassGUI]:SetChecked
}
if ${This.DW}
{
UIElement[DW@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.ShieldOnPull}
{
UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.Output}
{
UIElement[EnableOutput@Other@Pages@ClassGUI]:SetChecked
}
if ${This.Flee}
{
UIElement[Flee@Other@Pages@ClassGUI]:SetChecked
}
variable int i = 1
for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PullSpell.Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[EarthTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.EarthTotem.Equal["${UIElement[EarthTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[EarthTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[WaterTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.WaterTotem.Equal["${UIElement[WaterTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[WaterTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[FireTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.FireTotem.Equal["${UIElement[FireTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[FireTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[AirTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.AirTotem.Equal["${UIElement[AirTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[AirTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[MainHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.MainHand.Equal["${UIElement[MainHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[MainHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[OffHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.OffHand.Equal["${UIElement[OffHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[OffHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <= ${UIElement[Shield@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.Shield.Equal["${UIElement[Shield@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
{
UIElement[Shield@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
}
if ${This.RestMP} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value}
{
UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.RestMP}]
}
if ${This.RestHP} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value}
{
UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.RestHP}]
}
if ${This.StandMP} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value}
{
UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.StandMP}]
}
if ${This.StandHP} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value}
{
UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.StandHP}]
}
if ${This.ConserveMana} != ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}
{
UIElement[ConserveMana@Main@Pages@ClassGUI]:SetValue[${This.ConserveMana}]
}
if ${This.MPot} != ${UIElement[MPot@Main@Pages@ClassGUI].Value}
{
UIElement[MPot@Main@Pages@ClassGUI]:SetValue[${This.MPot}]
}
if ${This.HPot} != ${UIElement[HPot@Main@Pages@ClassGUI].Value}
{
UIElement[HPot@Main@Pages@ClassGUI]:SetValue[${This.HPot}]
}
if ${This.Bandage} != ${UIElement[Bandage@Main@Pages@ClassGUI].Value}
{
UIElement[Bandage@Main@Pages@ClassGUI]:SetValue[${This.Bandage}]
}
if ${This.HealWave} != ${UIElement[HealWave@Heals@Pages@ClassGUI].Value}
{
UIElement[HealWave@Heals@Pages@ClassGUI]:SetValue[${This.HealWave}]
}
if ${This.LHealWave} != ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}
{
UIElement[LHealWave@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
}
if ${This.ChainHeal} != ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}
{
UIElement[ChainHeal@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
}
if ${This.GOTN} != ${UIElement[GOTN@Heals@Pages@ClassGUI].Value}
{
UIElement[GOTN@Heals@Pages@ClassGUI]:SetValue[${This.GOTN}]
}
}
method ClassGUIChange(string Action)
{
switch ${Action}
{
case PullSpell
if ${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.PullSpell:Set[${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}]
}
break
case EarthTotem
if ${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.EarthTotem:Set[${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem}]
}
break
case FireTotem
if ${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.FireTotem:Set[${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem}]
}
break
case AirTotem
if ${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.AirTotem:Set[${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem}]
}
break
case WaterTotem
if ${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.WaterTotem:Set[${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem}]
}
break
case MainHand
if ${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.MainHand:Set[${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem}]
}
break
case OffHand
if ${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.OffHand:Set[${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem}]
}
break
case Shield
if ${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.Shield:Set[${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem}]
}
break
/* checkboxes */
case UsePull
if ${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
{
This.UsePull:Set[TRUE]
}
if !${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
{
This.UsePull:Set[FALSE]
}
break
case UseHPot
if ${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
{
This.UseHPot:Set[TRUE]
}
if !${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
{
This.UseHPot:Set[FALSE]
}
break
case UseMPot
if ${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
{
This.UseMPot:Set[TRUE]
}
if !${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
{
This.UseMPot:Set[FALSE]
}
break
case UseBandages
if ${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
{
This.UseBandages:Set[TRUE]
}
if !${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
{
This.UseBandages:Set[FALSE]
}
break
case MeleeOnly
if ${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
{
This.MeleeOnly:Set[TRUE]
}
if !${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
{
This.MeleeOnly:Set[FALSE]
}
break
case EarthElemental
if ${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
{
This.UseEarthElemental:Set[TRUE]
}
if !${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
{
This.UseEarthElemental:Set[FALSE]
}
break
case FireElemental
if ${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
{
This.UseFireElemental:Set[TRUE]
}
if !${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
{
This.UseFireElemental:Set[FALSE]
}
break
case EarthbindRunners
if ${UIElement[EarthbindRunners@Totems@Pages@ClassGUI].Checked}
{
This.EarthbindRunners:Set[TRUE]
}
if !${UIElement[EarthbindRunners@Totems@Pages@ClassGUI].Checked}
{
This.EarthbindRunners:Set[FALSE]
}
break
case FlameShock
if ${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
{
This.UseFlameShock:Set[TRUE]
}
if !${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
{
This.UseFlameShock:Set[FALSE]
}
break
case EarthShock
if ${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
{
This.UseEarthShock:Set[TRUE]
}
if !${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
{
This.UseEarthShock:Set[FALSE]
}
break
case FrostShock
if ${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
{
This.UseFrostShock:Set[TRUE]
}
if !${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
{
This.UseFrostShock:Set[FALSE]
}
break
case FrostShockRunners
if ${UIElement[FrostShockRunners@Spells@Pages@ClassGUI].Checked}
{
This.FrostShockRunners:Set[TRUE]
}
if !${UIElement[FrostShockRunners@Spells@Pages@ClassGUI].Checked}
{
This.FrostShockRunners:Set[FALSE]
}
break
case RandomShock
if ${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
{
This.RandomShock:Set[TRUE]
}
if !${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
{
This.RandomShock:Set[FALSE]
}
break
case UseLBolt
if ${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
{
This.UseLBolt:Set[TRUE]
}
if !${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
{
This.UseLBolt:Set[FALSE]
}
break
case UseChainLight
if ${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
{
This.UseChainLight:Set[TRUE]
}
if !${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
{
This.UseChainLight:Set[FALSE]
}
break
case DW
if ${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
{
This.DW:Set[TRUE]
}
if !${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
{
This.DW:Set[FALSE]
}
break
case ShieldOnPull
if ${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
{
This.ShieldOnPull:Set[TRUE]
}
if !${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
{
This.ShieldOnPull:Set[FALSE]
}
break
case EnableOutput
if ${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
{
This.Output:Set[TRUE]
}
if !${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
{
This.Output:Set[FALSE]
}
break
case Flee
if ${UIElement[Flee@Other@Pages@ClassGUI].Checked}
{
This.Flee:Set[TRUE]
}
if !${UIElement[Flee@Other@Pages@ClassGUI].Checked}
{
This.Flee:Set[FALSE]
}
break
/* sliders */
case RestMP
if ${UIElement[RestMP@Main@Pages@ClassGUI].Value(exists)}
{
This.RestMP:Set[${UIElement[RestMP@Main@Pages@ClassGUI].Value}]
}
break
case RestHP
if ${UIElement[RestHP@Main@Pages@ClassGUI].Value(exists)}
{
This.RestHP:Set[${UIElement[RestHP@Main@Pages@ClassGUI].Value}]
}
break
case StandHP
if ${UIElement[StandHP@Main@Pages@ClassGUI].Value(exists)}
{
This.StandHP:Set[${UIElement[StandHP@Main@Pages@ClassGUI].Value}]
}
break
case StandMP
if ${UIElement[StandMP@Main@Pages@ClassGUI].Value(exists)}
{
This.StandMP:Set[${UIElement[StandMP@Main@Pages@ClassGUI].Value}]
}
break
case ConserveMana
if ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value(exists)}
{
This.ConserveMana:Set[${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}]
}
break
case MPot
if ${UIElement[MPot@Main@Pages@ClassGUI].Value(exists)}
{
This.MPot:Set[${UIElement[MPot@Main@Pages@ClassGUI].Value}]
}
break
case HPot
if ${UIElement[HPot@Main@Pages@ClassGUI].Value(exists)}
{
This.HPot:Set[${UIElement[HPot@Main@Pages@ClassGUI].Value}]
}
break
case Bandage
if ${UIElement[Bandage@Main@Pages@ClassGUI].Value(exists)}
{
This.Bandage:Set[${UIElement[Bandage@Main@Pages@ClassGUI].Value}]
}
break
case HealWave
if ${UIElement[HealWave@Heals@Pages@ClassGUI].Value(exists)}
{
This.HealWave:Set[${UIElement[HealWave@Heals@Pages@ClassGUI].Value}]
}
break
case LHealWave
if ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value(exists)}
{
This.LHealWave:Set[${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}]
}
break
case ChainHeal
if ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value(exists)}
{
This.ChainHeal:Set[${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}]
}
break
case GOTN
if ${UIElement[GOTN@Heals@Pages@ClassGUI].Value(exists)}
{
This.GOTN:Set[${UIElement[GOTN@Heals@Pages@ClassGUI].Value}]
}
break
}
}
}