objectdef oClass inherits oBase
{
	/************ VARIABLES ***************/

	variable bool UsePull = TRUE
	variable string PullSpell = "None"
	variable int RestHP = 50
	variable int RestMP = 50
	variable int StandHP = 100
	variable int StandMP = 100
	variable string EarthTotem = ""
	variable string FireTotem = ""
	variable string AirTotem = ""
	variable string WaterTotem = ""
	variable bool UseEarthElemental = FALSE
	variable bool UseFireElemental = FALSE
	variable bool EarthbindRunners = FALSE
	variable bool UseEarthShock = FALSE
	variable bool UseFlameShock = FALSE
	variable bool UseFrostShock = FALSE
	variable bool FrostShockRunners = FALSE
	variable bool RandomShock = FALSE
	variable int ConserveMana = 40
	variable bool UseLBolt = FALSE
	variable bool UseChainLight = FALSE
	variable string MainHand = "None"
	variable string OffHand = "None"
	variable string Shield = "None"
	variable bool ShieldOnPull = FALSE
	variable bool DW = FALSE
	variable int HealWave = 20
	variable int LHealWave = 50
	variable int ChainHeal = 50
	variable int GOTN = 60
	variable bool Output = TRUE
	variable bool Flee = TRUE
	variable int MaxCastRange = 30
	variable int MaxShockRange = 20
	variable bool HookFlee = FALSE
	variable bool HasEarthTotem = FALSE
	variable bool HasFireTotem = FALSE
	variable bool HasWaterTotem = FALSE
	variable bool HasWindTotem = FALSE
	variable bool UseHPot = FALSE
	variable bool UseMPot = FALSE
	variable bool UseBandages = FALSE
	variable int HPot = 25
	variable int MPot = 25
	variable int Bandage = 25
	variable int restWaitTimer = 0
	variable int buffWaitTimer = 0
	variable int PotTimer = 0
	variable int DangerMedium               = 15
	variable int DangerHigh                 = 30
	variable int DangerVeryHigh             = 45
	variable int DangerLevel                = 0
	variable int Dangerlvl                  = 0
	variable int BuffNum										= 0
	variable bool Fleeing                   = FALSE
	variable bool debuffStatus							= FALSE
	variable string RealmChar								= "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
	variable bool MeleeOnly = FALSE


	method RestPulse()
	{
		if ${Movement.Speed}
		{
			Toon:Stop
		}
		if ${This.ShouldCallTotems}
		{
			Toon:CastSpell["Totemic Call"]
			This:CustOutput["Calling my totems back"]
			return
		}
		if !${Consumable.HasFood} && ${Me.PctHPs} < ${StandHP} && ${Toon.canCast[Healing Wave]} && !${Me.Buff[Drink](exists)}
		{
			Toon:CastSpell[Healing Wave]
			This:CustOutput["Casting Healing Wave - Rest"]
			return
		}
		if ${Me.PctHPs} < ${This.Bandage} && ${Toon.canBandage} && !${Me.Sitting} && ${This.UseBandages}
		{
			Toon:Bandage
			This:CustOutput["Bandaging...."]
			return
		}
		if ${Me.PctHPs} < ${This.RestHP} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)} && !${Me.Casting}
		{
			Consumable:useFood
			This:CustOutput["Eating..."]
			return
		}
		if ${Me.PctMana} < ${This.RestMP} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Casting}
		{
			Consumable:useDrink
			This:CustOutput["Drinking..."]
			return
		}
		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			Toon:Sitdown
			This:CustOutput["I've got Resurrection Sickness. Sittin the fuck down."]
			return
		}
		if ${Me.PctMana} >= ${This.StandMP} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Me.Casting} && !${Me.Buff[Resurrection Sickness](exists)}
		{
			Toon:Standup
			This:CustOutput["Done Resting!"]
			return
		}		
	}
	member NeedRest()
	{
		if ${Me.InCombat} || ${Targeting.realAgg}
		{
			return FALSE
		}
		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${This.RestHP} && !${Me.Buff[Food](exists)} && !${Me.Casting}
		{
			return TRUE
		}
		if ${Me.PctMana} < ${This.RestMP} && !${Me.Buff[Drink](exists)} && !${Me.Casting}
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${This.StandHP} && ${Me.Sitting}
		{
			return TRUE
		}
		if ${Me.PctMana} < ${This.StandMP} && ${Me.Sitting}
		{
			return TRUE
		}
		if ${This.ShouldCallTotems}
		{
			return TRUE
		}
		return FALSE
	}
	
	member NeedBuff()
	{
		if ${Toon.canUseScroll}
		{
			return TRUE
			This:CustOutput["Need a scroll buff"]
		}
		if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast["${This.MainHand} Weapon"]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
		{
			return TRUE
			This:CustOutput["Need Mainhand Buff - ${This.MainHand}"]
		}
		if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast["${This.OffHand} Weapon"]} && ${This.DW} && !${This.OffHand.Equal[None]}
		{
			return TRUE
			This:CustOutput["Need Offhand Buff - ${This.OffhHand}"]
		}
		if ${This.canBuff[${This.Shield}]}
		{
			return TRUE
		}
		return FALSE
	}
	method BuffPulse()
	{
		Toon:Standup
		if ${Movement.Speed}
		{
			Toon:Stop
			return
		}
		if ${Toon.canUseScroll}
		{
			Toon:UseScroll
			This:CustOutput["Using a scroll"]
			return
		}
		if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast[${This.MainHand} Weapon]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
		{
			Toon:CastSpell[${This.MainHand} Weapon]
			This:CustOutput["Casting ${This.MainHand} Weapon"]
			This.buffWaitTimer:Set[${This.InSeconds[20]}]
			return
		}
		if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast[${This.OffHand} Weapon]} && ${This.DW} && !${This.OffHand.Equal[None]}
		{
			Toon:CastSpell[${This.OffHand} Weapon]
			This:CustOutput["Casting ${This.OffHand} Weapon"]
			return
		}
		if ${This.canBuff[${This.Shield}]}
		{
			Toon:CastSpell[${This.Shield}]
			return
		}
	}
	
	member NeedPullBuff()
	{
		if ${This.ShieldOnPull} && ${This.canBuff[${This.Shield}]}
		{
			return TRUE
		}

		if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem}
		{
			return TRUE
		}
		if ${This.canCastTotem[Air]} && ${This.HasAirTotem}
		{
			return TRUE
		}
		if ${This.canCastTotem[Fire]} && ${This.HasFireTotem}
		{
			return TRUE
		}
		if ${This.canCastTotem[Water]} && ${This.HasWaterTotem}
		{
			return TRUE
		}

		if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem}
		{
			return TRUE
		}
		if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem}
		{
			return TRUE
		}
		if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem}
		{
			return TRUE
		}
		if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem}
		{
			return TRUE
		}
		return FALSE
	}
	method PullBuffPulse()
	{
		Toon:Standup
		if ${Movement.Speed}
		{
			Toon:Stop
		}
		if ${This.ShieldOnPull} && ${This.canBuff[${This.Shield}]}
		{
			Toon:CastSpell[${Shield}]
			This:CustOutput["Casting ${This.Shield}"]
			return
		}
		if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem}
		{
			Toon:CastSpell[${This.EarthTotem}]
			This:CustOutput["Casting ${This.EarthTotem}"]
			This:SetTotemXY[Earth]
			return
		}
		if ${This.canCastTotem[Air]} && ${This.HasAirTotem}
		{
			Toon:CastSpell[${This.AirTotem}]
			This:CustOutput["Casting ${This.AirTotem}"]
			This:SetTotemXY[Air]
			return
		}
		if ${This.canCastTotem[Fire]} && ${This.HasFireTotem}
		{
			Toon:CastSpell[${This.FireTotem}]
			This:CustOutput["Casting ${This.FireTotem}"]
			This:SetTotemXY[Fire]
			return
		}
		if ${This.canCastTotem[Water]} && ${This.HasWaterTotem}
		{
			Toon:CastSpell[${This.WaterTotem}]
			This:CustOutput["Casting ${This.WaterTotem}"]
			This:SetTotemXY[Water]
			return
		}
		if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem}
		{
			Toon:CastRandom[AirTotems]
			This:CustOutput["Casting a random Air Totem"]
			This.AirTotemTimer:Set[${This.InSeconds[80]}]
			This:SetTotemXY[Air]
			return
		}
		if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem}
		{
			Toon:CastRandom[EarthTotems]
			This:CustOutput["Casting a random Earth Totem"]
			This.EarthTotemTimer:Set[${This.InSeconds[80]}]
			This:SetTotemXY[Earth]
			return
		}
		if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem}
		{
			Toon:CastRandom[WaterTotems]
			This:CustOutput["Casting a random Water Totem"]
			This.WaterTotemTimer:Set[${This.InSeconds[80]}]
			This:SetTotemXY[Water]
			return
		}
		if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem}
		{
			Toon:CastRandom[FireTotems]
			This:CustOutput["Casting a random Fire Totem"]
			This.FireTotemTimer:Set[${This.InSeconds[80]}]
			This:SetTotemXY[Fire]
			return
		}
		return
	}
	
	member NeedCombatBuff()
	{
		Toon:Standup
		if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]}
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
		{
			return TRUE
		}
		if ${This.canBuff[${This.Shield}]} && ${Target.PctHPs} > 30
		{
			return TRUE
		}
		if ${This.canCastTotem[Fire]} && ${Me.PctMana} > ${This.ConserveMana}
		{
			return TRUE
		}
		if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85
		{
			return TRUE
		}
		if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
		{
			return TRUE
		}
		if ${Toon.canCast[Mana Tide Totem]} && ${Me.PctMana} < 30
		{
			return TRUE
		}
		if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
		{
			return TRUE
		}
		if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
		{
			return TRUE
		}
		return FALSE
	}
	method CombatBuffPulse()
	{
		Toon:Standup

		if ${Toon.canCast[War Stomp]}
		{
			Toon:CastSpell[War Stomp]

			if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Healing Wave]
				This:CustOutput["Casting Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Lesser Healing Wave]
				This:CustOutput["Casting Lesser Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
			{
				Toon:CastSpell[Chain Heal]
				This:CustOutput["Casting Chain Heal"]
			}
		}
		elseif ${Toon.canCast["Nature's Swiftness"]}
		{
			Toon:CastSpell["Nature's Swiftness"]

			if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Healing Wave]
				This:CustOutput["Casting Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Lesser Healing Wave]
				This:CustOutput["Casting Lesser Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
			{
				Toon:CastSpell[Chain Heal]
				This:CustOutput["Casting Chain Heal"]
			}
		}
		else
		{
			if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Healing Wave]
				This:CustOutput["Casting Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Healing Wave]}
			{
				Toon:CastSpell[Lesser Healing Wave]
				This:CustOutput["Casting Lesser Healing Wave"]
			}
			if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]}
			{
				Toon:CastSpell[Chain Heal]
				This:CustOutput["Casting Chain Heal"]
			}
		}
		if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]}
		{
			Toon:CastSpell[Gift of the Naaru]
			This:CustOutput["Casting Gift of the Naaru"]
		}
		if ${This.canBuff[${This.Shield}, ${Me.GUID}]} && ${Target.PctHPs} > 30 && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastSpell[${Shield}]
			This:CustOutput["Casting ${Shield}"]
		}
		if ${This.canCastTotem[Fire]} && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastSpell[${This.FireTotem}]
			This:CustOutput["Casting ${This.FireTotem}"]
			This:SetTotemXY[Fire]
		}
		if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85
		{
			Toon:CastSpell[Shamanistic Rage]
			This:CustOutput["Casting Shamanistic Rage!!!"]
		}
		if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
		{
			Toon:CastSpell[Elemental Mastery]
			This:CustOutput["Casting Elemental Mastery!!!"]
		}
		if ${Toon.canCast[Mana Tide Totem]} && ${Me.PctMana} < 30
		{
			Toon:CastSpell[Mana Tide Totem]
			This:CustOutput["Casting Mana Tide Totem!!!"]
		}
		if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
		{
			Toon:CastSpell[Heroism]
			This:CustOutput["Casting Heroism!!!"]
		}
		if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
		{
			Toon:CastSpell[Bloodlust]
			This:CustOutput["Casting Bloodlust!!!"]
		}
	}
	
	method PullPulse()
	{
		Toon:Standup
		Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		if ${Target.Classification.Equal[Elite]}
		{
			This:CustOutput["Target is elite. Blacklisting."]
			GlobalBlacklist:Insert[${Target.GUID},3600000]
			WoWScript ClearTarget()
			move -stop
			return
		}
		if !${Toon.ValidTarget[${Target.GUID}]}
    {
    	This:CustOutput["I need a target"]
      Toon:NeedTarget[1]
      return
    }
    if !${Toon.TargetIsBestTarget}
    {
    	This:CustOutput["Target is no longer best target, aquire new target."]
      Toon:BestTarget
      return
    }
    if ${This.UsePull}
    {
    	Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			if ${Target.Distance} > ${This.MaxCastRange}
			{
				This:CustOutput["Target too far away. Moving closer."]
				WoWPress -hold moveforward
			}
			if ${Target.Distance} <= ${Math.Calc[${This.MaxCastRange}-5]}
			{
				Toon:Stop
			}
			if ${Toon.canCast[${This.PullSpell}]} && ${Target.Distance} <= ${Math.Calc[${This.MaxCastRange}-5]}
			{
				Toon:Stop
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				Toon:CastSpell[${This.PullSpell}]
				This:CustOutput["Pulling With: ${This.PullSpell}"]
				return
			}
		}
		if !${This.UsePull}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			if !${Toon.withinMelee[TRUE]}
			{
				Toon:ToMelee
				This:CustOutput["Melee Pulling ${Target.Name}"]
				return
			}
		}
		if !${Me.Attacking}
		{
			WoWScript AttackTarget()
			This:CustOutput["Turning on autoattack"]
			return
		}
		if ${Me.InCombat} && !${Me.Casting}
		{
			This:CustOutput["Shit, can't pull now. Going into AttackPulse"]
			This:AttackPulse
			return
		}
		return
	}
	
	method AttackPulse()
	{
		Toon:Standup

		Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		if ${This.Flee}
		{
			This:SetDanger
			if ${Fleeing}
			{
				This:CustOutput[${ShowOutput}, "Attack - Fleeing"]
				Toon:Flee
				return
			}
			variable guidlist Aggros
			Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-40]
			if ${Dangerlvl} >= 3 && !${Fleeing} && ${Math.Distance[${Me.X},${Me.Y},${SafeX},${SafeY}]} > 20 && (${SafeX} != 0 && ${SafeY} != 0 && ${SafeZ} != 0)
			{
				Fleeing:Set[TRUE]
				This:CustOutput[${ShowOutput}, "Attack - So screwed - trying to run away"]
				GlobalBlacklist:Insert[${Target.GUID},3600000]
				return
			}
		}
		This:debuffAll
		if !${Toon.ValidTarget[${Target.GUID}]}
		{
			Toon:Stop
			This:CustOutput["I need a target"]
			Toon:NeedTarget[1]
			return
		}
		if !${Me.Attacking}
		{
			WoWScript AttackTarget()
			This:CustOutput["Turning on autoattack"]
		}
		if ${Target.Distance} < ${Toon.MinMelee}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Navigator:MoveBackward[500]
		}
		if ${Target.Distance} > ${This.MaxShockRange}
		{
			WoWPress -hold moveforward
		}
		if ${Target.Distance} < ${This.MaxShockRange} && ${This.UsePull}
		{
			Toon:Stop
		}
		if ${Target.PctHPs} < 40 && !${Target.Target(exists)}
		{
			if ${Toon.canCast[Frost Shock]} && ${This.FrostShockRunners}
			{
				Toon:CastSpell[Frost Shock]
				This:CustOutput["Casting Frost Shock on a runner"]
				return
			}
			if ${Toon.canCast[Earthbind Totem]} && ${This.EarthbindRunners} && !${This.OwnedTotemsCheck[Earthbind Totem]} && ${This.HasEarthTotem}
			{
				Toon:CastSpell[Earthbind Totem]
				This:CustOutput["Casting Earthbind Totem to catch a runner"]
				return
			}
		}
		if ${Me.PctHPs} < ${This.HPot} && ${This.UseHPot} && ${Consumable.HasHPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
		{
			Consumable:useHPot
			This:CustOutput["Quaffing a health pot"]
			This.PotTimer:Set[${This.InSeconds[120]}]
			return
		}
		if ${Me.PctMana} < ${This.MPot} && ${This.UseMPot} && ${Consumable.HasMPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
		{
			Consumable:useMPot
			This:CustOutput["Quaffing a mana pot"]
			This.PotTimer:Set[${This.InSeconds[120]}]
			return
		}
		if ${Toon.DetectAdds[${Target.GUID},1,10]} && ${Toon.canCast[Chain Lightning]} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
		{
			Toon:CastSpell[Chain Lightning]
			This:CustOutput["Casting Chain Lightning due to an add!"]
			return
		}
		if ${This.RandomShock} && ${Me.PctMana} > 15 && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastRandom[Shocks,"Target"]
			This:CustOutput["Casting a random shock on ${Target.Name}"]
		}
		if ${This.canBuff[Flame Shock, ${Target.GUID}]} && ${This.UseFlameShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastSpell[Flame Shock]
			This:CustOutput["Casting Flame Shock"]
			return
		}
		if ${Toon.canCast[Earth Shock]} && ${This.UseEarthShock} && !${This.RandomShock} && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastSpell[Earth Shock]
			This:CustOutput["Casting Earth Shock"]
			return
		}
		if ${Toon.canCast[Stormstrike]} && !${Target.Buff[Stormstrike](exists)}
		{
			Toon:CastSpell[Stormstrike]
			This:CustOutput["Casting Stormstrike"]
			return
		}
		if ${Toon.canCast[Earth Shock]} && ${Target.Buff[Stormstrike](exists)}
		{
			Toon:CastSpell[Earth Shock]
			This:CustOutput["Casting Earth Shock on Stormstrike'd ${Target}!"]
			return
		}
		if ${Toon.canCast[Frost Shock]} && ${This.UseFrostShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Me.PctMana} > ${This.ConserveMana}
		{
			Toon:CastSpell[Frost Shock]
			This:CustOutput["Casting Frost Shock"]
			return
		}
		if ${Toon.canCast[Earth Shock,1]} && ${Target.Casting(exists)}
		{
			This:StopCast
			This:CustOutput["Silencing ${Target} - Attack"]
			Toon:CastSpell[Earth Shock,1]
		}
		if ${Toon.canCast[Lightning Bolt]} && ${This.UseLBolt} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
		{
			Toon:CastSpell[Lightning Bolt]
			This:CustOutput["Casting Lightning Bolt"]
			return
		}
	}
	
	member NeedDead()
	{
		if ${This.CanUseAnkh}
		{
			return TRUE
		}
		return FALSE
	}
	method DeadPulse()
	{
		if ${This.CanUseAnkh}
		{
			WoWScript UseSoulstone()
		}
		return
	}

	member NeedCombatIdle()
	{
		variable guidlist TotemAggro
		TotemAggro:Search[-units,-totems,-notowner,-nearest,-range 0-20]
		if ${TotemAggro.Count} > 0
		{
			return TRUE
		}
		return FALSE
	}
	method CombatIdle()
	{
		variable guidlist TotemAggro
		TotemAggro:Search[-units,-totems,-notowner,-nearest,-range 0-20]
		if ${TotemAggro.Count} > 0
		{
			Target ${TotemAggro.Object[1].GUID}
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:AutoAttack
			return
		}
		else
		{
			This:AttackPulse
			return
		}
		return
	}



	member canCastTotem(string totemType)
	{
		if ${Toon.canCast[${This.${totemType}Totem}]} && !${This.OwnedTotemsCheck[${This.${totemType}Totem}]} && !${This.${totemType}Totem.Equal["Random"]} && !${This.${totemType}Totem.Equal["None"]}
		{
			return TRUE
		}
		return FALSE
	}
	member CanUseAnkh()
	{
		if ${Spell[Reincarnation](exists)} && !${Spell[Reincarnation].Cooldown}
		{
			if ${Navigator.PointIsSafe[${Me.X},${Me.Y},${Me.Z}]}
			{
				AnkhList:Search[-items,-inventory, "Ankh"]
				if ${AnkhList.Count} >= 1
				{
					This:CustOutput["We can use Reincarnation here. Popping back up to kick some ass!"]
					return TRUE
				}
				else
				{
					This:CustOutput["No ankhs! Can't self res ;_;"]
					return FALSE
				}
			}
			This:CustOutput["Not a safe spot to use Reincarnation. Corpse running instead"]
			return FALSE
		}
		return FALSE
	}
	member OwnedTotemsCheck(string totem)
	{
		if ${Unit[-units, -owner, -range 0-20, ${totem}](exists)}
		{
			return TRUE
			TotemList:Clear
		}
		return FALSE
	}
	member ShouldCallTotems()
	{
		if ${This.OwnedTotemsCheck[totem]} && !${Me.Target(exists)} && ${Toon.canCast[Totemic Call]}
		{
			return TRUE
		}
		return FALSE
	}
	method SetDanger()
	{
		variable guidlist Aggros
		Aggros:Search[-units,-nearest,-aggro,-alive,-targetingme,-range 0-40]

		This.DangerLevel:Set[${DangerLevel} * 0.5]
		This.DangerLevel:Set[${DangerLevel} + ${Aggros.Count}*6.5]
		This.DangerLevel:Set[${DangerLevel} + ((100 - ${Me.PctMana})*0.10)]
		if ${Target.Level} > ${Me.Level}
		{
			This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*2)]
		}

		elseif ${Me.Level} > ${Target.Level}
		{
			This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*1)]
		}

		if ${Target.Classification.Equal[Elite]} || ${Target.Classification.Equal[RareElite]}
		{
			This.DangerLevel:Set[${DangerLevel} + 20]
		}

		if ${Target.PctHPs} < 25
		{
			This.DangerLevel:Set[${DangerLevel} - 10]
		}

		if ${DangerLevel} < 0
		{
			This.DangerLevel:Set[0]
		}
		UIElement[DangerLevel@Titlebar@ClassGUI]:SetValue[${DangerLevel}]
		if ${DangerLevel} >= ${DangerVeryHigh}
		{
			This:CustOutput[${ShowOutput}, "Danger - Very High ${DangerLevel}"]
			This.Dangerlvl:Set[3]
			return
		}

		elseif ${DangerLevel} > ${DangerHigh}
		{
			This:CustOutput[${ShowOutput}, "Danger - High ${DangerLevel}"]
			This.Dangerlvl:Set[2]
			return
		}

		elseif ${DangerLevel} > ${DangerMedium}
		{
			;This:CustOutput[${ShowOutput}, "Danger - Medium ${DangerLevel}"]
			This.Dangerlvl:Set[1]
			return
		}

		else
		{
			;This:CustOutput[${ShowOutput}, "Danger - Low ${DangerLevel}"]
			This.Dangerlvl:Set[0]
			return
		}
	}
	member ShouldConserveMana()
	{
		if ${Me.PctMana} > ${This.ConserveMana}
		{
			return TRUE
		}
		return FALSE
	}
	method SetRandoms(string SpellName, string RandomSet)
	{
		if ${Spell[${SpellName}](exists)}
		{
			Toon:AddRandom[${RandomSet},${SpellName}]
		}
		else
		{
			This:CustOutput["Couldn't add ${SpellName} into ${RandomSet} because we don't have the spell!"]
		}
	}
	method InitRandoms()
	{
		This:SetRandoms["Earth Shock","Shocks"]
		This:SetRandoms["Flame Shock","Shocks"]
		This:SetRandoms["Frost Shock","Shocks"]
		This:SetRandoms["Lightning Bolt","Attacks"]
		This:SetRandoms["Chain Lightning","Attacks"]
		This:SetRandoms["Lightning Shield","Shields"]
		This:SetRandoms["Water Shield","Shields"]
		This:SetRandoms["Earth Shield","Shields"]
		This:SetRandoms["Earthbind Totem","EarthTotems"]
		This:SetRandoms["Stoneskin Totem","EarthTotems"]
		This:SetRandoms["Stoneclaw Totem","EarthTotems"]
		This:SetRandoms["Strength of Earth Totem","EarthTotems"]
		This:SetRandoms["Tremor Totem","EarthTotems"]
		This:SetRandoms["Searing Totem","FireTotems"]
		This:SetRandoms["Fire Nova Totem","FireTotems"]
		This:SetRandoms["Magma Totem","FireTotems"]
		This:SetRandoms["Totem of Wrath","FireTotems"]
		This:SetRandoms["Windwall Totem","AirTotems"]
		This:SetRandoms["Grounding Totem","AirTotems"]
		This:SetRandoms["Grace of Air Totem","AirTotems"]
		This:SetRandoms["Wrath of Air Totem","AirTotems"]
		This:SetRandoms["Healing Stream Totem","WaterTotems"]
		This:SetRandoms["Mana Spring Totem","WaterTotems"]
	}
	method SetTotems()
	{
		if ${Item[-items,-inventory,"Earth Totem"](exists)}
		{
			This.HasEarthTotem:Set[TRUE]
			This:CustOutput["We have an Earth Totem in our bags, we can use them now!"]
		}
		else
		{
			This.HasEarthTotem:Set[FALSE]
			This:CustOutput["No Earth Totem found! Not using them."]
		}

		if ${Item[-items,-inventory,"Fire Totem"](exists)}
		{
			This.HasFireTotem:Set[TRUE]
			This:CustOutput["We have an Fire Totem in our bags, we can use them now!"]
		}
		else
		{
			This.HasFireTotem:Set[FALSE]
			This:CustOutput["No Fire Totem found! Not using them."]
		}

		if ${Item[-items,-inventory,"Water Totem"](exists)}
		{
			This.HasWaterTotem:Set[TRUE]
			This:CustOutput["We have an Water Totem in our bags, we can use them now!"]
		}
		else
		{
			This.HasWaterTotem:Set[FALSE]
			This:CustOutput["No Water Totem found! Not using them."]
		}

		if ${Item[-items,-inventory,"Wind Totem"](exists)}
		{
			This.HasWindTotem:Set[TRUE]
			This:CustOutput["We have an Wind Totem in our bags, we can use them now!"]
		}
		else
		{
			This.HasWindTotem:Set[FALSE]
			This:CustOutput["No Wind Totem found! Not using them."]
		}
		return
	}
	method SetFleeHook()
	{
		if ${This.Flee}
		{
			This.HookFlee:Set[TRUE]
		}
		else
		{
			This.HookFlee:Set[FALSE]
		}
		return
	}
	method FleePulse()
	{
		if ${Flee.Avoiding} && !${Mount.IsMounted}
		{
			if ${Me.InCombat} && ${Toon.canCast[Earth Elemental Totem]}
			{
				Toon:CastSpell[Earth Elemental Totem]
				return
			}
			else
			{
				Toon:CastSpell[Stoneclaw Totem]
				return
			}

			if ${Me.InCombat} && ${Toon.canCast[Ghost Wolf]}
			{
				Toon:CastSpell[Ghost Wolf]
				return
			}
		}
		if ${Me.Attacking}
		{
			WoWScript AttackTarget()
			return
		}
	}
	member GetSpellRange(int base, string spellTree)
	{
		if ${spellTree.Equal[elemental]}
		{
			return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Storm Reach]}))-1].Round}
		}
		return ${base}
	}
	method SetDistances()
	{
		if  ${This.GetSpellRange[30, "elemental"]}
		{
			This.MaxCastRange:Set[${This.GetSpellRange[30, "elemental"]}]
			This:CustOutput["Setting New MaxRange to ${This.MaxCastRange}"]
			This.MaxShockRange:Set[${This.GetSpellRange[20, "elemental"]}]
			This:CustOutput["Setting New MaxShockRange to ${This.MaxShockRange}"]
		}
	}
	method CustOutput(bool xOutput, string myMessage)
	{
		if ${xOutput}
			{
				UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"]
			}
		return
	}
	method debuffAll()
	{
		if ${Me.PctMana} < 15 || ${Me.Casting}
		{
			return
		}
		BuffNum:Inc
		if ${BuffNum} > 15
		{
			BuffNum:Set[1]
		}
		if !${Target.Buff[${BuffNum}].Harmful} && ${Target.Buff[${BuffNum}].DispelType.Equal[Magic]}
		{
			debuffStatus:Set[TRUE]
			if ${Toon.canCast[Purge]}
			{
				This:CustOutput["Purging a buff on ${Target}"]
				Toon:CastSpell[Purge]
				debuffStatus:Set[FALSE]
				return
			}
		}
		if ${Me.Buff[${BuffNum}].Harmful}
		{
			debuffStatus:Set[TRUE]
			if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
			{
				if  ${Toon.canCast[Cure Disease]}
				{
					This:CustOutput["Curing a disease"]
					Toon:CastSpell[Cure Disease]
					debuffStatus:Set[FALSE]
					return
				}
			}
			if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]}
			{
				if  ${Toon.canCast[Cure Poison]}
				{
					This:CustOutput["Curing a poison"]
					Toon:CastSpell[Cure Poison]
					debuffStatus:Set[FALSE]
					return
				}
			}
			return
		}
	}
	member canBuff(string buffName, string theGUID=NULL,  string spellName=NULL)
	{
		if ${spellName.Equal[NULL]}
		{
			spellName:Set[${buffName}]
		}
		if ${theGUID.Equal[NULL]}
		{
			theGUID:Set[${Me.GUID}]
		}
		if !${Object[${theGUID}].Buff[${buffName}](exists)} && ${Toon.canCast[${spellName}]}
		{
			return TRUE
		}
		return FALSE
	}
	member detectMobAdd()
	{
		if ${Config.GetCheckBox[chkRangePullOnDetectAdds]}
		{
			if ${Toon.DetectAdds[${Target.GUID}, 1, ${Config.GetSlider[sldRangePullOnDetectAddsRadius]}]}
			{
				return TRUE
			}
		}
		return FALSE
	}
	method CustOutput(string myMessage)
	{
		if ${This.Output}
		{
			UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"]
		}
		return
	}


	method Initialize()
	{
		This:LoadConfig
		This:InitShamanGUI

		if ${Me.Action[Gift of the Naaru].Usable}
		{
			UIElement -toggle GOTN@Heals@Pages@ClassGUI
			UIElement -toggle lblGOTN@Heals@Pages@ClassGUI
		}

		This:SetDistances
		This:SetFleeHook
		This:SetTotems
		This:InitRandoms

		UIElement[ClassGUI].FindChild[Console]:Echo["================================="]
		UIElement[ClassGUI].FindChild[Console]:Echo["               Apoc's Shaman Routine v1.1"]
		UIElement[ClassGUI].FindChild[Console]:Echo["================================="]
	}
	method Shutdown()
	{
		This:SaveConfig
	}
	method SaveConfig()
	{
			Config:SetSetting["${RealmChar}","UsePull",${This.UsePull}]
			Config:SetSetting["${RealmChar}","PullSpell",${This.PullSpell}]
			Config:SetSetting["${RealmChar}","RestMP",${This.RestMP}]
			Config:SetSetting["${RealmChar}","RestHP",${This.RestHP}]
			Config:SetSetting["${RealmChar}","StandMP",${This.StandMP}]
			Config:SetSetting["${RealmChar}","StandHP",${This.StandHP}]
			Config:SetSetting["${RealmChar}","EarthTotem",${This.EarthTotem}]
			Config:SetSetting["${RealmChar}","AirTotem",${This.AirTotem}]
			Config:SetSetting["${RealmChar}","FireTotem",${This.FireTotem}]
			Config:SetSetting["${RealmChar}","WaterTotem",${This.WaterTotem}]
			Config:SetSetting["${RealmChar}","UseEarthElemental",${This.UseEarthElemental}]
			Config:SetSetting["${RealmChar}","UseFireElemental",${This.UseFireElemental}]
			Config:SetSetting["${RealmChar}","EarthbindRunners",${This.EarthbindRunners}]
			Config:SetSetting["${RealmChar}","UseEarthShock",${This.UseEarthShock}]
			Config:SetSetting["${RealmChar}","UseFlameShock",${This.UseFlameShock}]
			Config:SetSetting["${RealmChar}","UseFrostShock",${This.UseFrostShock}]
			Config:SetSetting["${RealmChar}","FrostShockRunners",${This.FrostShockRunners}]
			Config:SetSetting["${RealmChar}","RandomShock",${This.RandomShock}]
			Config:SetSetting["${RealmChar}","ConserveMana",${This.ConserveMana}]
			Config:SetSetting["${RealmChar}","UseLBolt",${This.UseLBolt}]
			Config:SetSetting["${RealmChar}","UseChainLight",${This.UseChainLight}]
			Config:SetSetting["${RealmChar}","MainHand",${This.MainHand}]
			Config:SetSetting["${RealmChar}","OffHand",${This.OffHand}]
			Config:SetSetting["${RealmChar}","DW",${This.DW}]
			Config:SetSetting["${RealmChar}","ShieldOnPull",${This.ShieldOnPull}]
			Config:SetSetting["${RealmChar}","HealWave",${This.HealWave}]
			Config:SetSetting["${RealmChar}","LHealWave",${This.LHealWave}]
			Config:SetSetting["${RealmChar}","ChainHeal",${This.ChainHeal}]
			Config:SetSetting["${RealmChar}","GOTN",${This.GOTN}]
			Config:SetSetting["${RealmChar}","Output",${This.Output}]
			Config:SetSetting["${RealmChar}","Flee",${This.Flee}]
			Config:SetSetting["${RealmChar}","UseMPot",${This.UseMPot}]
			Config:SetSetting["${RealmChar}","UseHPot",${This.UseHPot}]
			Config:SetSetting["${RealmChar}","UseBandages",${This.UseBandages}]
			Config:SetSetting["${RealmChar}","MPot",${This.MPot}]
			Config:SetSetting["${RealmChar}","HPot",${This.HPot}]
			Config:SetSetting["${RealmChar}","Bandage",${This.Bandage}]
			Config:SetSetting["${RealmChar}","Shield",${This.Shield}]
			Config:SetSetting["${RealmChar}","MeleeOnly",${This.MeleeOnly}]
	}
	method LoadConfig()
	{
		This.UsePull:Set[${Config.GetSetting["${RealmChar}","UsePull"]}]
		This.PullSpell:Set[${Config.GetSetting["${RealmChar}","PullSpell"]}]
		This.RestMP:Set[${Config.GetSetting["${RealmChar}","RestMP"]}]
		This.RestHP:Set[${Config.GetSetting["${RealmChar}","RestHP"]}]
		This.StandMP:Set[${Config.GetSetting["${RealmChar}","StandMP"]}]
		This.StandHP:Set[${Config.GetSetting["${RealmChar}","StandHP"]}]
		This.EarthTotem:Set[${Config.GetSetting["${RealmChar}","EarthTotem"]}]
		This.AirTotem:Set[${Config.GetSetting["${RealmChar}","AirTotem"]}]
		This.WaterTotem:Set[${Config.GetSetting["${RealmChar}","WaterTotem"]}]
		This.FireTotem:Set[${Config.GetSetting["${RealmChar}","FireTotem"]}]
		This.UseEarthElemental:Set[${Config.GetSetting["${RealmChar}","UseEarthElemental"]}]
		This.UseFireElemental:Set[${Config.GetSetting["${RealmChar}","UseFireElemental"]}]
		This.EarthbindRunners:Set[${Config.GetSetting["${RealmChar}","EarthbindRunners"]}]
		This.UseEarthShock:Set[${Config.GetSetting["${RealmChar}","UseEarthShock"]}]
		This.UseFlameShock:Set[${Config.GetSetting["${RealmChar}","UseFlameShock"]}]
		This.UseFrostShock:Set[${Config.GetSetting["${RealmChar}","UseFrostShock"]}]
		This.FrostShockRunners:Set[${Config.GetSetting["${RealmChar}","FrostShockRunners"]}]
		This.RandomShock:Set[${Config.GetSetting["${RealmChar}","RandomShock"]}]
		This.ConserveMana:Set[${Config.GetSetting["${RealmChar}","ConserveMana"]}]
		This.UseLBolt:Set[${Config.GetSetting["${RealmChar}","UseLBolt"]}]
		This.UseChainLight:Set[${Config.GetSetting["${RealmChar}","UseChainLight"]}]
		This.MainHand:Set[${Config.GetSetting["${RealmChar}","MainHand"]}]
		This.OffHand:Set[${Config.GetSetting["${RealmChar}","OffHand"]}]
		This.DW:Set[${Config.GetSetting["${RealmChar}","DW"]}]
		This.ShieldOnPull:Set[${Config.GetSetting["${RealmChar}","ShieldOnPull"]}]
		This.HealWave:Set[${Config.GetSetting["${RealmChar}","HealWave"]}]
		This.LHealWave:Set[${Config.GetSetting["${RealmChar}","LHealWave"]}]
		This.ChainHeal:Set[${Config.GetSetting["${RealmChar}","ChainHeal"]}]
		This.GOTN:Set[${Config.GetSetting["${RealmChar}","GOTN"]}]
		This.Output:Set[${Config.GetSetting["${RealmChar}","Output"]}]
		This.Flee:Set[${Config.GetSetting["${RealmChar}","Flee"]}]
		This.UseMPot:Set[${Config.GetSetting["${RealmChar}","UseMPot"]}]
		This.UseHPot:Set[${Config.GetSetting["${RealmChar}","UseHPot"]}]
		This.UseBandages:Set[${Config.GetSetting["${RealmChar}","UseBandages"]}]
		This.MPot:Set[${Config.GetSetting["${RealmChar}","MPot"]}]
		This.HPot:Set[${Config.GetSetting["${RealmChar}","HPot"]}]
		This.Bandage:Set[${Config.GetSetting["${RealmChar}","Bandage"]}]
		This.Shield:Set[${Config.GetSetting["${RealmChar}","Shield"]}]
		This.MeleeOnly:Set[${Config.GetSetting["${RealmChar}","MeleeOnly"]}]
	}
	method InitShamanGUI()
	{

		if ${This.UsePull}
		{
			UIElement[UsePull@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseMPot}
		{
			UIElement[UseMPot@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseHPot}
		{
			UIElement[UseHPot@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseBandages}
		{
			UIElement[UseBandages@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.MeleeOnly}
		{
			UIElement[MeleeOnly@Main@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseEarthElemental}
		{
			UIElement[EarthElemental@Totems@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseFireElemental}
		{
			UIElement[FireElemental@Totems@Pages@ClassGUI]:SetChecked
		}
		if ${This.EarthbindRunners}
		{
			UIElement[EarthbindRunners@Totems@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseEarthShock}
		{
			UIElement[EarthShock@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseFlameShock}
		{
			UIElement[FlameShock@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseFrostShock}
		{
			UIElement[FrostShock@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.FrostShockRunners}
		{
			UIElement[FrostShockRunners@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.RandomShock}
		{
			UIElement[RandomShock@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseLBolt}
		{
			UIElement[LightBolt@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.UseChainLight}
		{
			UIElement[UseChainLight@Spells@Pages@ClassGUI]:SetChecked
		}
		if ${This.DW}
		{
			UIElement[DW@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.ShieldOnPull}
		{
			UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked
		}
		if ${This.Output}
		{
			UIElement[EnableOutput@Other@Pages@ClassGUI]:SetChecked
		}
		if ${This.Flee}
		{
			UIElement[Flee@Other@Pages@ClassGUI]:SetChecked
		}

		variable int i = 1

		for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.PullSpell.Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[EarthTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.EarthTotem.Equal["${UIElement[EarthTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[EarthTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[WaterTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.WaterTotem.Equal["${UIElement[WaterTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[WaterTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[FireTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.FireTotem.Equal["${UIElement[FireTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[FireTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[AirTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.AirTotem.Equal["${UIElement[AirTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[AirTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[MainHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.MainHand.Equal["${UIElement[MainHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[MainHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[OffHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.OffHand.Equal["${UIElement[OffHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[OffHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i} <= ${UIElement[Shield@Buffs@Pages@ClassGUI].Items} ; i:Inc)
		{
			if ${This.Shield.Equal["${UIElement[Shield@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
			{
				UIElement[Shield@Buffs@Pages@ClassGUI]:SelectItem[${i}]
			}
		}






		if ${This.RestMP} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.RestMP}]
		}
		if ${This.RestHP} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value}
		{
			UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.RestHP}]
		}
		if ${This.StandMP} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value}
		{
			UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.StandMP}]
		}
		if ${This.StandHP} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value}
		{
			UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.StandHP}]
		}
		if ${This.ConserveMana} != ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}
		{
			UIElement[ConserveMana@Main@Pages@ClassGUI]:SetValue[${This.ConserveMana}]
		}
		if ${This.MPot} != ${UIElement[MPot@Main@Pages@ClassGUI].Value}
		{
			UIElement[MPot@Main@Pages@ClassGUI]:SetValue[${This.MPot}]
		}
		if ${This.HPot} != ${UIElement[HPot@Main@Pages@ClassGUI].Value}
		{
			UIElement[HPot@Main@Pages@ClassGUI]:SetValue[${This.HPot}]
		}
		if ${This.Bandage} != ${UIElement[Bandage@Main@Pages@ClassGUI].Value}
		{
			UIElement[Bandage@Main@Pages@ClassGUI]:SetValue[${This.Bandage}]
		}
		if ${This.HealWave} != ${UIElement[HealWave@Heals@Pages@ClassGUI].Value}
		{
			UIElement[HealWave@Heals@Pages@ClassGUI]:SetValue[${This.HealWave}]
		}
		if ${This.LHealWave} != ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}
		{
			UIElement[LHealWave@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
		}
		if ${This.ChainHeal} != ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}
		{
			UIElement[ChainHeal@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
		}
		if ${This.GOTN} != ${UIElement[GOTN@Heals@Pages@ClassGUI].Value}
		{
			UIElement[GOTN@Heals@Pages@ClassGUI]:SetValue[${This.GOTN}]
		}
	}
	method ClassGUIChange(string Action)
	{
		switch ${Action}
		{

			case PullSpell
			if ${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.PullSpell:Set[${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}]
			}
			break
			case EarthTotem
			if ${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.EarthTotem:Set[${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem}]
			}
			break
			case FireTotem
			if ${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.FireTotem:Set[${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem}]
			}
			break
			case AirTotem
			if ${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.AirTotem:Set[${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem}]
			}
			break
			case WaterTotem
			if ${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.WaterTotem:Set[${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem}]
			}
			break
			case MainHand
			if ${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.MainHand:Set[${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem}]
			}
			break
			case OffHand
			if ${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.OffHand:Set[${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem}]
			}
			break
			case Shield
			if ${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
			{
				This.Shield:Set[${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem}]
			}
			break


			/*    checkboxes    */


			case UsePull
			if ${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
			{
				This.UsePull:Set[TRUE]
			}
			if !${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
			{
				This.UsePull:Set[FALSE]
			}
			break

			case UseHPot
			if ${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
			{
				This.UseHPot:Set[TRUE]
			}
			if !${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
			{
				This.UseHPot:Set[FALSE]
			}
			break

			case UseMPot
			if ${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
			{
				This.UseMPot:Set[TRUE]
			}
			if !${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
			{
				This.UseMPot:Set[FALSE]
			}
			break

			case UseBandages
			if ${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
			{
				This.UseBandages:Set[TRUE]
			}
			if !${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
			{
				This.UseBandages:Set[FALSE]
			}
			break
			
			case MeleeOnly
			if ${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
			{
				This.MeleeOnly:Set[TRUE]
			}
			if !${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
			{
				This.MeleeOnly:Set[FALSE]
			}
			break

			case EarthElemental
			if ${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
			{
				This.UseEarthElemental:Set[TRUE]
			}
			if !${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
			{
				This.UseEarthElemental:Set[FALSE]
			}
			break

			case FireElemental
			if ${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
			{
				This.UseFireElemental:Set[TRUE]
			}
			if !${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
			{
				This.UseFireElemental:Set[FALSE]
			}
			break

			case EarthbindRunners
			if ${UIElement[EarthbindRunners@Totems@Pages@ClassGUI].Checked}
			{
				This.EarthbindRunners:Set[TRUE]
			}
			if !${UIElement[EarthbindRunners@Totems@Pages@ClassGUI].Checked}
			{
				This.EarthbindRunners:Set[FALSE]
			}
			break

			case FlameShock
			if ${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseFlameShock:Set[TRUE]
			}
			if !${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseFlameShock:Set[FALSE]
			}
			break

			case EarthShock
			if ${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseEarthShock:Set[TRUE]
			}
			if !${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseEarthShock:Set[FALSE]
			}
			break

			case FrostShock
			if ${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseFrostShock:Set[TRUE]
			}
			if !${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
			{
				This.UseFrostShock:Set[FALSE]
			}
			break

			case FrostShockRunners
			if ${UIElement[FrostShockRunners@Spells@Pages@ClassGUI].Checked}
			{
				This.FrostShockRunners:Set[TRUE]
			}
			if !${UIElement[FrostShockRunners@Spells@Pages@ClassGUI].Checked}
			{
				This.FrostShockRunners:Set[FALSE]
			}
			break

			case RandomShock
			if ${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
			{
				This.RandomShock:Set[TRUE]
			}
			if !${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
			{
				This.RandomShock:Set[FALSE]
			}
			break

			case UseLBolt
			if ${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
			{
				This.UseLBolt:Set[TRUE]
			}
			if !${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
			{
				This.UseLBolt:Set[FALSE]
			}
			break

			case UseChainLight
			if ${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
			{
				This.UseChainLight:Set[TRUE]
			}
			if !${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
			{
				This.UseChainLight:Set[FALSE]
			}
			break

			case DW
			if ${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
			{
				This.DW:Set[TRUE]
			}
			if !${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
			{
				This.DW:Set[FALSE]
			}
			break

			case ShieldOnPull
			if ${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
			{
				This.ShieldOnPull:Set[TRUE]
			}
			if !${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
			{
				This.ShieldOnPull:Set[FALSE]
			}
			break

			case EnableOutput
			if ${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
			{
				This.Output:Set[TRUE]
			}
			if !${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
			{
				This.Output:Set[FALSE]
			}
			break

			case Flee
			if ${UIElement[Flee@Other@Pages@ClassGUI].Checked}
			{
				This.Flee:Set[TRUE]
			}
			if !${UIElement[Flee@Other@Pages@ClassGUI].Checked}
			{
				This.Flee:Set[FALSE]
			}
			break




			/*   sliders   */

			case RestMP
			if ${UIElement[RestMP@Main@Pages@ClassGUI].Value(exists)}
			{
				This.RestMP:Set[${UIElement[RestMP@Main@Pages@ClassGUI].Value}]
			}
			break
			case RestHP
			if ${UIElement[RestHP@Main@Pages@ClassGUI].Value(exists)}
			{
				This.RestHP:Set[${UIElement[RestHP@Main@Pages@ClassGUI].Value}]
			}
			break
			case StandHP
			if ${UIElement[StandHP@Main@Pages@ClassGUI].Value(exists)}
			{
				This.StandHP:Set[${UIElement[StandHP@Main@Pages@ClassGUI].Value}]
			}
			break
			case StandMP
			if ${UIElement[StandMP@Main@Pages@ClassGUI].Value(exists)}
			{
				This.StandMP:Set[${UIElement[StandMP@Main@Pages@ClassGUI].Value}]
			}
			break
			case ConserveMana
			if ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value(exists)}
			{
				This.ConserveMana:Set[${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}]
			}
			break
			case MPot
			if ${UIElement[MPot@Main@Pages@ClassGUI].Value(exists)}
			{
				This.MPot:Set[${UIElement[MPot@Main@Pages@ClassGUI].Value}]
			}
			break
			case HPot
			if ${UIElement[HPot@Main@Pages@ClassGUI].Value(exists)}
			{
				This.HPot:Set[${UIElement[HPot@Main@Pages@ClassGUI].Value}]
			}
			break
			case Bandage
			if ${UIElement[Bandage@Main@Pages@ClassGUI].Value(exists)}
			{
				This.Bandage:Set[${UIElement[Bandage@Main@Pages@ClassGUI].Value}]
			}
			break



			case HealWave
			if ${UIElement[HealWave@Heals@Pages@ClassGUI].Value(exists)}
			{
				This.HealWave:Set[${UIElement[HealWave@Heals@Pages@ClassGUI].Value}]
			}
			break
			case LHealWave
			if ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value(exists)}
			{
				This.LHealWave:Set[${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}]
			}
			break
			case ChainHeal
			if ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value(exists)}
			{
				This.ChainHeal:Set[${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}]
			}
			break
			case GOTN
			if ${UIElement[GOTN@Heals@Pages@ClassGUI].Value(exists)}
			{
				This.GOTN:Set[${UIElement[GOTN@Heals@Pages@ClassGUI].Value}]
			}
			break
		}
	}
}