rendered paste body;____________________________________________________________________
;------------------------------------------------Mage Routine 2.0.1-------------------------------------------------
;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 =)
;-----------------------------------------------------------------------------------------------------------------------
;____________________________________________________________________
; Modified by Immolator
; v1.0.0
;
; Legend:
; Bugfix: B
; Feature: F
; Change: C
;
; Todo:
; - Implement proper handling of Flame Throwing
; - Icy Veins support
;
; C - Fixed the spelling/grammar of a lot of the debug output
; C - Changed casing of Member/Method names and parameter names
; B - Hopefully fixed use of potions
; C - Removed a lot of redundant code and optimized existing code
; B - Fixed drinking bug (use of StandHP instead of StandMP)
; B - Fixed miscellaneous bugs resulting from incorrect checks
; B - Fixed arcane torrent not working in some cases because of premature cooldown check (i think)
; B - Fixed improper output for Nova + Bandage
; C - Updated version number to 2.0.1 (sm0k3d forgot)
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)
{
if ${Math.Calc[${LavishScript.RunningTime}-${This.LastCastedAt}]}>${mySecond}
{
echo "The TakePot timer is OK"
echo "I am trying to take a ${myPot}"
Consumable:use${myPot}
This.LastCastedAt:Set[${LavishScript.RunningTime}]
}
else
{
echo "TakePot method executed but not working"
}
}
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 ${Me.InCombat} || ${Me.Casting} || ${Me.Buff[Evocation](exists)}
{
return
}
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["Making bandages"]
}
if ${Me.PctHPs} >= ${StandHP} && ${Me.PctMana} >= ${StandMP} && ${Me.Sitting}
{
Toon:Standup
}
if ${Toon.canUseScroll} && !${Me.Casting} && !${Me.GlobalCooldown}
{
variable string MyScroll = ${Toon.checkForScroll[ANY]}
Consumable:UseScroll[${MyScroll}]
This:Output["Using Scroll of ${MyScroll}"]
return
}
if ${This.RestEvocation} && ${Me.PctMana} < ${This.RestMP} && ${Toon:canCast[Evocation]}
{
Toon:CastSpell[Evocation]
This:Output["Casting Evocation"]
return
}
if ${Me.PctHPs} < ${RestHP} && ${This.Racial} && ${Toon.canCast[Cannibalize]} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)})
{
Toon:CastSpell[Cannibalize]
This:Output["Casting Cannibalize"]
return
}
if ${Me.PctHPs} < ${This.BandHP} && ${Consumable.HasBandage} && !${Me.Buff[First Aid](exists)} && !${Me.Casting}
{
Consumable:useBandage
This:Output["Using bandage"]
return
}
if ${This.NeedDecurse} && !${Me.Casting}
{
This:DecursePulse
This:Output["Decursing"]
return
}
if !${Consumable.HasDrink} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && ${Spell[Conjure Water](exists)} && ${Toon.canCast[Conjure Water]}
{
Toon:CastSpell[Conjure Water]
This:Output["Conjuring water"]
return
}
if !${Consumable.HasFood} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 2 && ${Spell[Conjure Food](exists)} && ${Toon.canCast[Conjure Food]}
{
Toon:CastSpell[Conjure Food]
This:Output["Conjuring food"]
return
}
if ${Consumable.HasFood} && ${Me.PctHPs} < ${This.StandHP} && !${Me.Buff["Food"](exists)} && !${Me.Swimming} && !${WoWScript[MerchantFrame:IsShown()]}
{
Consumable:useFood
This:Output["Eating"]
}
if ${Consumable.HasDrink} && ${Me.PctMana} < ${This.StandMP} && !${Me.Buff["Drink"](exists)} && !${Me.Swimming} && !${WoWScript[MerchantFrame:IsShown()]}
{
Consumable:useDrink
This:Output["Drinking"]
}
if !${This.HasGem} && ${Inventory.GetBagsInfo[RETRIEVE_FREESLOTS,"normal"]} > 0 && ${Toon:canCast[${This.GemSpell}]}
{
Toon:CastSpell[${This.GemSpell}]
This:Output["Casting ${This.GemSpell}"]
return
}
}
;--- Non Combat Buffs ---;
member NeedBuff()
{
if ${Me.Buff[Food](exists)} || ${Me.Buff[Drink](exists)}
{
return FALSE
}
if ${This.Armor.NotEqual["None"]} && ${Toon.canBuff[${Me.GUID},${This.Armor}]}
{
return TRUE
}
if ${This.ArcInt} && ${Toon.canBuff[${Me.GUID},"Arcane Intellect"]}
{
return TRUE
}
if ${This.Combustion} && ${Toon.canBuff[${Me.GUID},"Combustion"]}
{
return TRUE
}
if ${This.IceBarrier} && ${Toon.canBuff[${Me.GUID},"Ice Barrier"]}
{
return TRUE
}
if ${This.Dampen} && ${Toon.canBuff[${Me.GUID},"Dampen Magic"]}
{
return TRUE
}
if ${This.Amplify} && ${Toon.canBuff[${Me.GUID},"Amplify Magic"]}
{
return TRUE
}
Return FALSE
}
method BuffPulse()
{
if ${This.Armor.NotEqual["None"]} && ${Toon.canBuff[${Me.GUID},${This.Armor}]}
{
Toon:CastSpellGUID[${Me.GUID},${This.Armor}]
This:Output["Buffing self with ${This.Armor}"]
return
}
if ${This.ArcInt} && !${Me.Buff[Arcane Brilliance](exists)} && ${Toon.canBuff[${Me.GUID},"Arcane Intellect"]}
{
Toon:CastSpellGUID[${Me.GUID},"Arcane Intellect"]
This:Output["Buffing self with Arcane Intellect"]
return
}
if ${This.Combustion} && ${Toon.canBuff[${Me.GUID},"Combustion"]}
{
Toon:CastSpellGUID[${Me.GUID},"Combustion"]
This:Output["Buffing self with Combustion"]
return
}
if ${This.Dampen} && ${Toon.canBuff[${Me.GUID},"Dampen Magic"]}
{
Toon:CastSpellGUID[${Me.GUID},"Dampen Magic"]
This:Output["Buffing self with Dampen Magic"]
return
}
if ${This.Amplify} && ${Toon.canBuff[${Me.GUID},"Amplify Magic"]}
{
Toon:CastSpellGUID[${Me.GUID},"Amplify Magic"]
This:Output["Buffing self with Amplify Magic"]
return
}
}
;--- Pull Buffs ---;
member NeedPullBuff()
{
if ${This.IceBarrier} && ${Toon.canBuff[${Me.GUID},"Ice Barrier"]}
{
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
}
if ${This.IceBarrier} && ${Toon.canBuff[${Me.GUID},"Ice Barrier"]}
{
Toon:CastSpellGUID[${Me.GUID},"Ice Barrier"]
This:Output["Buffing self with Ice Barrier"]
return
}
if ${WaterElemental} && !${Me.Pet(exists)} && ${Toon.canCast[Summon Water Elemental]}
{
Toon:CastSpell[Summon Water Elemental]
This:Output["Summoning Water Elemental"]
}
if ${APonPull} && ${Toon.canBuff[${Me.GUID},"Arcane Power"]}
{
Toon:CastSpellGUID[${Me.GUID},"Arcane Power"]
This:Output["Casting Arcane Power"]
}
if ${POMonPull} && ${Toon.canBuff[${Me.GUID},"Presence of Mind"]}
{
Toon:CastSpellGUID[${Me.GUID},"Presence of Mind"]
This:Output["Casting Presence of Mind"]
}
}
;--- InCombat Buffs ---;
member NeedCombatBuff()
{
if ${Me.Sitting}
{
return TRUE
}
if ${This.Racial} && ${Toon.canBuff[${Me.GUID},"Berserking"]}
{
return TRUE
}
if ${This.ArcanePower} && ${Toon.canBuff[${Me.GUID},"Arcane Power"]}
{
return TRUE
}
if ${This.FrWard} && ${This.ReactFrWard} && ${Toon.canBuff[${Me.GUID},"Frost Ward"]}
{
return TRUE
}
if ${This.FWard} && ${This.ReactFWard} && ${Toon.canBuff[${Me.GUID},"Fire Ward"]}
{
return TRUE
}
if ${This.IceBarrier} && ${Toon.canBuff[${Me.GUID},"Ice Barrier"]}
{
return TRUE
}
if ${This.Presence} && ${Toon.canBuff[${Me.GUID},"Presence of Mind"]}
{
return TRUE
}
if (${Me.PctHPs} < ${IBHealth} && (${Toon.canBuff[${Me.GUID},"Hypothermia","Ice Block"]} || ${Toon.canBuff[${Me.GUID},"Hypothermia","Cold Snap"]})
{
return TRUE
}
if ${Slow} && ${Toon.canBuff[${Target.GUID},"Slow"]}
{
return TRUE
}
return FALSE
}
method CombatBuffPulse()
{
if ${Movement.Speed}
{
Toon:Stop
}
if ${This.IceBarrier} && ${Toon.canBuff[${Me.GUID},"Ice Barrier"]}
{
Toon:CastSpellGUID[${Me.GUID},"Ice Barrier"]
This:Output["Buffing self with Ice Barrier"]
}
if ${This.Racial} && ${Toon.canBuff[${Me.GUID},"Berserking"]}
{
Toon:CastSpellGUID[${Me.GUID},"Berserking"]
This:Output["Buffing self with Berserking"]
}
if ${This.FWard} && ${This.ReactFWard} && ${Toon.canBuff[${Me.GUID},"Fire Ward"]}
{
Toon:CastSpellGUID[${Me.GUID},"Fire Ward"]
This:Output["Buffing self with Fire Ward"]
return
}
if ${This.FrWard} && ${This.ReactFrWard} && ${Toon.canBuff[${Me.GUID},"Frost Ward"]}
{
Toon:CastSpellGUID[${Me.GUID},"Frost Ward"]
This:Output["Buffing self with Frost Ward"]
return
}
if ${This.ArcanePower} && ${Toon.canBuff[${Me.GUID},"Arcane Power"]}
{
Toon:CastSpellGUID[${Me.GUID},"Arcane Power"]
This:Output["Buffing self with Arcane Power"]
}
if ${This.Presence} && !${Spell[Presence of Mind].Cooldown} && ${Toon.canBuff[${Me.GUID},"Berserking"]}
{
Toon:CastSpellGUID[${Me.GUID},"Presence of Mind"]
This:Output["Buffing self with Presence of Mind"]
}
Target ${Targeting.TargetCollection.Get[1]}
if ${Slow} && ${Toon.canBuff[${Target.GUID},"Slow"]}
{
Toon:CastSpellGUID[${Me.GUID},"Slow"]
This:Output["Casting slow"]
}
}
;--- Pull ---;
method PullPulse()
{
if ${This.PullTimeDelay} > ${LavishScript.RunningTime}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
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["Target invalid, need a new one."]
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["Target is 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["Pulling with ${This.PullWith}"]
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["Too far away from target. Moving closer."]
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["Target is dead. Clearing."]
return
}
if !${Target(exists)} || ${Target.GUID.Equal[${Me.GUID}]}
{
This:Output["Target doesn't exist or target is self. Need new 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["Low on health. Using a health pot."]
}
if ${Me.PctMana} < ${This.PotMP} && ${Consumable.HasMPot}
{
WowScript SpellStopCasting()
This:TakePot[MPot,${Me.GlobalCooldown}]
This:Output["Low on mana. Using 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} && ${This.ManaShield} && ${Me.PctHPs} < ${This.ManaSheildPctHP} && ${Target.PctHPs} < ${This.ManaSheildPctMobHP} && ${Me.PctMana} > ${This.ManaSheildPctMP} && ${Toon.canCast[Mana Shield]}
{
Toon:CastSpell[Mana Shield]
This:Output["Low on health. Using mana shield."]
return
}
if ${Me.Buff[Feared](exists)} && ${This.Racial} && ${Toon.canCast[Will of the Forsaken]}
{
Toon:CastSpell[Will of the Forsaken]
This:Output["Feared, using Will of the Forsaken"]
return
}
if ${Me.Buff[Stunned](exists)} && ${This.StunBlink} && ${Toon:canCast[Blink]}
{
Toon:CastSpell[Blink]
This:Output["Stunned, casting blink"]
return
}
if ${Me.PctHPs} < ${IBHealth} && ${IceBlock} && (${Toon.canBuff[${Me.GUID},"Hypothermia","Ice Block"]} || ${Toon.canBuff[${Me.GUID},"Hypothermia","Cold Snap"]})
{
if ${Spell[Ice Block].Cooldown} && ${Cold Snap} && ${Toon.canBuff[${Me.GUID},"Hypothermia","Cold Snap"]}
{
Toon:CastSpell[Cold Snap]
This:Output["Ice Block on cooldown. Using Cold Snap."]
}
Toon:CastSpell[Ice Block]
This:Output["Casting Ice Block."]
}
if ${This.CounterSpell} && ${Target.Casting(exists)} && ${Target.CurrentMana} > 0 && (${Toon.canCast[Counterspell]} || (${Toon.canCast[Arcane Torrent]} && ${Target.Distance} < 8))
{
if !${Toon.canCast[Counterspell]} && ${Toon.canCast[Arcane Torrent]} && ${Target.Distance} < 8
{
Toon:CastSpell[Arcane Torrent]
This:Output["Mob is casting and Counterspell is on cooldown. Using Arcane Torrent."]
}
else
{
Toon:CastSpell[Counterspell]
This:Output["Mob is casting, using Counterspell."]
}
return
}
if ${Me.PctMana} < 85 && ${Toon.canCast[Arcane Torrent]} && ${Me.Buff[Mana Tap].Application} == 3
{
Toon:CastSpell[Arcane Torrent]
This:Output["Casting Arcane Torrent"]
return
}
if ${Me.PctHPs} < 60 && ${Toon.canCast[Gift of the Naaru]} && ${This.Racial}
{
Toon:CastSpell[Gift of the Naaru]
This:Output["Casting 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["Almost out of mana, using Mana Gem"]
return
}
if (${WoWScript[GetItemCooldown("${This.BestGem}"),2]} == 0) && !${This.HasGem}
{
This:Output["Couldn't find ${This.BestGem}"]
return
}
}
if (${Target.Distance} < 20) && !${FireImmune} && ${Toon.canCast[Fireblast]} && (${Target.PctHPs} < ${This.FB})
{
Toon:CastSpellGUID[${Target.GUID},Fire Blast]
This:Output["Casting Fire Blast"]
return
}
if ${Toon.canCast[Mana Tap]} && ${This.Racial} && ${Target.CurrentMana} > 0
{
Toon:CastSpell[${Target.GUID},Mana Tap]
This:Output["Casting 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.canCast[Evocation]} && ${Toon.canCast[Frost Nova]}
{
Toon:CastSpell[Frost Nova]
This:Output["Frost Nova"]
This:JumpAway
This:Output["Target frozen, jumping away."]
if ${Movement.Speed}
{
Toon:Stop
}
if ${Target.Buff[Frost Nova](exists)}
{
Toon:CastSpell[Evocation]
This:Output["Out of mana. Casting 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.canCast[Frost Nova]}
{
Toon:CastSpell[Frost Nova]
This:Output["Casting Frost Nova"]
This:JumpAway
This:Output["Target frozen, jumping away."]
if ${Movement.Speed}
{
Toon:Stop
}
if ${Target.Buff[Frost Nova](exists)}
{
This:Bandage
This:Output["Low on health. Bandaging."]
}
}
if ${ConeOfCold} && !${FrostImmune} && ${Target.Distance} < 8 && !${This.HasSheep} && ${Toon.canCast[Cone of Cold]}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Cone of Cold]
This:Output["Casting Cone of Cold"]
}
if ${This.BlastWave} && ${Toon.canCast[Blast Wave]} && !${FireImmune} && ${Target.Distance} < 8 && !${This.HasSheep}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Blast wave]
This:Output["Casting Blast Wave"]
}
if ${This.DragonBreath} && ${Toon.canCast[Dragon's Breath]} && !${FireImmune} && ${Target.Distance} < 8 && !${This.HasSheep}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[Dragon's Breath]
This:Output["Casting Dragon's Breath"]
This:JumpAway
This:Output["Jumping away while target is stunned."]
}
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:JumpAway
This:Output["Target is frozen within melee range. Jumping away."]
}
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["Casting Frost Nova"]
This:JumpAway
This:Output["Target frozen, jumping away."]
}
if ${This.IceLance} && ${Toon.canCast[Ice Lance]} && (${Target.Buff[Frost Nova](exists)} || ${Target.Buff[Frostbite](exists)}) && !${FrostImmune}
{
Toon:CastSpellGUID[${Target.GUID},"Ice Lance"]
This:Output["Target is frozen. Casting 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]}
{
Toon:CastSpellGUID[${Targeting.TargetCollection.Get[2]},Polymorph]
This:Output["We have an add. Casting Polymorph."]
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} && ${Toon.canCast[Fire Blast]}
{
Toon:CastSpellGUID[${Targeting.TargetCollection.Get[2]},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["Clearcasting proc. Casting 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 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["Using bandage."]
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
}
}