rendered paste body;____________________________________________________________________
;------------------------------------------------Mage Routine 2.0-------------------------------------------------
;made by sm0k3d
;
;Thanks Neutro for the working Pots
;Thanks Apoc for helping a n00b out =P
;and thanks to many other people who has helped me put this together and make all the fixes =)
;-----------------------------------------------------------------------------------------------------------------------
;____________________________________________________________________
objectdef oClass inherits oBase
{
;--- GUI Goodies ---;
variable bool LoadedSettings = FALSE
;--- Health Stuff ---;
variable int RestHP = 70
variable int RestMP = 65
variable int StandHP = 97
variable int StandMP = 97
variable int PotHP = 20
variable int PotMP = 15
variable int BandHP = 40
;Regular stuff
variable int MaxRange = 30
variable int GemMana = 40
variable int Wand = 20
variable int WandAt = 20
variable int IBHealth = 5
variable string PullWith = "Fireball"
variable string PullSecond = "Fireball"
variable bool TwoPull = FALSE
variable bool RandPull = FALSE
variable string CombatCast = "Fireball"
variable bool RandCom = FALSE
variable bool Racial = FALSE
;Buffs
variable bool ArcInt = TRUE
variable string Armor = "None"
variable bool FWard = FALSE
variable bool FrWard = FALSE
variable bool Dampen = FALSE
variable bool Amplify = FALSE
variable bool CombatEvocation = FALSE
variable bool RestEvocation = FALSE
variable bool ManaShield = FALSE
variable int ManaSheildPctHP = 15
variable int ManaSheildPctMobHP = 40
variable int ManaSheildPctMP = 40
;Arcane
variable bool CounterSpell = FALSE
variable bool Presence = FALSE
variable bool POMonPull = FALSE
variable bool Slow = FALSE
variable bool ArcanePower = FALSE
variable bool APonPull = FALSE
variable bool StunBlink = FALSE
variable bool ArcMissiles = FALSE
;Fire
variable bool DragonBreath = FALSE
variable bool BlastWave = FALSE
variable bool Combustion = FALSE
;Frost
variable bool FrostNova = FALSE
variable bool ConeOfCold = FALSE
variable bool ColdSnap = FALSE
variable bool IceBlock = FALSE
variable bool IceBarrier = FALSE
variable bool WaterElemental = FALSE
variable bool IceLance = FALSE
;Other
variable string BestGem = "None"
variable int BuffNum = 0
variable int RandVar = 0
variable string RandPullSpell = "None"
variable string RandComSpell = "None"
variable int PullTimeDelay = 1
;extras
variable guidlist FoodList
variable guidlist DrinkList
variable guidlist NovaList
variable guidlist AggroList
variable guidlist BandList
variable guidlist LinenList
variable guidlist WoolList
variable guidlist SilkList
variable guidlist MageList
variable guidlist RuneList
variable guidlist NetherList
variable string Bandage = "Linen Bandage"
variable bool MakeBand = TRUE
variable int FB = 20
;Reactive
variable bool ArcaneImmune = FALSE
variable bool FireImmune = FALSE
variable bool FrostImmune = FALSE
variable string ReactCast = "None"
variable bool ReactFWard = FALSE
variable bool ReactFrWard = FALSE
;timers
variable int LastCastedAt = 0
variable int CastingTime = 0
variable string LastSpell = "nothing yet"
variable int LagTime = 400
variable int detectTimer
variable int detectTimeOut = 10000
variable string detectGUID
variable int NextSheeping = 0
;aggro
variable guidlist AggroList
;timer
variable int RootCastTime = 0
;Additional aggro options
variable bool RangePullOnDetectAdds = TRUE ;Range pulls if hostile adds are within RADIUS yards of the attack target
variable int RangePullOnDetectAddsRadius = 20 ;The RADIUS to check for hostile adds around your attack target. if TRUE above, will range pull mob.
;--- Initialize ---;
method Initialize()
{
This:LoadConfig
This:InitMageGUI
This:SetDistances
call TriggerPlease
}
method TakePot(string mypot,int mysecond)
{
echo "Hi, I am in TakePot method and its not working"
if ${Math.Calc[${LavishScript.RunningTime}-${This.LastCastedAt}]}>${mysecond}
{
echo "the if timer is ok"
echo "I am trying to take a ${mypot}"
Consumable:use${mypot}()
This.LastCastedAt:Set[${LavishScript.RunningTime}]
}
else
{
echo "${LavishScript.RunningTime} : Can't cast ${myspell}, too soon"
}
}
member detectMobAdd()
{
if ${RangePullOnDetectAdds}
{
variable guidlist MobAdds
/* perform search */
MobAdds:Search[-nearest, -hostile, -health 100, -range 0-${RangePullOnDetectAddsRadius}, -origin,${Target.X},${Target.Y},${Target.Z}]
/* multiple hostiles? includes our target*/
if ${MobAdds.Count}>1
{
return TRUE
}
/* is our target non-hostile, but hostiles are around? */
elseif ${MobAdds.Count}>0&&${Target.ReactionLevel}!=2
{
return TRUE
}
}
return FALSE
}
member HasSheep()
{
if ${LavishScript.RunningTime} < ${This.NextSheeping}
{
return TRUE
}
variable int i = 0
while ${Targeting.TargetCollection.Get[${i:Inc}](exists)}
{
if ${Unit[${Targeting.TargetCollection.Get[i]}].Buff[Polymorph](exists)}
{
return TRUE
}
}
return FALSE
}
;--- Rest ---;
member NeedRest()
{
if (${Me.PctHPs} < ${RestHP} || ${Me.PctMana} < ${RestMP}) && !${Me.Swimming}
{
return TRUE
}
if ${Me.PctHPs} < ${StandHP} && ${Me.Sitting}
{
return TRUE
}
if ${Me.PctMana} < ${StandMP} && ${Me.Sitting}
{
return TRUE
}
if !${Consumable.HasFood} && ${Spell[Conjure Food](exists)} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${WoWScript[MerchantFrame:IsShown()]}
{
return TRUE
}
if !${Consumable.HasDrink} && ${Spell[Conjure Water](exists)} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${WoWScript[MerchantFrame:IsShown()]}
{
return TRUE
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
return TRUE
}
if ${This.NeedDecurse} && ${Spell[Remove Lesser Curse](exists)} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)}
{
return TRUE
}
if !${This.HasGem} && ${This.GemSpell.NotEqual["None"]} && ${Spell["${This.GemSpell}"](exists)} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 0 && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)}
{
return TRUE
}
if ${Consumable.HasScroll}
{
return TRUE
}
if ${Me.InCombat}
{
return FALSE
}
if ${Targeting.realAgg}
{
return FALSE
}
return FALSE
}
method RestPulse()
{
This.ReactFWard:Set[FALSE]
FoodList:Search[-items,-inventory,-food]
DrinkList:Search[-items,-inventory,-drink]
BandList:Search[-items,-inventory,Bandage]
LinenList:Search[-items,-inventory,Linen Cloth]
WoolList:Search[-items,-inventory,Wool Cloth]
SilkList:Search[-items,-inventory,Silk Cloth]
MageList:Search[-items,-inventory,Mageweave Cloth]
RuneList:Search[-items,-inventory,Runecloth]
NetherList:Search[-items,-inventory,Netherweave Cloth]
if ${Me.Buff[Resurrection Sickness](exists)}
{
Toon:Sitdown
return
}
if ${Movement.Speed}
{
Toon:Stop
}
if ${This.MakeBand} && !${Me.Buff[First Aid](exists)} && ${BandList.Count} == 0 && (${LinenList.Count} >= 2 || ${WoolList.Count} >= 2 || ${SilkList.Count} >= 2 || ${MageList.Count} >= 2 || ${RuneList.Count} >= 2 || ${NetherList.Count} >= 2) && !${Me.Casting}
{
if ${Me.Sitting}
{
Toon:Standup
}
Tradeskills:MakeBandage[${This.Bandage}, 5]
This:Output["Let's make some bandages..."]
}
if ${Me.PctHPs} >= ${StandHP} && ${Me.PctMana} >= ${StandMP} && ${Me.Sitting}
{
Toon:Standup
}
if ${Consumable.HasScroll[Strength]} && !${Me.Buff[Strength](exists)} && !${Me.Casting}
{
Consumable:UseScroll[Strength]
This:Output["Let's use the scroll of strength"]
return
}
if ${Consumable.HasScroll[Agility]} && !${Me.Buff[Agility](exists)} && !${Me.Casting}
{
Consumable:UseScroll[Agility]
This:Output["Let's use the scroll of agility"]
return
}
if ${Consumable.HasScroll[Stamina]} && !${Me.Buff[Stamina](exists)} && !${Me.Casting}
{
Consumable:UseScroll[Stamina]
This:Output["Let's use the scroll of stamina"]
return
}
if ${Consumable.HasScroll[Protection]} && !${Me.Buff[Protection](exists)} && !${Me.Casting}
{
Consumable:UseScroll[Protection]
This:Output["Let's use the scroll of protection"]
return
}
if ${Consumable.HasScroll[Spirit]} && !${Me.Buff[Protection](exists)} && !${Me.Casting}
{
Consumable:UseScroll[Spirit]
This:Output["Let's use the scroll of Spirit"]
return
}
if ${This.RestEvocation} && ${Spell[Evocation](exists)} && !${Spell[Evocation].Cooldown} && ${Me.PctMana} < ${This.RestMP} && !${Me.Casting}
{
Toon:Standup
Toon:CastSpell[Evocation]
This:Output["Time to get this show on the road, Casting Evocation"]
return
}
if ${Me.PctHPs} < ${RestHP} && ${This.Racial} && ${Spell[Cannibalize](exists)} && !${Spell[Cannibalize].Cooldown} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)}) && !${Me.Casting}
{
This:Output["Cannibalize"]
Toon:CastSpell[Cannibalize]
return
}
if ${Me.PctHPs} < ${This.BandHP} && ${Consumable.HasBandage} && !${Me.Buff[Recently Bandaged](exists)} && !${Me.Buff[First Aid](exists)} && !${Me.Casting}
{
Consumable:useBandage
This:Output["Bandaging..."]
return
}
if ${This.NeedDecurse} && !${Me.Casting}
{
This:DecursePulse
This:Output["Decuring"]
return
}
if !${Consumable.HasDrink} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && ${Spell[Conjure Water](exists)} && !${Me.Sitting} && ${Me.CurrentMana} > ${Spell[Conjure Water].Mana} && !${Me.InCombat} && !${Me.Casting}
{
Toon:CastSpell[Conjure Water]
This:Output["Making some Water"]
return
}
if !${Consumable.HasFood} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && ${Spell[Conjure Food](exists)} && !${Me.Sitting} && ${Me.CurrentMana} > ${Spell[Conjure Food].Mana} && !${Me.InCombat} && !${Me.Buff[Evocation](exists)} && !${Me.Casting}
{
Toon:CastSpell[Conjure Food]
This:Output["Making some Food"]
return
}
if ${Consumable.HasFood} && ${Me.PctHPs} < ${This.StandHP} && !${Me.Buff["Food"](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Buff[Evocation](exists)} && !${Me.Casting} && !${WoWScript[MerchantFrame:IsShown()]}
{
Consumable:useFood
This:Output["Let's get our health back up, Eating..."]
}
if ${Consumable.HasDrink} && ${Me.PctMana} < ${This.StandHP} && !${Me.Buff["Drink"](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Buff[Evocation](exists)} && !${Me.Casting} && !${WoWScript[MerchantFrame:IsShown()]}
{
Consumable:useDrink
This:Output["Let's get our mana backup, Drinking..."]
}
if !${This.HasGem} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 0 && ${Spell[${This.GemSpell}](exists)} && !${Me.Sitting} && ${Me.CurrentMana} > ${Spell[${This.GemSpell}].Mana} && !${Me.Buff[Evocation](exists)} && !${Me.Casting}
{
Toon:CastSpell[${This.GemSpell}]
This:Output["Making ${This.GemSpell}"]
return
}
}
;--- Non Combat Buffs ---;
member NeedBuff()
{
if ${This.Armor.NotEqual["None"]} && ${Spell[${This.Armor}](exists)} && !${Me.Buff[${This.Armor}](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
if ${This.ArcInt} && ${Spell[Arcane Intellect](exists)} && !${Me.Buff[Arcane Intellect](exists)} && !${Me.Buff[Arcane Brilliance](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
if ${This.Combustion} && ${Spell[Combustion](exists)} && !${Spell[Combustion].Cooldown} && !${Me.Buff[Combustion](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
if ${This.IceBarrier} && ${Spell[Ice Barrier](exists)} && && !${Spell[Ice Barrier].Cooldown} && !${Me.Buff[Ice Barrier](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
if ${This.Dampen} && ${Spell[Dampen Magic](exists)} && !${Me.Buff[Dampen Magic](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
if ${This.Amplify} && ${Spell[Amplify Magic](exists)} && !${Me.Buff[Amplify Magic](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)}
{
return TRUE
}
Return FALSE
}
method BuffPulse()
{
Toon:Standup
if ${This.Armor.NotEqual["None"]} && !${Me.Buff[${This.Armor}](exists)} && ${Spell[${This.Armor}](exists)} && ${Me.CurrentMana} > ${Spell[${This.Armor}].Mana}
{
Target ${Me.GUID}
Toon:CastSpell[${This.Armor}]
This:Output["Casting ${This.Armor}"]
return
}
if ${This.ArcInt} && ${Spell[Arcane Intellect](exists)} && !${Me.Buff[Arcane Intellect](exists)} && !${Me.Buff[Arcane Brilliance](exists)} && ${Me.CurrentMana} > ${Spell[Arcane Intellect].Mana}
{
Target ${Me.GUID}
Toon:CastSpell[Arcane Intellect]
This:Output["Casting AI"]
return
}
if ${This.Combustion} && ${Spell[Combustion](exists)} && !${Spell[Combustion].Cooldown} && !${Me.Buff[Combustion](exists)} && ${Me.CurrentMana} > ${Spell[${Combustion}].Mana}
{
Target ${Me.GUID}
Toon:CastSpell[Combustion]
This:Output["Casting Combustion"]
return
}
if ${This.Dampen} && ${Spell[Dampen Magic](exists)} && !${Me.Buff[Dampen Magic](exists)} && ${Me.CurrentMana} > ${Spell[Dampen Magic].Mana}
{
Target ${Me.GUID}
Toon:CastSpell[Dampen Magic]
This:Output["Casting Dampen Magic"]
return
}
if ${This.Amplify} && ${Spell[Amplify Magic](exists)} && !${Me.Buff[Amplify Magic](exists)} && ${Me.CurrentMana} > ${Spell[Amplify Magic].Mana}
{
Target ${Me.GUID}
Toon:CastSpell[Amplify Magic]
This:Output["Casting Amplify Magic"]
return
}
}
;--- Pull Buffs ---;
member NeedPullBuff()
{
if ${This.IceBarrier} && ${Spell[Ice Barrier](exists)} && && !${Spell[Ice Barrier].Cooldown} && !${Me.Buff[Ice Barrier](exists)}
{
return TRUE
}
if ${WaterElemental} && !${Spell[Summon Water Elemental].Cooldown} && ${Spell[Summon Water Elemental](exists)} && !${Me.Pet(exists)}
{
return TRUE
}
if ${APonPull} && ${Spell[Arcane Power](exists)} && !${Spell[Arcane Power].Cooldown} && !${Me.Buff[Arcane Power](exists)}
{
return TRUE
}
if ${POMonPull} && ${Spell[Presence of Mind](exists)} && !${Spell[Presence of Mind].Cooldown} && !${Me.Buff[Presence of Mind](exists)}
{
return TRUE
}
return FALSE
}
method PullBuffPulse()
{
if ${Movement.Speed}
{
Toon:Stop
}
Toon:Standup
if ${This.IceBarrier} && ${Spell[Ice Barrier](exists)} && && !${Spell[Ice Barrier].Cooldown} && !${Me.Buff[Ice Barrier](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Ice Barrier]
This:Output["Throwing up Ice Barrier"]
return
}
if ${WaterElemental} && !${Spell[Summon Water Elemental].Cooldown} && ${Spell[Summon Water Elemental](exists)} && !${Me.Pet(exists)}
{
This:Output["Summoning my little baby..."]
Toon:CastSpell[Summon Water Elemental]
}
if ${APonPull} && ${Spell[Arcane Power](exists)} && !${Spell[Arcane Power].Cooldown} && !${Me.Buff[Arcane Power](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Arcane Power]
This:Output["Casting AP"]
}
if ${POMonPull} && ${Spell[Presence of Mind](exists)} && !${Spell[Presence of Mind].Cooldown} && !${Me.Buff[Presence of Mind](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Presence of Mind]
This:Output["Casting PoM"]
}
}
;--- InCombat Buffs ---;
member NeedCombatBuff()
{
if ${Me.Sitting}
{
return TRUE
}
if ${This.Racial} && !${Spell[Berserking].Cooldown} && ${Spell[Berserking](exists)} && !${Me.Buff[Berserking](exists)}
{
return TRUE
}
if ${This.ArcanePower} && !${Spell[Arcane Power].Cooldown} && ${Spell[Arcane Power](exists)} && !${Me.Buff[Arcane Power](exists)}
{
return TRUE
}
if ${This.FrWard} && ${This.ReactFrWard} && ${Spell[Frost Ward](exists)} && !${Spell[Frost Ward].Cooldown} && !${Me.Buff[Frost Ward](exists)}
{
return TRUE
}
if ${This.FWard} && ${This.ReactFWard} && ${Spell[Fire Ward](exists)} && !${Spell[Fire Ward].Cooldown} && !${Me.Buff[Fire Ward](exists)}
{
return TRUE
}
if ${This.IceBarrier} && !${Spell[Ice Barrier].Cooldown} && ${Spell[Ice Barrier](exists)} && !${Me.Buff[Ice Barrier](exists)}
{
return TRUE
}
if ${This.Presence} && !${Spell[Presence of Mind].Cooldown} && ${Spell[Presence of Mind](exists)} && !${Me.Buff[Presence of Mind](exists)}
{
return TRUE
}
if (${Me.PctHPs} < ${IBHealth} && (${Spell[Ice Block](exists)} && ${IceBlock} && !${Me.Buff[Hypothermia](exists)} && ${Spell[Ice Block].Cooldown}) || (${Spell[Ice Block].Cooldown} && ${Cold Snap} && !${Spell[Cold Snap].Cooldown} && ${Spell[Cold Snap](exists)})
{
return TRUE
}
if ${Slow} && !${Target.Buff[Slow](exists)} && ${Spell[Slow](exists)}
{
return TRUE
}
return FALSE
}
method CombatBuffPulse()
{
if ${Me.Sitting}
{
Toon:Standup
}
if ${Movement.Speed}
{
Toon:Stop
}
if ${This.IceBarrier} && ${Spell[Ice Barrier](exists)} && !${Me.Buff[Ice Barrier](exists)} && !${Spell[Ice Barrier].Cooldown}
{
Target ${Me.GUID}
Toon:CastSpell[Ice Barrier]
This:Output["Lets use Ice Barrier"]
}
if ${Spell[Berserking](exists)} && !${Spell[Berserking].Cooldown} && ${This.Racial} && !${Me.Buff[Berserking](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Berserking]
This:Output["Berserking"]
}
if ${This.FWard} && ${This.ReactFWard} && ${Spell[Fire Ward](exists)} && !${Spell[Fire Ward].Cooldown} && !${Me.Buff[Fire Ward](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Fire Ward]
This:Output["Casting Fire Ward"]
return
}
if ${This.FrWard} && ${This.ReactFrWard} && ${Spell[Frost Ward](exists)} && !${Spell[Frost Ward].Cooldown} && !${Me.Buff[Frost Ward](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Frost Ward]
This:Output["Casting Frost Ward"]
return
}
if ${This.ArcanePower} && !${Spell[Arcane Power].Cooldown} && ${Spell[Arcane Power](exists)} && !${Me.Buff[Arcane Power](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Arcane Power]
This:Output["Casting AP"]
}
if ${This.Presence} && !${Spell[Presence of Mind].Cooldown} && ${Spell[Presence of Mind](exists)} && !${Me.Buff[Presence of Mind](exists)}
{
Target ${Me.GUID}
Toon:CastSpell[Presence of Mind]
This:Output["Casting PoM"]
}
Target ${Targeting.TargetCollection.Get[1]}
if ${Slow} & ${Spell[Slow](exists)}
{
if !${Target.Buff[Slow](exists)}
{
Target ${Targeting.TargetCollection.Get[1]}
Toon:CastSpell[Slow]
}
}
}
;--- Pull ---;
method PullPulse()
{
if ${This.PullTimeDelay} > ${LavishScript.RunningTime}
{
; We shouldnt do anything
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
return
}
if ${Me.Sitting}
{
Toon:Standup
This:Output["Standing up]
return
}
if ${Target.Classification.Equal[Elite]}
{
This:Output["Target is elite. Blacklisting..."]
GlobalBlacklist:Insert[${Target.GUID},3600000]
WoWScript ClearTarget()
move -stop
return
}
if !${Toon.ValidTarget[${Target.GUID}]}
{
This:Output["Need a target"]
Toon:NeedTarget[1]
return
}
if !${Toon.TargetIsBestTarget}
{
This:Output["Target is no longer best target. Getting new target"]
Toon:BestTarget
return
}
if ${Toon.TargetIsNew}
{
WoWScript SpellStopCasting()
return
}
if ${Target.Distance} > ${Class.MaxRange} && !${Me.Casting}
{
This:Output["Too far away. Moving closer"]
WoWPress -hold moveforward
return
}
if ${WaterElemental} && ${Me.Pet(exists)}
{
WoWScript PetAttack()
return
}
if ${Target.Distance} <= ${Math.Calc[${Class.MaxRange} - 5]} && !${Me.Casting}
{
Toon:Stop
if ${Toon.canCast[${This.PullWith}]} && !${Movement.Speed}
{
This:Output["Casting ${This.PullWith} - Pull"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[${This.PullWith}]
PullTimeDelay:Set[${Math.Calc[ ${LavishScript.RunningTime} + ${Spell[${This.RandPullSpell}].CastTime} + 1000 ]}]
return
}
if !${Toon.canCast[${This.PullWith}]} && !${Movement.Speed}
{
This:Output["Pulling with Fireball because we can't use ${This.PullWith}!"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Fireball]
PullTimeDelay:Set[${Math.Calc[ ${LavishScript.RunningTime} + ${Spell[${This.RandPullSpell}].CastTime} + 1000 ]}]
return
}
if ${Target.PctHPs}>99
{
ArcaneImmune:Set[FALSE]
FireImmune:Set[FALSE]
FrostImmune:Set[FALSE]
return
}
if ${This.detectMobAdd}
{
;This:Output["Woohoo you are about to pull a mob with another mob nearby, too bad I havn't learned to poly pull... that would be helpful here lol"]
}
return
}
}
;--- Meat and Potatoes ---;
method AttackPulse()
{
if ${Target.Distance} > ${Class.MaxRange} && !${Me.Casting}
{
This:Output["Ugh, too far away... lets move up a bit"]
Navigator:MoveToMob[${Target.GUID}]
return
}
if ${Target.Distance} < ${Class.MaxRange}
{
Toon:Stop
This:SetStarting
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${Me.Target.Dead}
{
WoWScript ClearTarget()
This:Output["Oops target is dead, lets get rid of him..."]
return
}
if !${Target(exists)} || ${Target.GUID.Equal[${Me.GUID}]}
{
This:Output["Ugh, lets find a target"]
return
}
if ${Target.PctHPs}>99
{
ArcaneImmune:Set[FALSE]
FireImmune:Set[FALSE]
FrostImmune:Set[FALSE]
}
if ${Me.PctHPs} <= ${This.PotHP} && ${Consumable.HasHPot}
{
WowScript SpellStopCasting()
This:TakePot[HPot,${Me.GlobalCooldown}]
This:Output["Oh shit we are low on health, lets use a Health pot"]
}
if ${Me.PctMana} < ${This.PotMP} && ${Consumable.HasMPot}
{
WowScript SpellStopCasting()
This:TakePot[MPot,${Me.GlobalCooldown}]
This:Output["Oh shit we are low on mana, lets use a Mana pot"]
}
if ${Target(unit).Casting.Name.Upper.Find[FIRE](exists)} && !${This.ReactFWard}
{
This:Output[Getting attacked by fire Spell. We need Fire Protection !]
This.ReactFWard:Set[TRUE]
}
if !${This.IceBarrier} && ${Spell[Mana Shield](exists)} && ${This.ManaShield} && !${Me.Buff[Mana Shield](exists)} && ${Me.PctHPs} < ${This.ManaSheildPctHP} && ${Target.PctHPs} < ${This.ManaSheildPctMobHP} && ${Me.PctMana} > ${This.ManaSheildPctMP}
{
Toon:CastSpell[Mana Shield]
This:Output["Shit we are getting pretty low on Health, using Mana Shield"]
return
}
if ${Me.Buff[Feared](exists)} && ${Spell[Will of the Forsaken](exists)} && !${Spell[Will of the Forsaken].Cooldown} && ${This.Racial}
{
Toon:CastSpell[Will of the Forsaken]
This:Output["God I hate fear, WoTF!"]
return
}
if ${Me.Buff[Stunned](exists)} && ${Spell[Blink](exists)} && !${Spell[Blink].Cooldown} && ${This.StunBlink}
{
Toon:CastSpell[Blink]
This:Output["Shit we're stunned, lets blink!"]
return
}
if ${Me.PctHPs} < ${IBHealth} && ${Spell[Ice Block](exists)} && ${IceBlock} && !${Me.Buff[Hypothermia](exists)}
{
if ${Spell[Ice Block].Cooldown} && ${Cold Snap} && !${Spell[Cold Snap].Cooldown} && ${Spell[Cold Snap](exists)}
{
Toon:CastSpell[Cold Snap]
This:Output["Shit Ice block is on CD, lets use Cold Snap"]
}
Toon:CastSpell[Ice Block]
This:Output["Ice blocking..."]
}
if ${This.CounterSpell} && ${Target.Casting(exists)} && ${Target.CurrentMana} > 0 && ${Toon.canCast[Counterspell]}
{
if ${Spell[CounterSpell].Cooldown} && ${Spell[Arcane Torrent](exists)} && ${Target.Distance} < 8 && !${Spell[Arcane Torrent].Cooldown}
{
Toon:CastSpell[Arcane Torrent]
This:Output["Oh noes they are casting, and counterspell is on cooldown!?! No worries, lets use arcane torrent!"]
}
else
{
Toon:CastSpell[Counterspell]
This:Output["Oh noes they are casting, counterspell now!"]
}
return
}
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
}
if ${Me.PctHPs} < 60 && ${Spell[Gift of the Naaru](exists)} && !${Spell[Gift of the Naaru].Cooldown} && ${This.Racial}
{
Toon:CastSpell[Gift of the Naaru]
This:Output["Gift of Naaru"]
return
}
if (${Me.PctMana} < ${This.GemMana}) && ${This.HasGem} && ${Me.InCombat} && ${WoWScript[GetItemCooldown("${This.BestGem}"),2]} == 0
{
if (${WoWScript[GetItemCooldown("${This.BestGem}"),2]} == 0) && ${This.HasGem}
{
This:UseGem
This:Output["Oh god we are almost out of mana, lets use a mana gem."]
return
}
if (${WoWScript[GetItemCooldown("${This.BestGem}"),2]} == 0) && !${This.HasGem}
{
This:Output["WTF, can't find ${This.BestGem} ..."]
return
}
}
if (${Target.Distance} < 20) && !${FireImmune} && !${Spell[Fire Blast].Cooldown} && ${Spell[Fire Blast](exists)} && (${Target.PctHPs} < ${This.FB})
{
Target ${Targeting.TargetCollection.Get[1]}
Toon:CastSpell[Fire Blast]
This:Output["Time to fire blast..."]
return
}
if ${Spell[Mana Tap](exists)} && ${Toon.canCast[Mana Tap]} && ${This.Racial} && ${Target.CurrentMana} > 0
{
Target ${Targeting.TargetCollection.Get[1]}
Toon:CastSpell[Mana Tap]
This:Output["Mana tap"]
return
}
if ${This.CombatEvocation} && ${This.FrostNova} && !${FrostImmune} && ${Me.PctMana} < 20 && ${Target.PctHPs} > 40 && (${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]} < 10)
{
Toon:CastSpell[Frost nova]
This:Output["Frost nova"]
This:JumpAway
if ${Movement.Speed}
{
Toon:Stop
}
if ${Target.Buff[Frost Nova](exists)}
{
Toon:CastSpell[Evocation]
This:Output["Ah, we are out of mana, lets use evocation"]
}
}
if ${Consumable.HasBandage} && ${This.FrostNova} && !${FrostImmune} && ${Me.PctHPs} < ${This.BandHP} && (${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]} < 10)
{
Toon:CastSpell[Frost nova]
This:Output["Frost nova"]
This:JumpAway
if ${Movement.Speed}
{
Toon:Stop
}
if ${Target.Buff[Frost Nova](exists)}
{
This:Bandage
This:Output["Ah, we are out of mana, lets use evocation"]
}
}
if ${ConeOfCold} && !${Spell[Cone Of Cold].Cooldown} && ${Spell[Cone of Cold](exists)} && !${FrostImmune} && ${Target.Distance} < 8 && !${This.HasSheep}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Cone of Cold]
This:Output["time for a Cone of Cold"]
}
if ${This.BlastWave} && !${Spell[Blast Wave].Cooldown} && ${Spell[Blast wave](exists)} && !${FireImmune} && ${Target.Distance} < 8 && !${This.HasSheep}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Blast wave]
This:Output["Blast wave"]
}
if ${This.DragonBreath} && !${Spell["Dragon's Breath"].Cooldown} && ${Spell["Dragon's Breath"](exists)} && !${FireImmune} && ${Target.Distance} < 8 && !${This.HasSheep}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Dragon's Breath]
This:Output["Whats that smell? Ah its Dragon's Breath"]
This:JumpAway
}
if (${Target.Buff[Frost Nova](exists)} || ${Target.Buff[Frostbite](exists)}) && ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]} < 6
{
This:Output["Oh they are Frozen within meele range, lets jump away"]
This:JumpAway
}
NovaList:Search[-units,-nearest,-neutral,-alive,-range 0-15]
if !${This.HasSheep} && ${This.FrostNova} && !${FrostImmune} && (${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]} < 10) && !${Spell[Frost Nova].Cooldown} && ${Spell[Frost Nova](exists)} && ${Me.CurrentMana} > ${Spell[Frost Nova].Mana} && ${NovaList.Count} == 0 && !${Me.Casting}
{
Toon:CastSpell["Frost Nova"]
This:Output["nows lets frost nova him..."]
This:JumpAway
}
if ${This.IceLance} && ${Spell[Ice Lance](exists)} && (${Target.Buff[Frost Nova](exists)} || ${Target.Buff[Frostbite](exists)}) && !${FrostImmune}
{
Target ${Targeting.TargetCollection.Get[1]}
Toon:CastSpell[Ice Lance]
This:Output["Oh! Our target is frozen, time to ice lance!"]
return
}
AggroList:Search[-units,-nearest,-targetingme,-attackable,-lineofsight, -zfilter 7, -range 0-30]
if ${Toon.canCast[Polymorph]} && ${AggroList.Count} >= 2 && !${This.HasSheep} && (${Unit[${Targeting.TargetCollection.Get[2]}].CreatureType.Equal[Beast]} || ${Unit[${Targeting.TargetCollection.Get[2]}].CreatureType.Equal[Humanoid]} || ${Unit[${Targeting.TargetCollection.Get[2]}].Type.Equal["Player"]} /* && !${Unit[${Targeting.TargetCollection.Get[2]}].CreatureType.Equal[Totem]}) */
{
Target ${Targeting.TargetCollection.Get[2]}
Toon:CastSpell[Polymorph]
This:Output["Ah shit, we got an add... lets poly our add"]
Target ${Targeting.TargetCollection.Get[1]}
This.NextSheeping:Set[${Math.Calc[${LavishScript.RunningTime}+(10 * ${Bot.GlobalCooldown})]}]
return
}
if ${Targeting.TargetCollection.Get[2](exists)} && ${Unit[${Targeting.TargetCollection.Get[2]}].CreatureType.Equal[Totem]}&& ${Unit[${Targeting.TargetCollection.Get[2]}].Distance <= 20} && !${This.HasSheep} && !${Spell[Fire Blast].Cooldown}
{
Target ${Targeting.TargetCollection.Get[2]}
Toon:CastSpell[Fire Blast]
This:Output["Fire Blasting Totem"]
Target ${Targeting.TargetCollection.Get[1]}
return
}
if (${Me.Talent[Improved Arcane Missiles]} == 5) && ${Me.Buff[Clearcasting](exists)} && ${This.ArcMissiles}
{
if ${Me.Casting} && !${WoWScript[UnitCastingInfo("player")].Equal[Arcane Missiles]}
{
WoWScript SpellStopCasting()
}
else
{
Toon:CastSpell[Arcane Missiles]
This:Output["0o0o Clearcasting, lets use arcane missiles"]
}
}
if (${Me.PctMana} < ${This.WandAt} || ${Target.PctHPs} < ${This.Wand}) && !${Action[Shoot].AutoRepeat} && ${Target.Distance} < 30
{
if !${Me.Equip[Ranged](exists)} && !${Action[Attack].AutoRepeat}
{
Toon:AutoAttack
return
}
if ${Me.Equip[Ranged](exists)} && !${Action[Shoot].AutoRepeat}
{
Toon:CastSpell[Shoot]
This:Output["Shooting my wand"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
return
}
}
if !${Movement.Speed}
{
Target ${Targeting.TargetCollection.Get[1]}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if (${This.CombatCast.Equal[Fireball]} || ${This.CombatCast.Equal[Scorch]} || ${This.CombatCast.Equal[Pyroblast]}) && ${FireImmune} && !${Me.Casting}
{
Toon:CastSpell[Frostbolt]
This:Output["Casting Frostbolt because the mob is immune to fire"]
return
}
if ${This.CombatCast.Equal[Frostbolt]} && ${FrostImmune} && !${Me.Casting}
{
This:Output["Casting Fireball because the mob is immune to frost"]
Toon:CastSpell[Fireball]
}
if !${Spell[${This.CombatCast}](exists)} && !${Me.Casting}
{
Toon:CastSpell[Fireball]
This:Output["Casting Fireball because ${This.CombatCast} does not exist"]
return
}
if ${Spell[${This.CombatCast}](exists)} && !${Me.Casting} && ${Toon.canCast[${This.CombatCast}]}
{
Toon:CastSpell[${This.CombatCast}]
This:Output[Casting ${This.CombatCast}]
return
}
return
}
return
}
}
;----------------------------------;
; Chasing Logic & Checks ;
;----------------------------------;
member ChasingTooFar()
{
if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Class.StartX},${Class.StartY},${Class.StartZ}]} > ${Class.ChaseDistance}
{
return TRUE
}
return FALSE
}
method StopChasing()
{
if ${Me.Target(exists)} && ${Class.ChasingTooFar}
{
This:Output["Chasing too far. Giving up on target"]
GlobalBlacklist:Insert[${Target.GUID},${This.InSeconds[${Class.ChasingTargetBL}]}]
WoWScript ClearTarget()
return
}
return
}
method SetStarting()
{
if ${Me.Target(exists)} && ${Toon.TargetIsNew}
{
Class.StartX:Set[${Me.X}]
Class.StartY:Set[${Me.Y}]
Class.StartZ:Set[${Me.X}]
return
}
return
}
member GetSpellRange(int base, string spellTree)
{
if ${spellTree.Equal[fire]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Flame Throwing]}))-1].Round}
}
if ${spellTree.Equal[frost]}
{
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Arctic Reach]}))-1].Round}
}
return ${base}
}
method SetDistances()
{
if ${Class.GetSpellRange[30, "fire"]} > ${Class.GetSpellRange[30, "frost"]}
{
Class.MaxRange:Set[${Class.GetSpellRange[30, "fire"]}]
This:Output["Setting New MaxRange to ${Class.MaxRange}"]
}
else
{
Class.MaxRange:Set[${Class.GetSpellRange[30, "frost"]}]
This:Output["Setting New MaxRange to ${Class.MaxRange"]
}
}
; some extras
method JumpAway()
{
RandVar:Set[${Math.Rand[3]}]
if ${RandVar} == 0
{
Move Right
}
if ${RandVar} == 1
{
Move Left
}
if ${RandVar} == 2
{
Move Backward
}
WoWPress Jump
Target ${Unit[${Targeting.TargetCollection.Get[1]}].GUID}
return
}
method Bandage()
{
if ${Me.PctHPs} < ${This.BandHP} && ${Consumable.HasBandage} && !${Me.Buff[Recently Bandaged](exists)} && !${Me.Buff[First Aid](exists)} && !${Me.Casting}
{
Consumable:useBandage
This:Output["Bandaging..."]
return
}
}
method DecursePulse()
{
/** Check if you don't have a buff **/
if !${Me.Buff[${BuffNum}](exists)}
{
return
}
/** if your have a debuff and it's a curse, remove it **/
if ${Me.Buff[${BuffNum}].Harmful}
{
Toon:Standup
if ${Me.Buff[${BuffNum}].DispelType.Equal[Curse]} && ${Me.Action[Remove Lesser Curse].Usable}
{
Toon:CastSpell[Remove Lesser Curse]
return
}
if (${Me.Buff[${BuffNum}].DispelType.Equal[Snare]} || ${Me.Buff[${BuffNum}].DispelType.Equal[Root]}) && (${Spell[Escape Artist](exists)}) && !${Spell[Escape Artist].Cooldown} && ${This.Racial}
{
Toon:CastSpell[Escape Artist]
return
}
if ${Me.Buff[${BuffNum}].DispelType.NotEqual[Curse]} && ${Spell[Ice Block](exists)} && ${IceBlock} && !${Me.Buff[Hypothermia](exists)}
{
if ${Spell[Ice Block].Cooldown} && ${Cold Snap} && !${Spell[Cold Snap].Cooldown} && ${Spell[Cold Snap](exists)}
{
Toon:CastSpell[Cold Snap]
}
Toon:CastSpell[Ice Block]
return
}
}
return
}
method UseGem()
{
/** Use the Best Mana Gem **/
if !${BestGem.Equal["None"]}
{
Item[${This.BestGem}]:Use
}
return
}
member HasGem()
{
if ${Item["Mana Emerald"](exists)}
{
This.BestGem:Set["Mana Emerald"]
return TRUE
}
if ${Item["Mana Ruby"](exists)}
{
This.BestGem:Set["Mana Ruby"]
return TRUE
}
if ${Item["Mana Citrine"](exists)}
{
This.BestGem:Set["Mana Citrine"]
return TRUE
}
if ${Item["Mana Jade"](exists)}
{
This.BestGem:Set["Mana Jade"]
return TRUE
}
if ${Item["Mana Agate"](exists)}
{
This.BestGem:Set["Mana Agate"]
return TRUE
}
return FALSE
}
member GemSpell()
{
if ${Spell["Conjure Mana Emerald"](exists)}
{
This.BestGem:Set["Mana Emerald"]
return "Conjure Mana Emerald"
}
if !${Spell["Conjure Mana Emerald"](exists)} && ${Spell["Conjure Mana Ruby"](exists)}
{
This.BestGem:Set["Mana Ruby"]
return "Conjure Mana Ruby"
}
if !${Spell["Conjure Mana Ruby"](exists)} && ${Spell["Conjure Mana Citrine"](exists)}
{
This.BestGem:Set["Mana Citrine"]
return "Conjure Mana Citrine"
}
if !${Spell["Conjure Mana Citrine"](exists)} && ${Spell["Conjure Mana Jade"](exists)}
{
This.BestGem:Set["Mana Jade"]
return "Conjure Mana Jade"
}
if !${Spell["Conjure Mana Jade"](exists)} && ${Spell["Conjure Mana Agate"](exists)}
{
This.BestGem:Set["Mana Agate"]
return "Conjure Mana Agate"
}
This.BestGem:Set["None"]
return "None"
}
member NeedDecurse()
{
BuffNum:Inc
if ${BuffNum} > 56
{
BuffNum:Set[1]
}
if !${Me.Buff[${BuffNum}](exists)}
{
return FALSE
}
if ${Me.Buff[${BuffNum}].Harmful}
{
if ${Me.Buff[${BuffNum}].DispelType.Equal[Curse]} && (${Spell[Remove Lesser Curse](exists)})
{
return TRUE
}
if (${Me.Buff[${BuffNum}].DispelType.Equal[Snare]} || ${Me.Buff[${BuffNum}].DispelType.Equal[Root]}) && (${Spell[Escape Artist](exists)}) && !${Spell[Escape Artist].Cooldown}
{
return TRUE
}
if ${Me.Buff[${BuffNum}].DispelType.NotEqual[Curse]} && ${Spell[Ice Block](exists)} && ${IceBlock} && !${Me.Buff[Hypothermia](exists)} && (!${Spell[Ice Block].Cooldown} || !${Spell[Cold Snap].Cooldown})
{
return TRUE
}
}
return FALSE
}
function TriggerPlease()
{
AddTrigger Immune "[Event:@eventid@:CHAT_MSG_SPELL_SELF_DAMAGE](\"Your @ReactCast@ failed. @*@ is immune.@*@"
AddTrigger HitMagic "[Event:@eventid@:CHAT_MSG_COMBAT_CREATURE_VS_SELF_HITS](\"@Mob@ @Dam@ you for @points@ @MagicType@ damage.@*@"
AddTrigger SpellMagic "[Event:@eventid@:CHAT_MSG_SPELL_CREATURE_VS_SELF_DAMAGE](\"@Mob@'s @ReactCast@ @Dam@ you for @points@ @MagicType@ damage.@*@" /*'*/
}
function Immune(string Line, string eventid, string ReactCast)
{
echo ${ReactCast}
echo Immune!
echo Immune to spell cast, initiating reactive casting
if ${ReactCast.Equal[Arcane Missiles]} || ${ReactCast.Equal[Arcane Blast]} || ${ReactCast.Equal[Arcane Explosion]}
{
ArcaneImmune:Set[TRUE]
This:Output [Immune to arcane, stopping arcane spells]
}
if ${ReactCast.Equal[Pyroblast]} || ${ReactCast.Equal[Scorch]} || ${ReactCast.Equal[Fireball]} || ${ReactCast.Equal[Blast Wave]} || ${ReactCast.Equal[Dragon'/*'*/s Breath]} || ${ReactCast.Equal[Flamestrike]} || ${ReactCast.Equal[Molten Armor]}
{
FireImmune:Set[TRUE]
This:Output [Immune to fire, stopping fire spells]
}
if ${ReactCast.Equal[Frostbolt]} || ${ReactCast.Equal[Frost Nova]} || ${ReactCast.Equal[Cone of Cold]} || ${ReactCast.Equal[Blizzard]} || ${ReactCast.Equal[IceLance]}
{
FrostImmune:Set[TRUE]
echo FrostImmune!
This:Output [Immune to frost, stopping frost spells]
}
return
}
function HitMagic(string Line, string eventid, string Mob, string Dam, string points, string MagicType)
{
if ${MagicType.Equal[Fire]} && ${Spell[Fire Ward](exists)} && !${Spell[Fire Ward].Cooldown}
{
ReactFWard:Set[TRUE]
}
if ${MagicType.Equal[Frost]} && ${Spell[Frost Ward](exists)} && !${Spell[Frost Ward].Cooldown}
{
ReactFrWard:Set[TRUE]
}
return
}
function SpellMagic(string Line, string eventid, string Mob, string ReactCast, string Dam, string points, string MagicType)
{
if ${MagicType.Equal[Fire]} && ${Spell[Fire Ward](exists)} && !${Spell[Fire Ward].Cooldown}
{
ReactFWard:Set[TRUE]
}
if ${MagicType.Equal[Frost]} && ${Spell[Frost Ward](exists)} && !${Spell[Frost Ward].Cooldown}
{
ReactFrWard:Set[TRUE]
}
return
}
;--- GUI ---;
method InitMageGUI()
{
variable int i = 1
for (i:Set[1] ; ${i} <=${UIElement[cmbPullWith@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PullWith.Equal["${UIElement[cmbPullWith@Main@Pages@ClassGUI].Item[${i}]}"]}
{
UIElement[cmbPullWith@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <=${UIElement[cmbCombatCast@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.CombatCast.Equal["${UIElement[cmbCombatCast@Main@Pages@ClassGUI].Item[${i}]}"]}
{
UIElement[cmbCombatCast@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <=${UIElement[cmbArmor@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.Armor.Equal["${UIElement[cmbArmor@Buffs@Pages@ClassGUI].Item[${i}]}"]}
{
UIElement[cmbArmor@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
}
for (i:Set[1] ; ${i} <=${UIElement[cmbPullSecondh@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PullSecond.Equal["${UIElement[cmbPullSecond@Main@Pages@ClassGUI].Item[${i}]}"]}
{
UIElement[cmbPullSecond@Main@Pages@ClassGUI]:SelectItem[${i}]
}
}
;bandages
for (i:Set[1] ; ${i} <=${UIElement[cmbBandage@Extras@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.Bandage.Equal["${UIElement[cmbBandage@Extras@Pages@ClassGUI].Item[${i}]}"]}
{
UIElement[cmbBandage@Extras@Pages@ClassGUI]:SelectItem[${i}]
}
}
;checkboxes
if ${This.MakeBand}
{
UIElement[chkMakeBand@Extras@Pages@ClassGUI]:SetChecked
}
if ${This.TwoPull}
{
UIElement[chkTwoPull@Main@Pages@ClassGUI]:SetChecked
}
if ${This.RandPull}
{
UIElement[chkRandPull@Main@Pages@ClassGUI]:SetChecked
}
if ${This.RandCom}
{
UIElement[chkRandCom@Main@Pages@ClassGUI]:SetChecked
}
if ${This.Racial}
{
UIElement[chkRacial@Extras@Pages@ClassGUI]:SetChecked
}
if ${This.ArcInt}
{
UIElement[chkArcInt@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.FWard}
{
UIElement[chkFWard@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.FrWard}
{
UIElement[chkFrWard@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.Dampen}
{
UIElement[chkDampen@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.Amplify}
{
UIElement[chkAmplify@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.CombatEvocation}
{
UIElement[chkCombatEvocation@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.RestEvocation}
{
UIElement[chkRestEvocation@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.ManaShield}
{
UIElement[chkManaShield@Buffs@Pages@ClassGUI]:SetChecked
}
if ${This.CounterSpell}
{
UIElement[chkCounterSpell@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.Presence}
{
UIElement[chkPresence@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.POMonPull}
{
UIElement[chkPOMonPull@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.Slow}
{
UIElement[chkSlow@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.ArcanePower}
{
UIElement[chkArcanePower@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.APonPull}
{
UIElement[chkAPonPull@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.StunBlink}
{
UIElement[chkStunBlink@Arcane@Pages@ClassGUI]:SetChecked
}
if ${This.DragonBreath}
{
UIElement[chkDragonBreath@Fire@Pages@ClassGUI]:SetChecked
}
if ${This.BlastWave}
{
UIElement[chkBlastWave@Fire@Pages@ClassGUI]:SetChecked
}
if ${This.Combustion}
{
UIElement[chkCombustion@Fire@Pages@ClassGUI]:SetChecked
}
if ${This.FrostNova}
{
UIElement[chkFrostNova@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.ConeOfCold}
{
UIElement[chkConeOfCold@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.ColdSnap}
{
UIElement[chkColdSnap@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.IceBlock}
{
UIElement[chkIceBlock@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.IceBarrier}
{
UIElement[chkIceBarrier@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.WaterElemental}
{
UIElement[chkWaterElemental@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.IceLance}
{
UIElement[chkIceLance@Frost@Pages@ClassGUI]:SetChecked
}
if ${This.ArcMissiles}
{
UIElement[chkArcMissiles@Arcane@Pages@ClassGUI]:SetChecked
}
;sliders
if ${This.RestMP} != ${UIElement[sldRestMP@Main@Pages@ClassGUI].Value}
{
UIElement[sldRestMP@Main@Pages@ClassGUI]:SetValue[${This.RestMP}]
}
if ${This.RestHP} != ${UIElement[sldRestHP@Main@Pages@ClassGUI].Value}
{
UIElement[sldRestHP@Main@Pages@ClassGUI]:SetValue[${This.RestHP}]
}
if ${This.Wand} != ${UIElement[sldWand@Main@Pages@ClassGUI].Value}
{
UIElement[sldWand@Main@Pages@ClassGUI]:SetValue[${This.Wand}]
}
if ${This.WandAt} != ${UIElement[sldWandAt@Main@Pages@ClassGUI].Value}
{
UIElement[sldWandAt@Main@Pages@ClassGUI]:SetValue[${This.WandAt}]
}
if ${This.GemMana} != ${UIElement[sldGemMana@Main@Pages@ClassGUI].Value}
{
UIElement[sldGemMana@Main@Pages@ClassGUI]:SetValue[${This.GemMana}]
}
if ${This.IBHealth} != ${UIElement[sldIBHealth@Frost@Pages@ClassGUI].Value}
{
UIElement[sldIBHealth@Frost@Pages@ClassGUI]:SetValue[${This.IBHealth}]
}
if ${This.ManaSheildPctHP} != ${UIElement[sldManaSheildPctHP@Buffs@Pages@ClassGUI].Value}
{
UIElement[sldManaSheildPctHP@Buffs@Pages@ClassGUI]:SetValue[${This.WandAt}]
}
if ${This.ManaSheildPctMobHP} != ${UIElement[sldManaSheildPctMobHP@Buffs@Pages@ClassGUI].Value}
{
UIElement[sldManaSheildPctMobHP@Buffs@Pages@ClassGUI]:SetValue[${This.WandAt}]
}
if ${This.ManaSheildPctMP} != ${UIElement[sldManaSheildPctMP@Buffs@Pages@ClassGUI].Value}
{
UIElement[sldManaSheildPctMP@Buffs@Pages@ClassGUI]:SetValue[${This.WandAt}]
}
;extras
if ${This.BandHP} != ${UIElement[sldBandHP@Extras@Pages@ClassGUI].Value}
{
UIElement[sldBandHP@Extras@Pages@ClassGUI]:SetValue[${This.BandHP}]
}
if ${This.PotHP} != ${UIElement[sldPotHP@Extras@Pages@ClassGUI].Value}
{
UIElement[sldPotHP@Extras@Pages@ClassGUI]:SetValue[${This.PotHP}]
}
if ${This.PotMP} != ${UIElement[sldPotMP@Extras@Pages@ClassGUI].Value}
{
UIElement[sldPotMP@Extras@Pages@ClassGUI]:SetValue[${This.PotMP}]
}
if ${This.FB} != ${UIElement[sldFB@Extras@Pages@ClassGUI].Value}
{
UIElement[sldFB@Extras@Pages@ClassGUI]:SetValue[${This.FB}]
}
}
method ClassGUIChange(string Action)
{
switch ${Action}
{
/** Get settings from the Main tab **/
case GemMana
if ${UIElement[sldGemMana@Main@Pages@ClassGUI].Value(exists)}
{
This.GemMana:Set[${UIElement[sldGemMana@Main@Pages@ClassGUI].Value}]
}
break
case RestMP
if ${UIElement[sldRestMP@Main@Pages@ClassGUI].Value(exists)}
{
This.RestMP:Set[${UIElement[sldRestMP@Main@Pages@ClassGUI].Value}]
}
break
case RestHP
if ${UIElement[sldRestHP@Main@Pages@ClassGUI].Value(exists)}
{
This.RestHP:Set[${UIElement[sldRestHP@Main@Pages@ClassGUI].Value}]
}
break
case Wand
if ${UIElement[sldWand@Main@Pages@ClassGUI].Value(exists)}
{
This.Wand:Set[${UIElement[sldWand@Main@Pages@ClassGUI].Value}]
}
break
case WandAt
if ${UIElement[sldWandAt@Main@Pages@ClassGUI].Value(exists)}
{
This.WandAt:Set[${UIElement[sldWandAt@Main@Pages@ClassGUI].Value}]
}
break
case pullwith
if ${UIElement[cmbPullWith@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.PullWith:Set[${UIElement[cmbPullWith@Main@Pages@ClassGUI].SelectedItem}]
}
break
case RandPull
if ${UIElement[chkRandPull@Main@Pages@ClassGUI].Checked}
{
This.RandPull:Set[TRUE]
}
if !${UIElement[chkRandPull@Main@Pages@ClassGUI].Checked}
{
This.RandPull:Set[FALSE]
}
break
case TwoPull
if ${UIElement[chkTwoPull@Main@Pages@ClassGUI].Checked}
{
This.TwoPull:Set[TRUE]
}
if !${UIElement[chkTwoPull@Main@Pages@ClassGUI].Checked}
{
This.TwoPull:Set[FALSE]
}
break
case CombatCast
if ${UIElement[cmbCombatCast@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.CombatCast:Set[${UIElement[cmbCombatCast@Main@Pages@ClassGUI].SelectedItem}]
}
break
case PullSecond
if ${UIElement[cmbPullSecond@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.PullSecond:Set[${UIElement[cmbPullSecond@Main@Pages@ClassGUI].SelectedItem}]
}
break
case RandCom
if ${UIElement[chkRandCom@Main@Pages@ClassGUI].Checked}
{
This.RandCom:Set[TRUE]
}
if !${UIElement[chkRandCom@Main@Pages@ClassGUI].Checked}
{
This.RandCom:Set[FALSE]
}
break
case Racial
if ${UIElement[chkRacial@Extras@Pages@ClassGUI].Checked}
{
This.Racial:Set[TRUE]
}
if !${UIElement[chkRacial@Extras@Pages@ClassGUI].Checked}
{
This.Racial:Set[FALSE]
}
break
/** Get settings from the Buff tab **/
case ArcInt
if ${UIElement[chkArcInt@Buffs@Pages@ClassGUI].Checked}
{
This.ArcInt:Set[TRUE]
}
if !${UIElement[chkArcInt@Buffs@Pages@ClassGUI].Checked}
{
This.ArcInt:Set[FALSE]
}
break
case Armor
if ${UIElement[cmbArmor@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.Armor:Set[${UIElement[cmbArmor@Buffs@Pages@ClassGUI].SelectedItem}]
}
break
case FWard
if ${UIElement[chkFWard@Buffs@Pages@ClassGUI].Checked}
{
This.FWard:Set[TRUE]
}
if !${UIElement[chkFWard@Buffs@Pages@ClassGUI].Checked}
{
This.FWard:Set[FALSE]
}
break
case FrWard
if ${UIElement[chkFrWard@Buffs@Pages@ClassGUI].Checked}
{
This.FrWard:Set[TRUE]
}
if !${UIElement[chkFrWard@Buffs@Pages@ClassGUI].Checked}
{
This.FrWard:Set[FALSE]
}
break
case Dampen
if ${UIElement[chkDampen@Buffs@Pages@ClassGUI].Checked}
{
This.Dampen:Set[TRUE]
}
if !${UIElement[chkDampen@Buffs@Pages@ClassGUI].Checked}
{
This.Dampen:Set[FALSE]
}
break
case Amplify
if ${UIElement[chkAmplify@Buffs@Pages@ClassGUI].Checked}
{
This.Amplify:Set[TRUE]
}
if !${UIElement[chkAmplify@Buffs@Pages@ClassGUI].Checked}
{
This.Amplify:Set[FALSE]
}
break
case CombatEvocation
if ${UIElement[chkCombatEvocation@Buffs@Pages@ClassGUI].Checked}
{
This.CombatEvocation:Set[TRUE]
}
if !${UIElement[chkCombatEvocation@Buffs@Pages@ClassGUI].Checked}
{
This.CombatEvocation:Set[FALSE]
}
break
case RestEvocation
if ${UIElement[chkRestEvocation@Buffs@Pages@ClassGUI].Checked}
{
This.RestEvocation:Set[TRUE]
}
if !${UIElement[chkRestEvocation@Buffs@Pages@ClassGUI].Checked}
{
This.RestEvocation:Set[FALSE]
}
break
case manashield
if ${UIElement[chkManaShield@Buffs@Pages@ClassGUI].Checked}
{
This.ManaShield:Set[TRUE]
}
if !${UIElement[chkManaShield@Buffs@Pages@ClassGUI].Checked}
{
This.ManaShield:Set[FALSE]
}
break
case sldManaSheildPctHP
if ${UIElement[sldManaSheildPctHP@Buffs@Pages@ClassGUI].Value(exists)}
{
This.ManaSheildPctHP:Set[${UIElement[sldManaSheildPctHP@Buffs@Pages@ClassGUI].Value}]
}
break
case sldManaSheildPctMobHP
if ${UIElement[sldManaSheildPctMobHP@Buffs@Pages@ClassGUI].Value(exists)}
{
This.ManaSheildPctMobHP:Set[${UIElement[sldManaSheildPctMobHP@Buffs@Pages@ClassGUI].Value}]
}
break
case sldManaSheildPctMP
if ${UIElement[sldManaSheildPctMP@Buffs@Pages@ClassGUI].Value(exists)}
{
This.ManaSheildPctMP:Set[${UIElement[sldManaSheildPctMP@Buffs@Pages@ClassGUI].Value}]
}
break
/** Get settings from the Arcane tab **/
case CounterSpell
if ${UIElement[chkCounterSpell@Arcane@Pages@ClassGUI].Checked}
{
This.CounterSpell:Set[TRUE]
}
if !${UIElement[chkCounterSpell@Arcane@Pages@ClassGUI].Checked}
{
This.CounterSpell:Set[FALSE]
}
break
case Presence
if ${UIElement[chkPresence@Arcane@Pages@ClassGUI].Checked}
{
This.Presence:Set[TRUE]
}
if !${UIElement[chkPresence@Arcane@Pages@ClassGUI].Checked}
{
This.Presence:Set[FALSE]
}
break
case POMonPull
if ${UIElement[chkPOMonPull@Arcane@Pages@ClassGUI].Checked}
{
This.POMonPull:Set[TRUE]
}
if !${UIElement[chkPOMonPull@Arcane@Pages@ClassGUI].Checked}
{
This.POMonPull:Set[FALSE]
}
break
case Slow
if ${UIElement[chkSlow@Arcane@Pages@ClassGUI].Checked}
{
This.Slow:Set[TRUE]
}
if !${UIElement[chkSlow@Arcane@Pages@ClassGUI].Checked}
{
This.Slow:Set[FALSE]
}
break
case ArcanePower
if ${UIElement[chkArcanePower@Arcane@Pages@ClassGUI].Checked}
{
This.ArcanePower:Set[TRUE]
}
if !${UIElement[chkArcanePower@Arcane@Pages@ClassGUI].Checked}
{
This.ArcanePower:Set[FALSE]
}
break
case APonPull
if ${UIElement[chkAPonPull@Arcane@Pages@ClassGUI].Checked}
{
This.APonPull:Set[TRUE]
}
if !${UIElement[chkAPonPull@Arcane@Pages@ClassGUI].Checked}
{
This.APonPull:Set[FALSE]
}
break
case ArcMissiles
if ${UIElement[chkArcMissiles@Arcane@Pages@ClassGUI].Checked}
{
This.ArcMissiles:Set[TRUE]
}
if !${UIElement[chkArcMissiles@Arcane@Pages@ClassGUI].Checked}
{
This.ArcMissiles:Set[FALSE]
}
break
case StunBlink
if ${UIElement[chkStunBlink@Arcane@Pages@ClassGUI].Checked}
{
This.StunBlink:Set[TRUE]
}
if !${UIElement[chkStunBlink@Arcane@Pages@ClassGUI].Checked}
{
This.StunBlink:Set[FALSE]
}
break
/** Get settings from the Fire tab **/
case DragonBreath
if ${UIElement[chkDragonBreath@Fire@Pages@ClassGUI].Checked}
{
This.DragonBreath:Set[TRUE]
}
if !${UIElement[chkDragonBreath@Fire@Pages@ClassGUI].Checked}
{
This.DragonBreath:Set[FALSE]
}
break
case BlastWave
if ${UIElement[chkBlastWave@Fire@Pages@ClassGUI].Checked}
{
This.BlastWave:Set[TRUE]
}
if !${UIElement[chkBlastWave@Fire@Pages@ClassGUI].Checked}
{
This.BlastWave:Set[FALSE]
}
break
case Combustion
if ${UIElement[chkCombustion@Fire@Pages@ClassGUI].Checked}
{
This.Combustion:Set[TRUE]
}
if !${UIElement[chkCombustion@Fire@Pages@ClassGUI].Checked}
{
This.Combustion:Set[FALSE]
}
break
/** Get settings from the Frost tab **/
case FrostNova
if ${UIElement[chkFrostNova@Frost@Pages@ClassGUI].Checked}
{
This.FrostNova:Set[TRUE]
}
if !${UIElement[chkFrostNova@Frost@Pages@ClassGUI].Checked}
{
This.FrostNova:Set[FALSE]
}
break
case ConeOfCold
if ${UIElement[chkConeOfCold@Frost@Pages@ClassGUI].Checked}
{
This.ConeOfCold:Set[TRUE]
}
if !${UIElement[chkConeOfCold@Frost@Pages@ClassGUI].Checked}
{
This.ConeOfCold:Set[FALSE]
}
break
case IceBarrier
if ${UIElement[chkIceBarrier@Frost@Pages@ClassGUI].Checked}
{
This.IceBarrier:Set[TRUE]
}
if !${UIElement[chkIceBarrier@Frost@Pages@ClassGUI].Checked}
{
This.IceBarrier:Set[FALSE]
}
break
case WaterElemental
if ${UIElement[chkWaterElemental@Frost@Pages@ClassGUI].Checked}
{
This.WaterElemental:Set[TRUE]
}
if !${UIElement[chkWaterElemental@Frost@Pages@ClassGUI].Checked}
{
This.WaterElemental:Set[FALSE]
}
break
case IceLance
if ${UIElement[chkIceLance@Frost@Pages@ClassGUI].Checked}
{
This.IceLance:Set[TRUE]
}
if !${UIElement[chkIceLance@Frost@Pages@ClassGUI].Checked}
{
This.IceLance:Set[FALSE]
}
break
case ColdSnap
if ${UIElement[chkColdSnap@Frost@Pages@ClassGUI].Checked}
{
This.ColdSnap:Set[TRUE]
}
if !${UIElement[chkColdSnap@Frost@Pages@ClassGUI].Checked}
{
This.ColdSnap:Set[FALSE]
}
break
case IceBlock
if ${UIElement[chkIceBlock@Frost@Pages@ClassGUI].Checked}
{
This.IceBlock:Set[TRUE]
}
if !${UIElement[chkIceBlock@Frost@Pages@ClassGUI].Checked}
{
This.IceBlock:Set[FALSE]
}
break
case IBHealth
if ${UIElement[sldIBHealth@Frost@Pages@ClassGUI].Value(exists)}
{
This.IBHealth:Set[${UIElement[sldIBHealth@Frost@Pages@ClassGUI].Value}]
}
break
;and finally the Extras tab
case MakeBand
if ${UIElement[chkMakeBand@Extras@Pages@ClassGUI].Checked}
{
This.MakeBand:Set[TRUE]
}
if !${UIElement[chkMakeBand@Extras@Pages@ClassGUI].Checked}
{
This.MakeBand:Set[FALSE]
}
break
case Bandage
if ${UIElement[cmbBandage@Extras@Pages@ClassGUI].SelectedItem.Value(exists)}
{
This.Bandage:Set[${UIElement[cmbBandage@Extras@Pages@ClassGUI].SelectedItem}]
}
break
case BandHP
if ${UIElement[sldBandHP@Extras@Pages@ClassGUI].Value(exists)}
{
This.BandHP:Set[${UIElement[sldBandHP@Extras@Pages@ClassGUI].Value}]
}
break
case PotHP
if ${UIElement[sldPotHP@Extras@Pages@ClassGUI].Value(exists)}
{
This.PotHP:Set[${UIElement[sldPotHP@Extras@Pages@ClassGUI].Value}]
}
break
case PotMP
if ${UIElement[sldPotMP@Extras@Pages@ClassGUI].Value(exists)}
{
This.PotMP:Set[${UIElement[sldPotMP@Extras@Pages@ClassGUI].Value}]
}
break
case FB
if ${UIElement[sldFB@Extras@Pages@ClassGUI].Value(exists)}
{
This.FB:Set[${UIElement[sldFB@Extras@Pages@ClassGUI].Value}]
}
break
case defaultMain
break
}
}
method LoadConfig()
{
;Regular stuff
This.GemMana:Set[${Config.GetSetting["Mage","GemMana"]}]
This.RestMP:Set[${Config.GetSetting["Mage","RestMP"]}]
This.BestGem:Set[${Config.GetSetting["Mage","BestGem"]}]
This.RestHP:Set[${Config.GetSetting["Mage","RestHP"]}]
This.Wand:Set[${Config.GetSetting["Mage","Wand"]}]
This.WandAt:Set[${Config.GetSetting["Mage","WandAt"]}]
This.PullWith:Set[${Config.GetSetting["Mage","PullWith"]}]
This.RandPull:Set[${Config.GetSetting["Mage","RandPull"]}]
This.TwoPull:Set[${Config.GetSetting["Mage","TwoPull"]}]
This.CombatCast:Set[${Config.GetSetting["Mage","CombatCast"]}]
This.PullSecond:Set[${Config.GetSetting["Mage","PullSecond"]}]
This.RandCom:Set[${Config.GetSetting["Mage","RandCom"]}]
This.Racial:Set[${Config.GetSetting["Mage","Racial"]}]
;Buffs
This.ArcInt:Set[${Config.GetSetting["Mage","ArcInt"]}]
This.Armor:Set[${Config.GetSetting["Mage","Armor"]}]
This.FWard:Set[${Config.GetSetting["Mage","FWard"]}]
This.FrWard:Set[${Config.GetSetting["Mage","FrWard"]}]
This.Dampen:Set[${Config.GetSetting["Mage","Dampen"]}]
This.Amplify:Set[${Config.GetSetting["Mage","Amplify"]}]
This.CombatEvocation:Set[${Config.GetSetting["Mage","CombatEvocation"]}]
This.RestEvocation:Set[${Config.GetSetting["Mage","RestEvocation"]}]
This.ManaShield:Set[${Config.GetSetting["Mage","ManaShield"]}]
This.ManaSheildPctHP:Set[${Config.GetSetting["Mage","ManaSheildPctHP"]}]
This.ManaSheildPctMobHP:Set[${Config.GetSetting["Mage","ManaSheildPctMobHP"]}]
This.ManaSheildPctMP:Set[${Config.GetSetting["Mage","ManaSheildPctMP"]}]
;Arcane
This.CounterSpell:Set[${Config.GetSetting["Mage","CounterSpell"]}]
This.Presence:Set[${Config.GetSetting["Mage","Presence"]}]
This.POMonPull:Set[${Config.GetSetting["Mage","POMonPull"]}]
This.Slow:Set[${Config.GetSetting["Mage","Slow"]}]
This.ArcanePower:Set[${Config.GetSetting["Mage","ArcanePower"]}]
This.APonPull:Set[${Config.GetSetting["Mage","APonPull"]}]
This.StunBlink:Set[${Config.GetSetting["Mage","StunBlink"]}]
This.ArcMissiles:Set[${Config.GetSetting["Mage","ArcMissiles"]}]
;Fire
This.DragonBreath:Set[${Config.GetSetting["Mage","DragonBreath"]}]
This.BlastWave:Set[${Config.GetSetting["Mage","BlastWave"]}]
This.Combustion:Set[${Config.GetSetting["Mage","Combustion"]}]
;Frost
This.FrostNova:Set[${Config.GetSetting["Mage","FrostNova"]}]
This.ConeOfCold:Set[${Config.GetSetting["Mage","ConeOfCold"]}]
This.IceBarrier:Set[${Config.GetSetting["Mage","IceBarrier"]}]
This.WaterElemental:Set[${Config.GetSetting["Mage","WaterElemental"]}]
This.IceLance:Set[${Config.GetSetting["Mage","IceLance"]}]
This.ColdSnap:Set[${Config.GetSetting["Mage","ColdSnap"]}]
This.IceBlock:Set[${Config.GetSetting["Mage","IceBlock"]}]
This.IBHealth:Set[${Config.GetSetting["Mage","IBHealth"]}]
;extras
This.MakeBand:Set[${Config.GetSetting["Mage","MakeBand"]}]
This.Bandage:Set[${Config.GetSetting["Mage","Bandage"]}]
This.BandHP:Set[${Config.GetSetting["Mage","BandHP"]}]
This.PotHP:Set[${Config.GetSetting["Mage","PotHP"]}]
This.PotMP:Set[${Config.GetSetting["Mage","PotMP"]}]
This.FB:Set[${Config.GetSetting["Mage","FB"]}]
}
method SaveConfig()
{
;Regular stuff
Config:SetSetting[Mage,"GemMana",${This.GemMana}]
Config:SetSetting[Mage,"RestMP",${This.RestMP}]
Config:SetSetting[Mage,"BestGem",${This.BestGem}]
Config:SetSetting[Mage,"RestHP",${This.RestHP}]
Config:SetSetting[Mage,"Wand",${This.Wand}]
Config:SetSetting[Mage,"WandAt",${This.WandAt}]
Config:SetSetting[Mage,"PullWith",${This.PullWith}]
Config:SetSetting[Mage,"RandPull",${This.RandPull}]
Config:SetSetting[Mage,"RandPull",${This.TwoPull}]
Config:SetSetting[Mage,"CombatCast",${This.CombatCast}]
Config:SetSetting[Mage,"PullSecond",${This.PullSecond}]
Config:SetSetting[Mage,"RandCom",${This.RandCom}]
Config:SetSetting[Mage,"Racial",${This.Racial}]
;Buffs
Config:SetSetting[Mage,"ArcInt",${This.ArcInt}]
Config:SetSetting[Mage,"Armor",${This.Armor}]
Config:SetSetting[Mage,"FWard",${This.FWard}]
Config:SetSetting[Mage,"FrWard",${This.FrWard}]
Config:SetSetting[Mage,"Dampen",${This.Dampen}]
Config:SetSetting[Mage,"Amplify",${This.Amplify}]
Config:SetSetting[Mage,"CombatEvocation",${This.CombatEvocation}]
Config:SetSetting[Mage,"RestEvocation",${This.RestEvocation}]
Config:SetSetting[Mage,"ManaShield",${This.ManaShield}]
Config:SetSetting[Mage,"ManaSheildPctHP",${This.ManaSheildPctHP}]
Config:SetSetting[Mage,"ManaSheildPctMobHP",${This.ManaSheildPctMobHP}]
Config:SetSetting[Mage,"ManaSheildPctMP",${This.ManaSheildPctMP}]
;Arcane
Config:SetSetting[Mage,"CounterSpell",${This.CounterSpell}]
Config:SetSetting[Mage,"Presence",${This.Presence}]
Config:SetSetting[Mage,"POMonPull",${This.POMonPull}]
Config:SetSetting[Mage,"Slow",${This.Slow}]
Config:SetSetting[Mage,"ArcanePower",${This.ArcanePower}]
Config:SetSetting[Mage,"APonPull",${This.APonPull}]
Config:SetSetting[Mage,"StunBlink",${This.StunBlink}]
Config:SetSetting[Mage,"ArcMissiles",${This.ArcMissiles}]
;Fire
Config:SetSetting[Mage,"DragonBreath",${This.DragonBreath}]
Config:SetSetting[Mage,"BlastWave",${This.BlastWave}]
Config:SetSetting[Mage,"Combustion",${This.Combustion}]
;Frost
Config:SetSetting[Mage,"FrostNova",${This.FrostNova}]
Config:SetSetting[Mage,"ConeOfCold",${This.ConeOfCold}]
Config:SetSetting[Mage,"IceBarrier",${This.IceBarrier}]
Config:SetSetting[Mage,"WaterElemental",${This.WaterElemental}]
Config:SetSetting[Mage,"IceLance",${This.IceLance}]
Config:SetSetting[Mage,"ColdSnap",${This.ColdSnap}]
Config:SetSetting[Mage,"IceBlock",${This.IceBlock}]
Config:SetSetting[Mage,"IBHealth",${This.IBHealth}]
;extras
Config:SetSetting[Mage,"MakeBand",${This.MakeBand}]
Config:SetSetting[Mage,"Bandage",${This.Bandage}]
Config:SetSetting[Mage,"BandHP",${This.BandHP}]
Config:SetSetting[Mage,"PotHP",${This.PotHP}]
Config:SetSetting[Mage,"PotMP",${This.PotMP}]
Config:SetSetting[Mage,"FB",${This.FB}]
}
/** On Shutdown **/
method Shutdown()
{
This:SaveConfig
RemoveTrigger Immune
RemoveTrigger HitMagic
RemoveTrigger SpellMagic
}
}