objectdef oClass inherits oBase
{
	;----------------------------------;
	;    Variables...All 5 Of Them     ;
	;----------------------------------;
	variable int MaxRange = 30
	variable int MFRange = 20
	variable guidlist AggroList
	variable int PotTimer = 0
	variable oHeal Heal
	variable oIQ IQ
	variable bool HookBGPrebuff = TRUE
	variable bool HookFlee = TRUE
	variable int PullTimer
	;----------------------------------;
	;       Rest Pulses & Checks       ;
	;----------------------------------;

	member NeedRest()
	{
		if ${Me.InCombat}
		{
			This:CustOutput["Resting in combat",1]
			return FALSE
		}
		if ${Targeting.realAgg}
		{
			This:CustOutput["I have aggro in rest",1]
			return FALSE
		}
		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			This:CustOutput["Got Rez sickness in rest",1]
			return TRUE
		}
		if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]}
		{
			This:CustOutput["Need to rest health",1]
			return TRUE
		}
		if (${Me.PctMana} < ${Class.UseIntVar[RestMP]})
		{
			This:CustOutput["Need to rest mana",1]
			return TRUE
		}
		if ${Me.PctHPs} < ${Class.UseIntVar[StandHP]} && ${Me.Buff[Food](exists)}
		{
			This:CustOutput["Not finished eating yet",1]
			return TRUE
		}
		if ${Me.PctMana} < ${Class.UseIntVar[StandMP]} && ${Me.Buff[Drink](exists)}
		{
			This:CustOutput["Not finished drinking yet",1]
			return TRUE
		}
		return FALSE
	}

	method RestPulse()
	{
		if ${Me.InCombat}
		{
			This:CustOutput["In combat in RestPulse",1]
			return
		}
		if ${Me.Casting}
		{
			This:CustOutput["Casting in RestPulse",1]
			return
		}
		if ${Targeting.realAgg}
		{
			This:CustOutput["Got aggro in RestPulse",1]
			return
		}
		Toon:Stop
		if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]} && ${Spell[Cannibalize](exists)} && !${Spell[Cannibalize].Cooldown} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)})
		{
			This:CustOutput["Using Cannibalize - rest pulse",1]
			Toon:CastSpell[Cannibalize]
			return
		}
		if ${Heal.NeedHeal}
		{
			This:CustOutput["Need a heal in RestPulse",1]
			Heal:HealPulse[TRUE]
			return
		}
		if ${Me.PctHPs} < ${Class.UseIntVar[RestHP]} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)}
		{
			This:CustOutput["Eating in RestPulse",1]
			Consumable:useFood
			if ${Class.canBuff[Shadowmeld]}
			{
				This:CustOutput["Need to shadowmeld/eat in RestPulse",1]
				Toon:CastSpell["Shadowmeld"]
			}
			return
		}
		if ${Me.PctMana} < ${Class.UseIntVar[RestMP]} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)}
		{
			if ${Me.PctMana} < ${Class.UseIntVar[SpiritTapMP]} && ${Me.Buff[Spirit Tap](exists)}
			{
				This:CustOutput["Waiting on spirit tap regen in RestPulse",1]
				return
			}
			This:CustOutput["Drinking in RestPulse",1]
			Consumable:useDrink
			if ${Class.canBuff[Shadowmeld]}
			{
				This:CustOutput["Need to shadowmeld/drink in RestPulse",1]
				Toon:CastSpell["Shadowmeld"]
			}
			return
		}
		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			This:CustOutput["Got rez sickness in RestPulse. Sitting.",1]
			Toon:Sitdown
			if ${Class.canBuff[Shadowmeld]}
			{
				This:CustOutput["Shadowmelding with res sickness. RestPulse.",1]
				Toon:CastSpell["Shadowmeld"]
			}
			return
		}
		if ${Me.PctMana} >= ${Class.UseIntVar[StandMP]} && ${Me.PctHPs} >= ${Class.UseIntVar[StandHP]} && !${Me.Buff[Resurrection Sickness](exists)}
		{
			This:CustOutput["All done resting in RestPulse.",1]
			Toon:Standup
			return
		}
		return
	}

	;----------------------------------;
	;       Buff Pulse & Checks        ;
	;----------------------------------;

	member NeedBuff()
	{
		variable string OilType = ${Class.ChooseOilType[${Class.ChooseOil}]}
		if ${Class.canBuff[Power Word: Fortitude]} && !${Me.Buff[Prayer of Fortitude](exists)} && ${Class.UseVar[PWF]}
		{
			This:CustOutput["Need Fort",1]
			return TRUE
		}
		if ${Class.canBuff[Shadow Protection]} && !${Me.Buff[Prayer of Shadow Protection](exists)} && ${Class.UseVar[ShadowProt]}
		{
			This:CustOutput["Need shadow prot",1]
			return TRUE
		}
		if ${Class.canBuff[Inner Fire]} && ${Class.UseVar[InnerFire]}
		{
			This:CustOutput["Need inner fire",1]
			return TRUE
		}
		if ${Class.canBuff[Divine Spirit]} && !${Me.Buff[Prayer of Spirit](exists)} && ${Class.UseVar[DivineSpirit]}
		{
			This:CustOutput["Need divine spirit",1]
			return TRUE
		}
		if ${Class.canBuff[Fear Ward]} && ${Class.UseVar[FearWard]}
		{
			This:CustOutput["Need fear ward",1]
			return TRUE
		}
		if ${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${OilType}](exists)} && ${Item[${OilType}](exists)}
		{
			This:CustOutput["Need a weapon enchant (oil)",1]
			return TRUE
		}
		if ${Toon.canUseScroll}
		{
			This:CustOutput["Need a scroll",1]
			return TRUE
		}
		if ${Class.canBuff[Shadowguard]}
		{
			This:CustOutput["Need shadowguard",1]
			return TRUE
		}
		return FALSE
	}

	method BuffPulse()
	{
		Target ${Me.GUID}
		variable string OilType = ${Class.ChooseOilType[${Class.ChooseOil}]}
		if ${Class.canBuff[Power Word: Fortitude]} && !${Me.Buff[Prayer of Fortitude](exists)} && ${Class.UseVar[PWF]}
		{
			This:CustOutput["Buffing fort",1]
			Toon:CastSpell[Power Word: Fortitude]
			return
		}
		if ${Class.canBuff[Inner Fire]} && ${Class.UseVar[InnerFire]}
		{
			This:CustOutput["Buffing inner fire",1]
			Toon:CastSpell[Inner Fire]
			return
		}
		if ${Class.canBuff[Shadow Protection]} && !${Me.Buff[Prayer of Shadow Protection](exists)} && ${Class.UseVar[ShadowProt]}
		{
			This:CustOutput["Buffing shadow prot",1]
			Toon:CastSpell[Shadow Protection]
			return
		}
		if ${Class.canBuff[Divine Spirit]} && !${Me.Buff[Prayer of Spirit](exists)} && ${Class.UseVar[DivineSpirit]}
		{
			This:CustOutput["Buffing divine spirit",1]
			Toon:CastSpell[Divine Spirit]
			return
		}
		if ${Class.canBuff[Fear Ward]} && ${Class.UseVar[FearWard]}
		{
			This:CustOutput["Buffing fear ward",1]
			Toon:CastSpell[Fear Ward]
			return
		}
		if  !${Me.InCombat}&&${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${OilType}](exists)} && ${Item[${OilType}](exists)}
		{
			if ${WoWScript[SpellIsTargeting()]}
			{
				Me.Equip[mainhand]:PickUp
				This:CustOutput["Applying ${OilType} to my mainhand."]
				Bot.RandomPause:Set[24]
				return
			}
			Item[${OilType}]:Use
			return
		}
		if ${Toon.canUseScroll}
		{
			This:CustOutput["Buffing a scroll",1]
			Toon:UseScroll
			return
		}
		if ${Class.canBuff[Shadowguard]}
		{
			Toon:CastSpell[Shadowguard]
			This:CustOutput["Buffing shadowguard",1]
			return
		}
		return
	}


	member NeedBGPrebuff()
	{
		variable guidlist Candles
		variable int i = 1
		variable guidlist NearbyFriends
    variable objectref FriendlyTarget
		Candles:Search[-items, Sacred Candle]
		NearbyFriends:Search[-players,-nearest,-${Me.FactionGroup.Lower},-alive,-lineofsight,-range 1-28]
		if ${NearbyFriends.Count}
    {
			do
			{
				FriendlyTarget:Set[${NearbyFriends.Object[${i}].GUID}]
				if !${FriendlyTarget.Buff[Power Word: Fortitude](exists)} && ${Toon.canCast[Power Word: Fortitude]} && !${FriendlyTarget.Buff[Prayer of Fortitude](exists)}
				{
					This:CustOutput["Need to buff a friendly player with fort",1]
					return TRUE
				}
				if !${FriendlyTarget.Buff[Divine Spirit](exists)} && ${Toon.canCast[Divine Spirit]} && !${FriendlyTarget.Buff[Prayer of Spirit](exists)}
				{
					This:CustOutput["Need to buff a friendly player with spirit",1]
					return TRUE
				}
				if !${FriendlyTarget.Buff[Shadow Protection](exists)} && ${Toon.canCast[Shadow Protection]} && !${FriendlyTarget.Buff[Prayer of Shadow Protection](exists)}
				{
					This:CustOutput["Need to buff a friendly player with shadow prot",1]
					return TRUE
				}
			}
			while ${i:Inc} <= ${NearbyFriends.Count}
			NearbyFriends:Clear
		}
		if ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", 4]}
		{
			This:CustOutput["Need a refreshment table",1]
			return TRUE
		}
		if ${This.NeedBGObjects["Soulwell", "Master Healthstone", 1]}
		{
			This:CustOutput["Need a soulwell",1]
			return TRUE
		}
		return FALSE
	}

	method BGPrebuffPulse()
	{
		variable guidlist Candles
		variable int i = 1
		variable guidlist NearbyFriends
    variable objectref FriendlyTarget
		Candles:Search[-items, Sacred Candle]
		NearbyFriends:Search[-players,-nearest,-${Me.FactionGroup.Lower},-alive,-lineofsight,-range 1-28]
		if ${Me.Casting}
		{
			return
		}
		if ${NearbyFriends.Count} > 0
    {
			do
			{
				FriendlyTarget:Set[${NearbyFriends.Object[${i}].GUID}]
				if !${FriendlyTarget.Buff[Power Word: Fortitude](exists)} && ${Toon.canCast[Power Word: Fortitude]} && !${FriendlyTarget.Buff[Prayer of Fortitude](exists)}
				{
					This:CustOutput["Buffing ${FriendlyTarget} with fort",1]
					Target ${FriendlyTarget}
					Toon:CastSpell[Power Word: Fortitude]
					return
				}
				if !${FriendlyTarget.Buff[Divine Spirit](exists)} && ${Toon.canCast[Divine Spirit]} && !${FriendlyTarget.Buff[Prayer of Spirit](exists)}
				{
					This:CustOutput["Buffing ${FriendlyTarget} with divine spirit",1]
					Target ${FriendlyTarget}
					Toon:CastSpell[Divine Spirit]
					return
				}
				if !${FriendlyTarget.Buff[Shadow Protection](exists)} && ${Toon.canCast[Shadow Protection]} && !${FriendlyTarget.Buff[Prayer of Shadow Protection](exists)}
				{
					This:CustOutput["Buffing ${FriendlyTarget} with shadow prot",1]
					Target ${FriendlyTarget}
					Toon:CastSpell[Shadow Protection]
					return
				}
			}
			while ${i:Inc} <= ${NearbyFriends.Count}
			NearbyFriends:Clear
		}
		if ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", 4]}
		{
			This:CustOutput["Need to use a refreshment table",1]
			This:BGObjectsPulse["Refreshment Table","Conjured Manna Biscuit", 4]
			return
		}
		if ${This.NeedBGObjects["Soulwell", "Master Healthstone", 1]}
		{
			This:CustOutput["Need to use a soulwell",1]
			This:BGObjectsPulse["Soulwell", "Master Healthstone"]
		}
		return
	}

	;----------------------------------;
	;   CombatBuff Pulse & Checks      ;
	;----------------------------------;

	member NeedCombatBuff()
	{
		if ${Class.UseVar[Shield]} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && (${Me.PctHPs} <= ${Class.UseIntVar[ShieldMyHP]}) && (${Target.PctHPs} <= ${Class.UseIntVar[ShieldMobHP]}) && !${Me.Buff[Forbearance](exists)}
		{
			This:CustOutput["Need shield needcombatbuff",1]
			return TRUE
		}
		if ${Class.UseVar[PainSup]} && ${Me.PctHPs} < ${Class.UseIntVar[PSHP]} && ${Class.canBuff[Pain Suppression]}
		{
			This:CustOutput["Need pain supp needcombatbuff",1]
			return TRUE
		}
		if ${Me.PctHPs} < ${Class.UseIntVar[HPotAt]} && ${Class.UseVar[HPots]} && ${Consumable.HasHPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
		{
			This:CustOutput["Need health pot needcombatbuff",1]
			return TRUE
		}
		if ${Me.PctMana} < ${Class.UseIntVar[MPotAt]} && ${Class.UseVar[MPots]} && ${Consumable.HasMPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
		{
			This:CustOutput["Need mana pot needcombatbuff",1]
			return TRUE
		}
		if ${Target.Type.Equal["Player"]} && ${Class.HasMultiAggro[TRUE]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
		{
			This:CustOutput["Have multi aggro with a player target. needcombatbuff",1]
			return TRUE
		}
		if ${Class.HasMultiAggro}
		{
			This:CustOutput["Need multiaggro needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Symbol of Hope]} && ${Me.PctMana} < 40
		{
			This:CustOutput["Need symbol of hope needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Shadow Word: Pain,"Target"]} && ${Class.UseVar[SWP]} && (${Target.PctHPs} > ${Class.UseVar[SWPHP]})
		{
			This:CustOutput["Need SWP needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Vampiric Embrace,"Target"]} && ${Class.UseVar[VE]} && (${Target.PctHPs} > ${Class.UseIntVar[VEHP]}) && (${Me.PctHPs} < ${Class.UseIntVar[VEMyHP]})
		{
			This:CustOutput["Need ve needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Starshards,"Target"]}
		{
			This:CustOutput["Need starshards needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Devouring Plague,"Target"]} && ${Class.UseVar[DP]} && (${Target.PctHPs} > ${Class.UseIntVar[DPHP]})
		{
			This:CustOutput["Need DP needcombatbuff",1]
			return TRUE
		}
		if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
		{
			This:CustOutput["Need a heal on party member needcombatbuff",1]
			return TRUE
		}
		if ${Class.UseVar[Heals]} && ${Heal.NeedHeal}
		{
			This:CustOutput["Need a heal on self needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
		{
			This:CustOutput["Need shadowform needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Berserking]}
		{
			This:CustOutput["Need beserking needcombatbuff",1]
			return TRUE
		}
		if ${Class.canBuff[Hex of Weakness, "Target"]}
		{
			This:CustOutput["Need hex of weakness needcombatbuff",1]
			return TRUE
		}
		return FALSE
	}

	method CombatBuffPulse()
	{
		if ${Me.Casting} || ${Me.GlobalCooldown} > 0 || ${This.Wanding}
		{
			This:CustOutput["Casting in CombatBuff",1]
			return
		}
		if ${Class.UseVar[Shield]} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && ${Me.PctHPs} < ${Class.UseIntVar[ShieldMyHP]} && ${Target.PctHPs} < ${Class.UseIntVar[ShieldMobHP]} && !${Me.Buff[Forbearance](exists)}
		{
			This:CustOutput["Buffing shield combatbuff",1]
			Toon:CastSpell[Power Word: Shield]
			return
		}
		if ${Class.UseVar[PainSup]} && ${Me.PctHPs} < ${Class.UseIntVar[PSHP]} && ${Class.canBuff[Pain Suppression]}
		{
			This:CustOutput["Buffing ps combat buff",1]
			Toon:CastSpell[Pain Supression]
			return
		}
		if ${Me.PctHPs} < ${Class.UseIntVar[HPotAt]} && ${Class.UseVar[HPots]} && ${Consumable.HasHPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
		{
			This:CustOutput["Using a health pot combatbuff",1]
			Consumable:useHPot
			Class.PotTimer:Set[${This.InSeconds[120]}]
			return
		}
		if ${Me.PctMana} < ${Class.UseIntVar[MPotAt]} && ${Class.UseVar[MPots]} && ${Consumable.HasMPot} && ${Class.PotTimer} < ${LavishScript.RunningTime}
		{
			This:CustOutput["Using a mana pot combatbuff",1]
			Consumable:useMPot
			Class.PotTimer:Set[${This.InSeconds[120]}]
			return
		}
		if ${Target.Type.Equal["Player"]} && ${Class.HasMultiAggro[TRUE]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
		{
			This:CustOutput["Got player multiaggro combatbuff",1]
			This:MultiAggro[TRUE]
			return
		}
		if ${Class.HasMultiAggro}
		{
			This:CustOutput["Got multiaggro combatbuff",1]
			This:MultiAggro
			return
		}
		if ${Class.canBuff[Symbol of Hope]} && ${Me.PctMana} < 40
		{
			This:CustOutput["Buffing symbol of hope combatbuff",1]
			Toon:CastSpell[Symbol of Hope]
			return
		}
		if ${Class.canBuff[Shadow Word: Pain,"Target"]} && ${Class.UseVar[SWP]} && ${Target.PctHPs} > ${Class.UseVar[SWPHP]}
		{
			This:CustOutput["Buffing swp on target combatbuff",1]
			Toon:CastSpell[Shadow Word: Pain]
			return
		}
		if ${Class.canBuff[Vampiric Embrace,"Target"]} && ${Class.UseVar[VE]} && ${Target.PctHPs} > ${Class.UseIntVar[VEHP]} && ${Me.PctHPs} < ${Class.UseIntVar[VEMyHP]}
		{
			This:CustOutput["Buffing VE on target combatbuff",1]
			Toon:CastSpell[Vampiric Embrace]
			return
		}
		if ${Class.canBuff[Starshards, "Target"]}
		{
			This:CustOutput["Buffing starshards on target combatbuff",1]
			Toon:CastSpell[Starshards]
			return
		}
		if ${Class.canBuff[Devouring Plague, "Target"]} && ${Class.UseVar[DP]} && ${Target.PctHPs} > ${Class.UseIntVar[DPHP]}
		{
			This:CustOutput["Buffing DP combatbuff",1]
			if ${Class.canBuff[Inner Focus]}
			{
				This:CustOutput["Buffing inner focus for DP combatbuff",1]
				Toon:CastSpell[Inner Focus]
			}
			Toon:CastSpell[Devouring Plague]
			return
		}
		if ${Class.UseVar[Heals]} && ${Heal.NeedHeal}
		{
			This:CustOutput["Heal on myself combatbuff",1]
			Heal:HealPulse[TRUE]
			return
		}
		if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
		{
			This:CustOutput["Healing a friendly player combatbuff",1]
			Heal:HealPulse
			return
		}
		if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
		{
			This:CustOutput["Buffing shadowform combatbuff",1]
			Toon:CastSpell[Shadowform]
			return
		}
		if ${Class.canBuff[Berserking]}
		{
			This:CustOutput["Buffing beserking combatbuff",1]
			Toon:CastSpell[Berserking]
			return
		}
		if ${Class.canBuff[Hex of Weakness,"Target"]}
		{
			This:CustOutput["Buffing HoW on target combatbuff",1]
			Toon:CastSpell[Hex of Weakness]
			return
		}
		return
	}

	;----------------------------------;
	;  PullBuff/Pull Pulses & Checks   ;
	;----------------------------------;

	member NeedPullBuff()
	{
		if ${Class.canBuff[Power Word: Shield]} && ${Class.UseVar[ShieldOnPull]} && !${Me.Buff[Weakened Soul](exists)} && !${Me.Buff[Forbearance](exists)}
		{
			This:CustOutput["Need shield on pull",1]
			return TRUE
		}
		if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
		{
			This:CustOutput["Need shadowform on pull",1]
			return TRUE
		}
		return FALSE
	}

	method PullBuffPulse()
	{
		if ${Class.canBuff[Power Word: Shield]} && ${Class.UseVar[ShieldOnPull]} && !${Me.Buff[Weakened Soul](exists)} && !${Me.Buff[Forbearance](exists)}
		{
			This:CustOutput["Buffing shield on pull",1]
			Toon:CastSpell[Power Word: Shield]
			return
		}
		if ${Class.canBuff[Shadowform]} && ${Class.UseVar[Shadowform]}
		{
			This:CustOutput["Buffing shadowform on pull",1]
			Toon:CastSpell[Shadowform]
			return
		}
		return
	}
	method PullPulse()
	{
		if ${Target.Classification.Equal[Elite]}
		{
			This:CustOutput["Target is elite. Blacklisting..."]
			GlobalBlacklist:Insert[${Target.GUID},3600000]
			WoWScript ClearTarget()
			move -stop
			return
		}
		if !${Toon.ValidTarget[${Target.GUID}]}
    {
    	This:CustOutput["Need a target"]
      Toon:NeedTarget[1]
      return
    }
    if !${Toon.TargetIsBestTarget}
    {
    	This:CustOutput["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:CustOutput["Too far away. Moving closer"]
			WoWPress -hold moveforward
			return
		}
		if ${Target.Distance} <= ${Math.Calc[${Class.MaxRange} - 5]} && !${Me.Casting}
		{
			Toon:Stop
		}
		if ${Toon.canCast[${This.UseVar[PullSpell]}]} && !${Movement.Speed} && ${This.PullTimer} < ${LavishScript.RunningTime}
		{
			This:CustOutput["Casting ${This.UseVar[PullSpell]} - Pull"]
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpell[${Class.UseVar[PullSpell]}]
			return
		}
		if ${Toon.canCast[Shadow Word: Pain]} && !${Target.Buff[Shadow Word: Pain](exists)} && !${Movement.Speed}
		{
			This:CustOutput["Pulling with SW:P because we can't use ${This.UseVar[PullSpell]}!"]
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpell[Shadow Word: Pain]
			return
		}
		return
	}

	;----------------------------------;
	;        Main Attack Logic         ;
	;----------------------------------;

	method AttackPulse()
	{
		if !${Toon.ValidTarget[${Target.GUID}]}
		{
			Toon:Stop
			Toon:NeedTarget[1]
			return
		}
		if !${Toon.TargetIsBestTarget} && ${Object[${Toon.BestTarget}](exists)} && ${Toon.BestTarget.NotEqual[NULL]}
		{
			Toon:BestTarget
			return
		}
		if ${Toon.TargetIsNew}
		{
			Class.TimesCCd:Set[0]
			This:SetStarting
		}
		if ${Movement.Speed} && (${Target.PctHPs} > 20 || !${Toon.isFacingAway[90]})
		{
			Toon:Stop
		}
		if ${Target.IsTotem}
		{
			Me.Action[Shoot]:Use
			return
		}
		if !${This.UseVar[Wand]} || !${Me.Equip[Ranged](exists)}
		{
			Toon:AutoAttack
		}
		if ${Me.PctHPs} < 20 && ${Target.PctHPs} > 30
		{
			Toon:Flee
			return
		}
		Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		if ${Me.Casting}
		{
			Toon:Stop
			return
		}
		This:CrowdControl
		if ${Target.Fleeing} && ${Toon.canCast[Mind Flay]} && ${Class.UseVar[MindflayRunners]}
		{
			Class:CustOutput["Run faster ${Target.Name}!"]
			Toon:CastSpell[Mind Flay]
			return
		}
		if ${Target.Distance} > ${Class.MaxRange}
		{
			Navigator:MoveToMob[${Target.GUID}]
			return
		}
		if ${Target.Distance} < ${Class.MaxRange}
		{
			if ${Toon.canCast[Shadowfiend]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 50
			{
				Toon:CastSpell[Shadowfiend]
				return
			}
			if ${Me.Buff[Feared](exists)} && ${Toon.canCast[Will of the Forsaken]}
			{
				Toon:CastSpell[Will of the Forsaken]
				return
			}
			if ${Toon.canCast[Mana Tap]} && ${Target.PctMana} > 0
			{
				Toon:CastSpell[Mana Tap]
				return
			}
			if ${Me.PctMana} < 85 && ${Toon.canCast[Arcane Torrent]} && ${Me.Buff[Mana Tap].Application} == 3
			{
				Toon:CastSpell[Arcane Torrent]
				return
			}
			if ${Class.canBuff[Silence, "Target"]} && ${Target.Casting(exists)}
			{
				Toon:CastSpell[Silence]
				return
			}
			if ${Me.Buff[Surge of Light](exists)}
			{
				Class:CustOutput["Casting Smite for free on ${Target.Name}"]
				Toon:CastSpell[Smite]
				return
			}
			if ${Class.UseVar[SWD]} && (${Target.PctHPs} < ${Class.UseIntVar[SWDMaxMobHP]}) && ${Toon.canCast[Shadow Word: Death]}
			{
				Class:CustOutput["Casting SW:D on ${Target.Name}"]
				Toon:CastSpell[Shadow Word: Death]
				return
			}
			AggroList:Search[-units,-nearest,-aggro,-attackable,-alive,-lineofsight,-range 0-${MaxRange}]
			if ${Target.Type.Equal["Player"]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
			{
				if ${Target.Buff[Power Word: Shield](exists)} && ${Toon.canCast[Dispel Magic]}
				{
					Class:CustOutput["Dispelling a shield on ${Target.Name}"]
					Toon:CastSpell[Dispel Magic]
					return
				}
				This:PvP
				return
			}
			if ${This.ShouldWand} && ${Me.Equip[ranged](exists)} && ${Target.Distance} <= 30 && !${Me.Action[Shoot].AutoRepeat} && !${Me.Action[Shoot].Cooldown}
			{
				Class:CustOutput["Shooting my wand!"]
				Me.Action[Shoot]:Use
				return
			}
			if ${AggroList.Count} == 1 && !${Me.Action[Shoot].AutoRepeat}
			{
				This:SingleMob
			}
			if ${AggroList.Count} == 2
			{
				This:DoubleMob
			}
			if ${AggroList.Count} > 2
			{
				This:MultiAggro
			}
			AggroList:Clear
			return
		}
		return
	}
	method SingleMob()
	{
		if ${Class.UseVar[MindBlast]} && (${Target.PctHPs} > ${Class.UseIntVar[MindBlastMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[MindBlastMaxMobHP]}) && ${Toon.canCast[Mind Blast]} && !${This.Wanding}
		{
			Class:CustOutput["Casting Mind Blast on ${Target.Name}"]
			Toon:CastSpell[Mind Blast]
			return
		}
		if ${Class.UseVar[MindFlay]} && (${Target.PctHPs} > ${Class.UseIntVar[MindFlayMinMobHP]}) && ${Toon.canCast[Mind Flay]} && !${This.Wanding}
		{
			if ${Target.Distance} > ${This.MFRange} && !${Movement.Speed}
			{
				Move Forward 500
				Class:CustOutput["Target too far away for Mind Flay, moving closer"]
				return
			}
			Class:CustOutput["Casting Mind Flay on ${Target.Name}"]
			Toon:CastSpell[Mind Flay]
			return
		}
		if ${Class.UseVar[HolyFire]} && (${Target.PctHPs} > ${Class.UseIntVar[HolyFireMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[HolyFireMaxMobHP]}) && ${Toon.canCast[Holy Fire]} && !${This.Wanding}
		{
			Class:CustOutput["Casting Holy Fire on ${Target.Name}"]
			Toon:CastSpell[Holy Fire]
			return
		}
		if ${Class.UseVar[Smite]} && (${Target.PctHPs} > ${Class.UseIntVar[SmiteMinMobHP]}) && (${Target.PctHPs} < ${Class.UseIntVar[SmiteMaxMobHP]}) && ${Toon.canCast[Smite]} && !${This.Wanding}
		{
			Class:CustOutput["Casting Smite on ${Target.Name}"]
			Toon:CastSpell[Smite]
			return
		}
		return
	}
	method DoubleMob(int NumMobs = 1)
	{
		variable guidlist ScreamList
		ScreamList:Search[-units,-nearest,-alive,-targetingme,-nonfriendly,-range 0-10]
		if ${ScreamList.Count} > ${NumMobs} && ${Class.UseVar[Scream]} && ${Toon.canCast[Psychic Scream]}
		{
			Class:CustOutput["AHHHHHHHHHHHHHH!"]
			Toon:CastSpell[Psychic Scream]
			return
		}
		if ${Object[${Targeting.TargetCollection.Get[2]}](exists)} && !${Object[${Targeting.TargetCollection.Get[2]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]}
		{
			Target ${Targeting.TargetCollection.Get[2]}
			Class:CustOutput["Casting SW:P on ${Target.Name}"]
			Toon:CastSpell[Shadow Word: Pain]
			Bot.RandomPause:Set[10]
			if ${Object[${Targeting.TargetCollection.Get[2]}].Buff[Vampiric Embrace](exists)}
			{
				Target ${Targeting.TargetCollection.Get[1]}
			}
		}
		if ${Object[${Targeting.TargetCollection.Get[2]}](exists)} && !${Object[${Targeting.TargetCollection.Get[2]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]}
		{
			Target ${Targeting.TargetCollection.Get[2]}
			Class:CustOutput["Casting VE on ${Target.Name}"]
			Toon:CastSpell[Vampiric Embrace]
			Bot.RandomPause:Set[10]
			Target ${Targeting.TargetCollection.Get[1]}
			return
		}
		This:SingleMob
		return
	}
	method PvP()
	{
		variable guidlist AddsList
		switch ${Target.Class}
		{
			case Druid
				if ${Target.Power.Equal[Mana]} && ${Toon.canCast[Silence]} && (${Target.PctMana} > 5)
				{
					Toon:CastSpell[Silence]
					return
				}
				This:DoubleMob[0]
			break

			case Hunter
				This:DoubleMob[0]
			break

			case Mage
				if ${Target.Buff[Ice Block](exists)} && ${Toon.canCast[Mass Dispel]}
				{
					Toon:CastSpell[Mass Dispel]
					ISXWoW:ClickTerrain[${Target.X},${Target.Y},${Target.Z}]
					return
				}
				This:DoubleMob[0]
			break

			case Paladin
				if (${Target.Buff[Divine Shield](exists)} || ${Target.Buff[Divine Protection](exists)} || ${Target.Buff[Blessing of Protection](exists)}) && ${Toon.canCast[Mass Dispel]}
				{
					Toon:CastSpell[Mass Dispel]
					ISXWoW:ClickTerrain[${Target.X},${Target.Y},${Target.Z}]
					return
				}
				This:DoubleMob[0]
			break

			case Priest
				if ${Target.PctMana} > 2 && ${Toon.canCast[Mana Burn]}
				{
					Toon:CastSpell[Mana Burn]
					return
				}
				This:DoubleMob[0]
			break

			case Rogue
				This:DoubleMob[0]
			break

			case Shaman
				if ${Toon.canCast[Silence]}
				{
					Toon:CastSpell[Silence]
				}
				AddsList:Search[-units,-totem,-notowner,-lineofsight,-attackable,-range 0-30]
				if ${AddsList.Count} > 0 && ${Toon.canShoot}
				{
					Target ${AddsList.Object[1].GUID}
					Toon:Shoot
				}
				This:DoubleMob[0]
			break

			case Warrior
				This:DoubleMob[0]
			break

			case Warlock
				This:DoubleMob[0]
			break

			default
				This:DoubleMob[0]
			break
		}
	}

	method FleePulse()
	{
		if ${Flee.Avoiding} && !${Mount.IsMounted}
		{
			if ${Me.InCombat} && ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)}
			{
				Toon:CastSpell[Power Word: Shield]
				return
			}
		}
		if ${Class.canBuff["Elune's Grace"]}
		{
			Toon:CastSpell["Elune's Grace"]
			return
		}
		if ${Class.canBuff[Renew]}
		{
			Toon:CastSpell[Renew]
			return
		}
		if ${Class.canBuff[Power Word: Shield]} && !${Me.Buff[Weakened Soul](exists)} && ${Me.PctMana} > 20
		{
			Toon:CastSpell[Power Word: Shield]
			return
		}
		if ${Toon.canCast[Psychic Scream]}
		{
			Toon:CastSpell[Psychic Scream]
			return
		}
		if ${Class.canBuff[Pain Suppression]}
		{
			Toon:CastSpell[Pain Suppression]
			return
		}
		if ${Me.Attacking}
		{
			WoWScript AttackTarget()
			return
		}
	}

	variable bool HookBGGuard = TRUE
	member NeedBGGuard()
	{
		if ${This.NeedBGPrebuff}
		{
			return TRUE
		}
		if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
		{
			return TRUE
		}
		return FALSE
	}

	method BGGuardPulse()
	{
		if ${This.NeedBGPrebuff}
		{
			This:BGPrebuffPulse
		}
		if ${Class.UseVar[HealerMode]} && ${Heal.CanHealParty}
		{
			Heal:HealPulse
		}
		return
	}

	;----------------------------------;
	;  Multiple Aggro Logic & Checks   ;
	;----------------------------------;

	variable int LastCCTime = 0
	variable int TimesCCd = 0
	method CrowdControl()
	{
		variable guidlist CCList
		variable objectref CCTarget
		CCList:Search[-units,-nearest,-hostile,-undead,-nonfriendly,-range 0-30]
		CCTarget:Set[${CCList.Object[2].GUID}]

		if ${Toon.canCast[Shackle Undead]} && ${CCList.Count} > 0 && (${Class.TimesCCd} <= 3) && !${CCTarget.Buff[Shackled](exists)} && (${Class.LastCCTime} < ${LavishScript.RunningTime}) && ${CCTarget.Type.Equal[Undead]}
		{
			Target ${CCTarget}
			Class:CustOutput["Casting Shackle on ${Target.Name}"]
			Toon:CastSpell[Shackle Undead]
			Class.TimesCCd:Inc
			Class.LastCCTime:Set[${This.InSeconds[3]}]
			return
		}
		return
	}
	member HasMultiAggro(bool PvP = FALSE)
	{
		variable guidlist AggrosList
		variable objectref AggTarget
		variable int i = 1
		AggrosList:Clear
		if ${PvP}
		{
			AggrosList:Search[-units,-nearest,-alive,-lineofsight,-zfilter 7,-pvp,-attackable,-range 0-${Class.MaxRange}]
		}
		else
		{
			AggrosList:Search[-units,-nearest,-aggro,-alive,-lineofsight,-attackable,-zfilter 7,-range 0-${Class.MaxRange}]
		}
		if ${AggrosList.Count} > 2
    {
			for (i:Set[1]; ${i} <= ${AggrosList.Count}; i:Inc)
			{
				if ${Toon.ValidTarget[${AggrosList.GUID[${i}]}]}
				{
					if !${Object[${AggrosList.GUID[${i}]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
					{
						return TRUE
					}
					if !${Object[${AggrosList.GUID[${i}]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
					{
						return TRUE
					}
					return FALSE
				}
				return FALSE
			}
			return FALSE
		}
		return FALSE
	}
	method MutliAggro(bool PvP = FALSE)
	{
		variable guidlist AggrosList
		variable objectref AggTarget
		variable int i = 1
		AggrosList:Clear
		if ${PvP}
		{
			AggrosList:Search[-units,-nearest,-alive,-lineofsight,-attackable,-zfilter 7,-pvp,-range 0-${Class.MaxRange}]
		}
		else
		{
			AggrosList:Search[-units,-nearest,-aggro,-alive,-lineofsight,-attackable,-zfilter 7,-range 0-${Class.MaxRange}]
		}
		if ${AggrosList.Count} > 2
    {
			for (i:Set[1]; ${i} <= ${AggrosList.Count}; i:Inc)
			{
				if ${Toon.ValidTarget[${AggrosList.GUID[${i}]}]}
				{
					if !${Object[${AggrosList.GUID[${i}]}].Buff[Shadow Word: Pain](exists)} && ${Toon.canCast[Shadow Word: Pain]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
					{
						Target ${AggrosList.GUID[${i}]}
						Class:CustOutput["Casting SW:P on ${Target.Name}"]
						Bot.RandomPause:Set[10]
						Toon:CastSpell[Shadow Word: Pain]
						return
					}
					if !${Object[${AggrosList.GUID[${i}]}].Buff[Vampiric Embrace](exists)} && ${Toon.canCast[Vampiric Embrace]} && !${Object[${AggrosList.GUID[${i}]}].IsTotem}
					{
						Target ${AggrosList.GUID[${i}]}
						Class:CustOutput["Casting VE on ${Target.Name}"]
						Bot.RandomPause:Set[10]
						Toon:CastSpell[Vampiric Embrace]
						return
					}
				}
			}
			Toon:NeedTarget[1]
		}
		return
	}

	;----------------------------------;
	;      Chasing Logic & Checks      ;
	;----------------------------------;
	variable float StartX
	variable float StartY
	variable float StartZ

	variable int ChaseDistance = 90
	variable int ChastingTargetBL = 5

	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:CustOutput["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)}
		{
			Class:CustOutput["New target! Setting start to ${Me.Location}"]
			Class.StartX:Set[${Me.X}]
			Class.StartY:Set[${Me.Y}]
			Class.StartZ:Set[${Me.X}]
			return
		}
		return
	}

	;----------------------------------;
	;         Misc Functions           ;
	;----------------------------------;

	member Wanding()
	{
		if ${Me.Action[Shoot].AutoRepeat}
		{
			WoWScript SpellStopCasting()
			return TRUE
		}
		return FALSE
	}
	member ShouldWand()
	{
		if !${This.UseVar[Wand]}
		{
			return FALSE
		}
		if ${Target.PctHPs} < ${This.UseIntVar[WandMobHP]} && ${This.UseVar[Wand]}
		{
			return TRUE
		}
		if ${Me.PctMana} < ${This.UseIntVar[WandAtMP]} && ${This.UseVar[Wand]}
		{
			return TRUE
		}
		return FALSE
	}
	member canBuff(string spellname, string myObj="Me")
	{
		if ${Toon.canCast[${spellname}]} && !${${myObj}.Buff[${spellname}](exists)} && !${${myObj}.IsTotem}
		{
			return TRUE
		}
		return FALSE
	}
	member ChooseOilType(string OilType)
	{
		variable int i = 1
		variable index:string OilName
		OilName:Insert["Minor ${OilType}"]
		OilName:Insert["Lesser ${OilType}"]
		OilName:Insert["${OilType}"]
		OilName:Insert["Greater ${OilType}"]
		OilName:Insert["Superior ${OilType}"]
		OilName:Insert["Brilliant ${OilType}"]
		do
		{
			if ${Item[${OilName.Get[${i}]}](exists)}
			{
				return "${OilName.Get[${i}]}"
			}
		}
		while ${OilName.Get[${i:Inc}](exists)}
		return "NONE"
	}
	member GetSpellRange(int base, string spellTree)
	{
		if ${spellTree.Equal[shadow]}
		{
			return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Shadow Reach]}))-1].Round}
		}
		if ${spellTree.Equal[holy]}
		{
			return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Holy Reach]}))-1].Round}
		}
		return ${base}
	}
	method SetDistances()
	{
		if  ${Class.GetSpellRange[30, "shadow"]} > ${Class.GetSpellRange[30, "holy"]}
		{
			Class.MaxRange:Set[${Class.GetSpellRange[30, "shadow"]}]
			This:CustOutput["Setting New MaxRange to ${Class.MaxRange}"]
			Class.MFRange:Set[${Class.GetSpellRange[20, "shadow"]}]
			This:CustOutput["Setting New Mind Flay range to ${Class.MFRange}"]
		}
		else
		{
			Class.MaxRange:Set[${Class.GetSpellRange[30, "holy"]}]
			This:CustOutput["Setting New MaxRange to ${Class.MaxRange"]
		}
	}
	variable int BuffNum = 0
	variable bool debuffStatus = FALSE
	method debuffAll()
	{
		if ${Me.PctMana} < 15 || ${Me.Casting}
		{
			return
		}
		BuffNum:Inc
		if ${BuffNum} > 56
		{
			BuffNum:Set[1]
		}
		if ${Me.Buff[${BuffNum}].Harmful}
		{
			debuffStatus:Set[TRUE]
			if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
			{
				if  ${Toon.canCast[Cure Disease]}
				{
					Target ${Me}
					This:CustOutput[${ShowOutput}, "Cleansing a disease"]
					Toon:CastSpell[Cure Disease]
					debuffStatus:Set[FALSE]
					return
				}
			}
			if ${Me.Buff[${BuffNum}].DispelType.Equal[Magic]}
			{
				if  ${Toon.canCast[Dispel Magic]}
				{
					Target ${Me}
					This:CustOutput[${ShowOutput}, "Dispelling a magic debuff"]
					Toon:CastSpell[Dispel Magic]
					debuffStatus:Set[FALSE]
					return
				}
			}
			return
		}
		if !${Target.Buff[${BuffNum}].Harmful} && ${Target.Buff[${BuffNum}].DispelType.Equal[Magic]}
		{
			debuffStatus:Set[TRUE]
			if ${Toon.canCast[Dispel Magic]}
			{
				Toon:CastSpell[Dispel Magic]
				debuffStatus:Set[FALSE]
				return
			}
		}
		return
	}
	method CustOutput(string Txt, int Debug = 0)
	{
		if ${This.UseVar[Output]} && ${Debug} == 0
		{
			UIElement[ClassGUI].FindChild[Pages].FindChild[Output].FindChild[Console]:Echo["${Txt}"]
		}
		if ${Debug} == 1
		{
			echo "[${Time.Time24}] ${Txt}"
			redirect -append "${Script.CurrentDirectory}/routines/PriestDebug/PriestDebug.txt" echo "[${Time.Time24}] ${Txt}"
		}
	}
	member NeedBGObjects(string objectName, string objectItem, int objectValue)
	{
		variable int i = 1
		variable guidlist UsableObjs
		variable objectref UseableObject
		UsableObjs:Search[-gameobjects, -usable, -range 0-40]
		i:Set[1]
		if ${UsableObjs.Count}
		{
			do
			{
				UseableObject:Set[${UsableObjs.Object[${i}].GUID}]
				This:Output["We have at the moment ${This.InventoryCountItem[${objectItem}]} ${objectItem}!"]
				This:Output["And there is a ${UseableObject.Name} arount."]
				if ${UseableObject.Name.Equal[${objectName}]} && ${This.InventoryCountItem[${objectItem}]} < ${objectValue}
				{
					return TRUE
				}
			}
			while ${i:Inc} <= ${objectref.Count}
		}
		UsableObjs:Clear
		return FALSE
	}
	method BGObjectsPulse(string objectName, string objectItem, int objectValue)
	{
		variable int i = 1
		variable guidlist UsableObjs
		variable objectref UseableObject
		UsableObjs:Search[-gameobjects, -usable, -range 0-40]
		i:Set[1]
		if ${UsableObjs.Count}
		{
			do
			{
				UseableObject:Set[${UsableObjs.Object[${i}].GUID}]
				if ${UseableObject.Name.Equal[${objectName}]} && ${This.InventoryCountItem[${objectItem}]} < ${objectValue}
				{
					if ${UseableObject.Distance} > 4 && !${Navigator.MovingToPoint[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]}
					{
						This:Output["Moving towards ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
						Navigator:MoveToLoc[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]
					}
					if ${Object[${UseableObject}].Distance} < 4
					{
						Toon:Stop
						This:Output["Using ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
						UseableObject:Use
						Bot.RandomPause:Set[16]
					}
					return
				}
			}
			while ${i:Inc} <= ${objectref.Count}
		}
		UsableObjs:Clear
		return
	}
	member InventoryCountItem(string itemName)
	{
		variable guidlist countItem
		countItem:Search[-items,-inventory, ${itemName}]
		return ${countItem.Count}
	}
	method SetSpellTimer(string eventid,string text,string Who,string spellname)
	{
		if ${spellname.Equal[${This.UseVar[PullSpell]}]}
		{
			This.PullTimer:Set[${This.InSeconds[3]}]
		}
	}

	;----------------------------------;
	;       All The GUI Shit           ;
	;----------------------------------;
	variable string RealmChar = "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
	method Initialize()
	{
		LavishScript:RegisterEvent[UNIT_SPELLCAST_SUCCEEDED]
		Event[UNIT_SPELLCAST_SUCCEEDED]:AttachAtom[This:SetSpellTimer]
		This:SetGUI
		This:InitPriestGUI
		This:SetDistances
		Bot:AddPulse["Class","HealTargetsPulse",3,FALSE,FALSE,1]
		This:CustOutput["Apoc's Priest Routine v5.2 Loaded!"]
	}
	method Shutdown()
	{
		This:SaveGUI
	}
	method InitPriestGUI()
	{
		variable int i
		for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.UseVar[PullSpell].Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.UseVar[ChooseOil].Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		if ${This.UseVar[HPots]}
		{
			UIElement[HPots@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[MPots]}
		{
			UIElement[MPots@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Wand]}
		{
			UIElement[Wand@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Smite]}
		{
			UIElement[Smite@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[HolyFire]}
		{
			UIElement[HolyFire@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[MindFlay]}
		{
			UIElement[MindFlay@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[MindFlayRunners]}
		{
			UIElement[MindFlayRunners@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[MindBlast]}
		{
			UIElement[MindBlast@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[SWD]}
		{
			UIElement[SWD@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[DP]}
		{
			UIElement[DP@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[VE]}
		{
			UIElement[VE@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[SWP]}
		{
			UIElement[SWP@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Scream]}
		{
			UIElement[Scream@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Heals]}
		{
			UIElement[Heals@Heal@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[HealerMode]}
		{
			UIElement[HealerMode@Heal@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[PWF]}
		{
			UIElement[PWF@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[ShadowProt]}
		{
			UIElement[ShadowProt@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[DivineSpirit]}
		{
			UIElement[DivineSpirit@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[UseCandles]}
		{
			UIElement[UseCandles@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[InnerFire]}
		{
			UIElement[InnerFire@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Shadowform]}
		{
			UIElement[Shadowform@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[FearWard]}
		{
			UIElement[FearWard@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Shield]}
		{
			UIElement[Shield@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[PainSup]}
		{
			UIElement[PainSup@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[ShieldOnPull]}
		{
			UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseVar[Output]}
		{
			UIElement[EnableOutput@Output@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseIntVar[WandMobHP]} != ${UIElement[WandMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[WandMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandMobHP]}]
		}
		if ${This.UseIntVar[RestHP]} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value}
		{
			UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[RestHP]}]
		}
		if ${This.UseIntVar[StandHP]} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value}
		{
			UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[StandHP]}]
		}
		if ${This.UseIntVar[RestMP]} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[RestMP]}]
		}
		if ${This.UseIntVar[StandMP]} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[StandMP]}]
		}
		if ${This.UseIntVar[SpiritTapMP]} != ${UIElement[SpiritTapMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[SpiritTapMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[SpiritTapMP]}]
		}
		if ${This.UseIntVar[HPotAt]} != ${UIElement[HPotAt@Main@Pages@ClassGUI].Value}
		{
			UIElement[HPotAt@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[HPotAt]}]
		}
		if ${This.UseIntVar[MPotAt]} != ${UIElement[MPotAt@Main@Pages@ClassGUI].Value}
		{
			UIElement[MPotAt@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[MPotAt]}]
		}
		if ${This.UseIntVar[WandAtMP]} != ${UIElement[WandAtMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[WandAtMP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandAtMP]}]
		}
		if ${This.UseIntVar[WandMobHP]} != ${UIElement[WandMobHP@Main@Pages@ClassGUI].Value}
		{
			UIElement[WandMobHP@Main@Pages@ClassGUI]:SetValue[${This.UseIntVar[WandMobHP]}]
		}
		if ${This.UseIntVar[SmiteMinMobHP]} != ${UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SmiteMinMobHP]}]
		}
		if ${This.UseIntVar[SmiteMaxMobHP]} != ${UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SmiteMaxMobHP]}]
		}
		if ${This.UseIntVar[HolyFireMinMobHP]} != ${UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[HolyFireMinMobHP]}]
		}
		if ${This.UseIntVar[HolyFireMaxMobHP]} != ${UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[HolyFireMaxMobHP]}]
		}
		if ${This.UseIntVar[MindFlayMinMobHP]} != ${UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindFlayMinMobHP]}]
		}
		if ${This.UseIntVar[MindBlastMinMobHP]} != ${UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindBlastMinMobHP]}]
		}
		if ${This.UseIntVar[MindBlastMaxMobHP]} != ${UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[MindBlastMaxMobHP]}]
		}
		if ${This.UseIntVar[SWDMaxMobHP]} != ${UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[SWDMaxMobHP]}]
		}
		if ${This.UseIntVar[DPHP]} != ${UIElement[DPHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[DPHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[DPHP]}]
		}
		if ${This.UseIntVar[VEMyHP]} != ${UIElement[VEMyHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[VEMyHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[VEMyHP]}]
		}
		if ${This.UseIntVar[VEHP]} != ${UIElement[VEHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[VEHP@Spells@Pages@ClassGUI]:SetValue[${This.UseIntVar[VEHP]}]
		}
		if ${This.UseIntVar[HealRenewHP]} != ${UIElement[HealRenewHP@Heal@Pages@ClassGUI].Value}
		{
			UIElement[HealRenewHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealRenewHP]}]
		}
		if ${This.UseIntVar[HealFlashHP]} != ${UIElement[HealFlashHP@Heal@Pages@ClassGUI].Value}
		{
			UIElement[HealFlashHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealFlashHP]}]
		}
		if ${This.UseIntVar[HealGreaterHP]} != ${UIElement[HealGreaterHP@Heal@Pages@ClassGUI].Value}
		{
			UIElement[HealGreaterHP@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HealGreaterHP]}]
		}
		if ${This.UseIntVar[DruidWeight]} != ${UIElement[DruidWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[DruidWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[DruidWeight]}]
		}
		if ${This.UseIntVar[HunterWeight]} != ${UIElement[HunterWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[HunterWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[HunterWeight]}]
		}
		if ${This.UseIntVar[MageWeight]} != ${UIElement[MageWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[MageWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[MageWeight]}]
		}
		if ${This.UseIntVar[PaladinWeight]} != ${UIElement[PaladinWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[PaladinWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[PaladinWeight]}]
		}
		if ${This.UseIntVar[PriestWeight]} != ${UIElement[PriestWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[PriestWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[PriestWeight]}]
		}
		if ${This.UseIntVar[RogueWeight]} != ${UIElement[RogueWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[RogueWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[RogueWeight]}]
		}
		if ${This.UseIntVar[ShamanWeight]} != ${UIElement[ShamanWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[ShamanWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShamanWeight]}]
		}
		if ${This.UseIntVar[WarlockWeight]} != ${UIElement[WarlockWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[WarlockWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[WarlockWeight]}]
		}
		if ${This.UseIntVar[WarriorWeight]} != ${UIElement[WarriorWeight@Heal@Pages@ClassGUI].Value}
		{
			UIElement[WarriorWeight@Heal@Pages@ClassGUI]:SetValue[${This.UseIntVar[WarriorWeight]}]
		}
		if ${This.UseIntVar[ShieldMyHP]} != ${UIElement[ShieldMyHP@Buffs@Pages@ClassGUI].Value}
		{
			UIElement[ShieldMyHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShieldMyHP]}]
		}
		if ${This.UseIntVar[ShieldMobHP]} != ${UIElement[ShieldMobHP@Buffs@Pages@ClassGUI].Value}
		{
			UIElement[ShieldMobHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[ShieldMobHP]}]
		}
		if ${This.UseIntVar[PSHP]} != ${UIElement[PSHP@Buffs@Pages@ClassGUI].Value}
		{
			UIElement[PSHP@Buffs@Pages@ClassGUI]:SetValue[${This.UseIntVar[PSHP]}]
		}
		if ${THis.UseIntVar[SWPHP]} != ${UIElement[SWPHP@Spells@Pages@ClassGUI].Value}
		{
			UIElement[SWPHP@Spells@Pages@ClassGUI]:SetValue[${THis.UseIntVar[SWPHP]}]
		}
	}
	method SetGUI()
	{
		This:SetUse[PullSpell,${Config.GetSetting["${RealmChar}","PullSpell"]}]
		This:SetUse[HPots,${Config.GetSetting["${RealmChar}","HPots"]}]
		This:SetUse[MPots,${Config.GetSetting["${RealmChar}","MPots"]}]
		This:SetUse[Wand,${Config.GetSetting["${RealmChar}","Wand"]}]
		This:SetUse[Smite,${Config.GetSetting["${RealmChar}","Smite"]}]
		This:SetUse[HolyFire,${Config.GetSetting["${RealmChar}","HolyFire"]}]
		This:SetUse[MindFlay,${Config.GetSetting["${RealmChar}","MindFlay"]}]
		This:SetUse[MindFlayRunners,${Config.GetSetting["${RealmChar}","MindFlayRunners"]}]
		This:SetUse[MindBlast,${Config.GetSetting["${RealmChar}","MindBlast"]}]
		This:SetUse[SWD,${Config.GetSetting["${RealmChar}","SWD"]}]
		This:SetUse[DP,${Config.GetSetting["${RealmChar}","DP"]}]
		This:SetUse[VE,${Config.GetSetting["${RealmChar}","VE"]}]
		This:SetUse[SWP,${Config.GetSetting["${RealmChar}","SWP"]}]
		This:SetUse[Scream,${Config.GetSetting["${RealmChar}","Scream"]}]
		This:SetUse[Heals,${Config.GetSetting["${RealmChar}","Heals"]}]
		This:SetUse[HealerMode,${Config.GetSetting["${RealmChar}","HealerMode"]}]
		This:SetUse[PWF,${Config.GetSetting["${RealmChar}","PWF"]}]
		This:SetUse[ShadowProt,${Config.GetSetting["${RealmChar}","ShadowProt"]}]
		This:SetUse[DivineSpirit,${Config.GetSetting["${RealmChar}","DivineSpirit"]}]
		This:SetUse[UseCandles,${Config.GetSetting["${RealmChar}","UseCandles"]}]
		This:SetUse[InnerFire,${Config.GetSetting["${RealmChar}","InnerFire"]}]
		This:SetUse[Shadowform,${Config.GetSetting["${RealmChar}","Shadowform"]}]
		This:SetUse[FearWard,${Config.GetSetting["${RealmChar}","FearWard"]}]
		This:SetUse[Shield,${Config.GetSetting["${RealmChar}","Shield"]}]
		This:SetUse[PainSup,${Config.GetSetting["${RealmChar}","PainSup"]}]
		This:SetUse[ChooseOil,${Config.GetSetting["${RealmChar}","ChooseOil"]}]
		This:SetUse[ShieldOnPull,${Config.GetSetting["${RealmChar}","ShieldOnPull"]}]
		This:SetUse[Output,${Config.GetSetting["${RealmChar}","Output"]}]


		This:SetUseInt[RestHP,${Config.GetSetting["${RealmChar}","RestHP"]}]
		This:SetUseInt[StandHP,${Config.GetSetting["${RealmChar}","StandHP"]}]
		This:SetUseInt[RestMP,${Config.GetSetting["${RealmChar}","RestMP"]}]
		This:SetUseInt[StandMP,${Config.GetSetting["${RealmChar}","StandMP"]}]
		This:SetUseInt[SpiritTapMP,${Config.GetSetting["${RealmChar}","SpiritTapMP"]}]
		This:SetUseInt[HPotAt,${Config.GetSetting["${RealmChar}","HPotAt"]}]
		This:SetUseInt[MPotAt,${Config.GetSetting["${RealmChar}","MPotAt"]}]
		This:SetUseInt[WandAtMP,${Config.GetSetting["${RealmChar}","WandAtMP"]}]
		This:SetUseInt[WandMobHP,${Config.GetSetting["${RealmChar}","WandMobHP"]}]
		This:SetUseInt[SmiteMinMobHP,${Config.GetSetting["${RealmChar}","SmiteMinMobHP"]}]
		This:SetUseInt[SmiteMaxMobHP,${Config.GetSetting["${RealmChar}","SmiteMaxMobHP"]}]
		This:SetUseInt[HolyFireMinMobHP,${Config.GetSetting["${RealmChar}","HolyFireMinMobHP"]}]
		This:SetUseInt[HolyFireMaxMobHP,${Config.GetSetting["${RealmChar}","HolyFireMaxMobHP"]}]
		This:SetUseInt[MindFlayMinMobHP,${Config.GetSetting["${RealmChar}","MindFlayMinMobHP"]}]
		This:SetUseInt[MindBlastMinMobHP,${Config.GetSetting["${RealmChar}","MindBlastMinMobHP"]}]
		This:SetUseInt[MindBlastMaxMobHP,${Config.GetSetting["${RealmChar}","MindBlastMaxMobHP"]}]
		This:SetUseInt[SWDMaxMobHP,${Config.GetSetting["${RealmChar}","SWDMaxMobHP"]}]
		This:SetUseInt[DPHP,${Config.GetSetting["${RealmChar}","DPHP"]}]
		This:SetUseInt[VEMyHP,${Config.GetSetting["${RealmChar}","VEMyHP"]}]
		This:SetUseInt[VEHP,${Config.GetSetting["${RealmChar}","VEHP"]}]
		This:SetUseInt[HealRenewHP,${Config.GetSetting["${RealmChar}","HealRenewHP"]}]
		This:SetUseInt[HealFlashHP,${Config.GetSetting["${RealmChar}","HealFlashHP"]}]
		This:SetUseInt[HealGreaterHP,${Config.GetSetting["${RealmChar}","HealGreaterHP"]}]
		This:SetUseInt[HealerMode,${Config.GetSetting["${RealmChar}","HealerMode"]}]
		This:SetUseInt[DruidWeight,${Config.GetSetting["${RealmChar}","DruidWeight"]}]
		This:SetUseInt[HunterWeight,${Config.GetSetting["${RealmChar}","HunterWeight"]}]
		This:SetUseInt[MageWeight,${Config.GetSetting["${RealmChar}","MageWeight"]}]
		This:SetUseInt[PaladinWeight,${Config.GetSetting["${RealmChar}","PaladinWeight"]}]
		This:SetUseInt[PriestWeight,${Config.GetSetting["${RealmChar}","PriestWeight"]}]
		This:SetUseInt[RogueWeight,${Config.GetSetting["${RealmChar}","RogueWeight"]}]
		This:SetUseInt[ShamanWeight,${Config.GetSetting["${RealmChar}","ShamanWeight"]}]
		This:SetUseInt[WarlockWeight,${Config.GetSetting["${RealmChar}","WarlockWeight"]}]
		This:SetUseInt[WarriorWeight,${Config.GetSetting["${RealmChar}","WarriorWeight"]}]
		This:SetUseInt[PSHP,${Config.GetSetting["${RealmChar}","PSHP"]}]
		This:SetUseInt[ShieldMyHP,${Config.GetSetting["${RealmChar}","ShieldMyHP"]}]
		This:SetUseInt[ShieldMobHP,${Config.GetSetting["${RealmChar}","ShieldMobHP"]}]
		This:SetUseInt[SWPHP,${Config.GetSetting["${RealmChar}","SWPHP"]}]
	}
	method SaveGUI()
	{
		Config:SetSetting["${RealmChar}","PullSpell",${This.UseVar[PullSpell]}]
		Config:SetSetting["${RealmChar}","RestHP",${This.UseIntVar[RestHP]}]
		Config:SetSetting["${RealmChar}","StandHP",${This.UseIntVar[StandHP]}]
		Config:SetSetting["${RealmChar}","RestMP",${This.UseIntVar[RestMP]}]
		Config:SetSetting["${RealmChar}","StandMP",${This.UseIntVar[StandMP]}]
		Config:SetSetting["${RealmChar}","SpiritTapMP",${This.UseIntVar[SpiritTapMP]}]
		Config:SetSetting["${RealmChar}","HPots",${This.UseVar[HPots]}]
		Config:SetSetting["${RealmChar}","MPots",${This.UseVar[MPots]}]
		Config:SetSetting["${RealmChar}","HPotAt",${This.UseIntVar[HPotAt]}]
		Config:SetSetting["${RealmChar}","MPotAt",${This.UseIntVar[MPotAt]}]
		Config:SetSetting["${RealmChar}","Wand",${This.UseVar[Wand]}]
		Config:SetSetting["${RealmChar}","WandAtMP",${This.UseIntVar[WandAtMP]}]
		Config:SetSetting["${RealmChar}","WandMobHP",${This.UseIntVar[WandMobHP]}]
		Config:SetSetting["${RealmChar}","Smite",${This.UseVar[Smite]}]
		Config:SetSetting["${RealmChar}","SmiteMinMobHP",${This.UseIntVar[SmiteMinMobHP]}]
		Config:SetSetting["${RealmChar}","SmiteMaxMobHP",${This.UseIntVar[SmiteMaxMobHP]}]
		Config:SetSetting["${RealmChar}","HolyFire",${This.UseVar[HolyFire]}]
		Config:SetSetting["${RealmChar}","HolyFireMinMobHP",${This.UseIntVar[HolyFireMinMobHP]}]
		Config:SetSetting["${RealmChar}","HolyFireMaxMobHP",${This.UseIntVar[HolyFireMaxMobHP]}]
		Config:SetSetting["${RealmChar}","MindFlay",${This.UseVar[MindFlay]}]
		Config:SetSetting["${RealmChar}","MindFlayRunners",${This.UseVar[MindFlayRunners]}]
		Config:SetSetting["${RealmChar}","MindFlayMinMobHP",${This.UseIntVar[MindFlayMinMobHP]}]
		Config:SetSetting["${RealmChar}","MindBlast",${This.UseVar[MindBlast]}]
		Config:SetSetting["${RealmChar}","MindBlastMinMobHP",${This.UseIntVar[MindBlastMinMobHP]}]
		Config:SetSetting["${RealmChar}","MindBlastMaxMobHP",${This.UseIntVar[MindBlastMaxMobHP]}]
		Config:SetSetting["${RealmChar}","SWD",${This.UseVar[SWD]}]
		Config:SetSetting["${RealmChar}","SWDMaxMobHP",${This.UseIntVar[SWDMaxMobHP]}]
		Config:SetSetting["${RealmChar}","DP",${This.UseVar[DP]}]
		Config:SetSetting["${RealmChar}","DPHP",${This.UseIntVar[DPHP]}]
		Config:SetSetting["${RealmChar}","VE",${This.UseVar[VE]}]
		Config:SetSetting["${RealmChar}","VEMyHP",${This.UseIntVar[VEMyHP]}]
		Config:SetSetting["${RealmChar}","VEHP",${This.UseIntVar[VEHP]}]
		Config:SetSetting["${RealmChar}","Scream",${This.UseVar[Scream]}]
		Config:SetSetting["${RealmChar}","Heals",${This.UseVar[Heals]}]
		Config:SetSetting["${RealmChar}","HealRenewHP",${This.UseIntVar[HealRenewHP]}]
		Config:SetSetting["${RealmChar}","HealFlashHP",${This.UseIntVar[HealFlashHP]}]
		Config:SetSetting["${RealmChar}","HealGreaterHP",${This.UseIntVar[HealGreaterHP]}]
		Config:SetSetting["${RealmChar}","HealerMode",${This.UseVar[HealerMode]}]
		Config:SetSetting["${RealmChar}","DruidWeight",${This.UseIntVar[DruidWeight]}]
		Config:SetSetting["${RealmChar}","HunterWeight",${This.UseIntVar[HunterWeight]}]
		Config:SetSetting["${RealmChar}","MageWeight",${This.UseIntVar[MageWeight]}]
		Config:SetSetting["${RealmChar}","PaladinWeight",${This.UseIntVar[PaladinWeight]}]
		Config:SetSetting["${RealmChar}","PriestWeight",${This.UseIntVar[PriestWeight]}]
		Config:SetSetting["${RealmChar}","RogueWeight",${This.UseIntVar[RogueWeight]}]
		Config:SetSetting["${RealmChar}","ShamanWeight",${This.UseIntVar[ShamanWeight]}]
		Config:SetSetting["${RealmChar}","WarlockWeight",${This.UseIntVar[WarlockWeight]}]
		Config:SetSetting["${RealmChar}","WarriorWeight",${This.UseIntVar[WarriorWeight]}]
		Config:SetSetting["${RealmChar}","PWF",${This.UseVar[PWF]}]
		Config:SetSetting["${RealmChar}","ShadowProt",${This.UseVar[ShadowProt]}]
		Config:SetSetting["${RealmChar}","DivineSpirit",${This.UseVar[DivineSpirit]}]
		Config:SetSetting["${RealmChar}","UseCandles",${This.UseVar[UseCandles]}]
		Config:SetSetting["${RealmChar}","InnerFire",${This.UseVar[InnerFire]}]
		Config:SetSetting["${RealmChar}","Shadowform",${This.UseVar[Shadowform]}]
		Config:SetSetting["${RealmChar}","FearWard",${This.UseVar[FearWard]}]
		Config:SetSetting["${RealmChar}","Shield",${This.UseVar[Shield]}]
		Config:SetSetting["${RealmChar}","ShieldMyHP",${This.UseIntVar[ShieldMyHP]}]
		Config:SetSetting["${RealmChar}","ShieldMobHP",${This.UseIntVar[ShieldMobHP]}]
		Config:SetSetting["${RealmChar}","PainSup",${This.UseVar[PainSup]}]
		Config:SetSetting["${RealmChar}","PSHP",${This.UseIntVar[PSHP]}]
		Config:SetSetting["${RealmChar}","ChooseOil",${This.UseVar[ChooseOil]}]
		Config:SetSetting["${RealmChar}","ShieldOnPull",${This.UseVar[ShieldOnPull]}]
		Config:SetSetting["${RealmChar}","Output",${This.UseVar[Output]}]
		Config:SetSetting["${RealmChar}","SWP",${This.UseVar[SWP]}]
		Config:SetSetting["${RealmChar}","SWPHP",${This.UseIntVar[SWPHP]}]
	}
	method ClassGUIChange(string Action)
	{
		switch ${Action}
		{
			case PullSpell
				Class:SetUse[PullSpell,${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}]
				break
			case RestHP
				Class:SetUseInt[RestHP,${UIElement[RestHP@Main@Pages@ClassGUI].Value}]
				break
			case StandHP
				Class:SetUseInt[StandHP,${UIElement[StandHP@Main@Pages@ClassGUI].Value}]
				break
			case RestMP
				Class:SetUseInt[RestMP,${UIElement[RestMP@Main@Pages@ClassGUI].Value}]
				break
			case StandMP
				Class:SetUseInt[StandMP,${UIElement[StandMP@Main@Pages@ClassGUI].Value}]
				break
			case SpiritTapMP
				Class:SetUseInt[SpiritTapMP,${UIElement[SpiritTapMP@Main@Pages@ClassGUI].Value}]
				break
			case HPots
				Class:SetUse[HPots,${UIElement[HPots@Main@Pages@ClassGUI].Checked}]
				break
			case MPots
				Class:SetUse[MPots,${UIElement[MPots@Main@Pages@ClassGUI].Checked}]
				break
			case HPotAt
				Class:SetUseInt[HPotAt,${UIElement[HPotAt@Main@Pages@ClassGUI].Value}]
				break
			case MPotAt
				Class:SetUseInt[MPotAt,${UIElement[MPotAt@Main@Pages@ClassGUI].Value}]
				break
			case Wand
				Class:SetUse[Wand,${UIElement[Wand@Main@Pages@ClassGUI].Checked}]
				break
			case WandAtMP
				Class:SetUseInt[WandAtMP,${UIElement[WandAtMP@Main@Pages@ClassGUI].Value}]
				break
			case WandMobHP
				Class:SetUseInt[WandMobHP,${UIElement[WandMobHP@Main@Pages@ClassGUI].Value}]
				break
			case Smite
				Class:SetUse[Smite,${UIElement[Smite@Spells@Pages@ClassGUI].Checked}]
				break
			case SmiteMinMobHP
				Class:SetUseInt[SmiteMinMobHP,${UIElement[SmiteMinMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case SmiteMaxMobHP
				Class:SetUseInt[SmiteMaxMobHP,${UIElement[SmiteMaxMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case HolyFire
				Class:SetUse[HolyFire,${UIElement[HolyFire@Spells@Pages@ClassGUI].Checked}]
				break
			case HolyFireMinMobHP
				Class:SetUseInt[HolyFireMinMobHP,${UIElement[HolyFireMinMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case HolyFireMaxMobHP
				Class:SetUseInt[HolyFireMaxMobHP,${UIElement[HolyFireMaxMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case MindFlay
				Class:SetUse[MindFlay,${UIElement[MindFlay@Spells@Pages@ClassGUI].Checked}]
				break
			case MindFlayRunners
				Class:SetUse[MindFlayRunners,${UIElement[MindFlayRunners@Spells@Pages@ClassGUI].Checked}]
				break
			case MindFlayMinMobHP
				Class:SetUseInt[MindFlayMinMobHP,${UIElement[MindFlayMinMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case MindBlast
				Class:SetUse[MindBlast,${UIElement[MindBlast@Spells@Pages@ClassGUI].Checked}]
				break
			case MindBlastMinMobHP
				Class:SetUseInt[MindBlastMinMobHP,${UIElement[MindBlastMinMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case MindBlastMaxMobHP
				Class:SetUseInt[MindBlastMaxMobHP,${UIElement[MindBlastMaxMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case SWD
				Class:SetUse[SWD,${UIElement[SWD@Spells@Pages@ClassGUI].Checked}]
				break
			case SWDMaxMobHP
				Class:SetUseInt[SWDMaxMobHP,${UIElement[SWDMaxMobHP@Spells@Pages@ClassGUI].Value}]
				break
			case DP
				Class:SetUse[DP,${UIElement[DP@Spells@Pages@ClassGUI].Checked}]
				break
			case DPHP
				Class:SetUseInt[DPHP,${UIElement[DPHP@Spells@Pages@ClassGUI].Value}]
				break
			case VE
				Class:SetUse[VE,${UIElement[VE@Spells@Pages@ClassGUI].Checked}]
				break
			case VEMyHP
				Class:SetUseInt[VEMyHP,${UIElement[VEMyHP@Spells@Pages@ClassGUI].Value}]
				break
			case VEHP
				Class:SetUseInt[VEHP,${UIElement[VEHP@Spells@Pages@ClassGUI].Value}]
				break
			case SWP
				Class:SetUse[SWP,${UIElement[SWP@Spells@Pages@ClassGUI].Checked}]
				break
			case SWPHP
				Class:SetUseInt[SWPHP,${UIElement[SWPHP@Spells@Pages@ClassGUI].Value}]
				break
			case Scream
				Class:SetUse[Scream,${UIElement[Scream@Spells@Pages@ClassGUI].Checked}]
				break
			case Heals
				Class:SetUse[Heals,${UIElement[Heals@Heal@Pages@ClassGUI].Checked}]
				break
			case HealRenewHP
				Class:SetUseInt[HealRenewHP,${UIElement[HealRenewHP@Heal@Pages@ClassGUI].Value}]
				break
			case HealFlashHP
				Class:SetUseInt[HealFlashHP,${UIElement[HealFlashHP@Heal@Pages@ClassGUI].Value}]
				break
			case HealGreaterHP
				Class:SetUseInt[HealGreaterHP,${UIElement[HealGreaterHP@Heal@Pages@ClassGUI].Value}]
				break
			case HealerMode
				Class:SetUse[HealerMode,${UIElement[HealerMode@Heal@Pages@ClassGUI].Checked}]
				break
			case DruidWeight
				Class:SetUseInt[DruidWeight,${UIElement[DruidWeight@Heal@Pages@ClassGUI].Value}]
				break
			case HunterWeight
				Class:SetUseInt[HunterWeight,${UIElement[HunterWeight@Heal@Pages@ClassGUI].Value}]
				break
			case MageWeight
				Class:SetUseInt[MageWeight,${UIElement[MageWeight@Heal@Pages@ClassGUI].Value}]
				break
			case PaladinWeight
				Class:SetUseInt[PaladinWeight,${UIElement[PaladinWeight@Heal@Pages@ClassGUI].Value}]
				break
			case PriestWeight
				Class:SetUseInt[PriestWeight,${UIElement[PriestWeight@Heal@Pages@ClassGUI].Value}]
				break
			case RogueWeight
				Class:SetUseInt[RogueWeight,${UIElement[RogueWeight@Heal@Pages@ClassGUI].Value}]
				break
			case ShamanWeight
				Class:SetUseInt[ShamanWeight,${UIElement[ShamanWeight@Heal@Pages@ClassGUI].Value}]
				break
			case WarlockWeight
				Class:SetUseInt[WarlockWeight,${UIElement[WarlockWeight@Heal@Pages@ClassGUI].Value}]
				break
			case WarriorWeight
				Class:SetUseInt[WarriorWeight,${UIElement[WarriorWeight@Heal@Pages@ClassGUI].Value}]
				break
			case PWF
				Class:SetUse[PWF,${UIElement[PWF@Buffs@Pages@ClassGUI].Checked}]
				break
			case ShadowProt
				Class:SetUse[ShadowProt,${UIElement[ShadowProt@Buffs@Pages@ClassGUI].Checked}]
				break
			case DivineSpirit
				Class:SetUse[DivineSpirit,${UIElement[DivineSpirit@Buffs@Pages@ClassGUI].Checked}]
				break
			case UseCandles
				Class:SetUse[UseCandles,${UIElement[UseCandles@Buffs@Pages@ClassGUI].Checked}]
				break
			case InnerFire
				Class:SetUse[InnerFire,${UIElement[InnerFire@Buffs@Pages@ClassGUI].Checked}]
				break
			case Shadowform
				Class:SetUse[Shadowform,${UIElement[Shadowform@Buffs@Pages@ClassGUI].Checked}]
				break
			case FearWard
				Class:SetUse[FearWard,${UIElement[FearWard@Buffs@Pages@ClassGUI].Checked}]
				break
			case Shield
				Class:SetUse[Shield,${UIElement[Shield@Buffs@Pages@ClassGUI].Checked}]
				break
			case ShieldMyHP
				Class:SetUseInt[ShieldMyHP,${UIElement[ShieldMyHP@Buffs@Pages@ClassGUI].Value}]
				break
			case ShieldMobHP
				Class:SetUseInt[ShieldMobHP,${UIElement[ShieldMobHP@Buffs@Pages@ClassGUI].Value}]
				break
			case PainSup
				Class:SetUse[PainSup,${UIElement[PainSup@Buffs@Pages@