;____________________________________________________________________
;------------------------------------------------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
		}
	}