/*
======================================================================
Ritz's Complete Druid Routine; V5.2
----------------------------------------------------------------------
Version 5.2

Bug Fixes

Changes:
» Less Spamming about ranged pulls
» Stopped Double casting of roots/overhealing
» Fixed Moonkin mounting troubles

Issues:
» ?

ToDo:
» Automatic form selection depending on spec
» A GUI. Maybe. If I get really bored.
» More switches for stuff like potions/ranged pulling
» Improve Balance/Low level logic
» Improve trinket handling

======================================================================
*/
objectdef oClass inherits oBase
{
	
	/*	Custom Variables	*/
	variable int RestHP = 50	;Rest if I'm below this HP
	variable int RestMana = 35	;Rest if I'm below this Mana
	variable int HealHP = 35	;Heal if I fall below this HP
	variable int HealToHP = 50	;Once i've started healing, keep going till I get above this %
	variable int LowMana = 15	;Pot/Innervate if I fall below this mana
	variable int CastPrecision = 250	;How good the routine is at timing spells in MS. Lower is more accurate.
	variable bool BarkskinForHeals = TRUE	;Save Barkskin for when you need to heal?
	variable int PullTimer = 15000	;How long in MS before declaring a failed pull
	variable int CureDelay = 10	;How often to check for debuffs to cure. Lower is more often.
	
	
	/*	Forms	*/
	/*	Kitty|Bear|Travel|Moonkin|Caster	*/
	variable string DangerLow = Kitty
	variable string DangerMedium = Bear
	variable string DangerHigh = Bear
	variable string DangerVeryHigh = Travel
	
	/*	Hooks	*/
	variable bool needUIHook = TRUE	;Don't Touch
	variable bool needCombatHook = TRUE	;Don't Touch
	variable bool HookFlee = TRUE	;Don't Touch
	variable collection:string UIErrorMsgStrings
	
	/*	Fixed Variables		*/
	variable int HP = ${Me.PctHPs}
	variable int Mana = ${Me.PctMana}
	variable int CD
	variable string CurrentForm
	variable int CombatStart = ${LavishScript.RunningTime}
	variable bool Healing = FALSE
	variable bool Caster = FALSE
	variable string OldTargetGUID
	variable bool ArcaneImmune
	variable bool NatureImmune
	variable bool BleedImmune
	variable bool RangedPull
	variable int PullTimeOut = 0
	variable int MWait
	
	method Initialize()
	{
		This:Output[======================================================================]
		This:Output[Ritz's Druid routine V5.2 Loaded]
		LavishScript:RegisterEvent[UNIT_MODEL_CHANGED]
		Event[UNIT_MODEL_CHANGED]:AttachAtom[Class:SetCurrentForm]
		Class:SetCurrentForm
		Bot:AddPulse["Class","CureAll",${CureDelay},TRUE,TRUE] 
		Class:CreateUIErrorStrings
		This:Output[======================================================================]
	}

	method CreateUIErrorStrings()
	{
		This.UIErrorMsgStrings:Set["You are facing the wrong way!"]
		This.UIErrorMsgStrings:Set["Target not in line of sight"]
		This.UIErrorMsgStrings:Set["Can't use items while shapeshifted."]
		This.UIErrorMsgStrings:Set["You can't take a taxi while shapeshifted!"]
		This.UIErrorMsgStrings:Set["You are in shapeshift form"]
		This.UIErrorMsgStrings:Set["You are too far away!"]
		This.UIErrorMsgStrings:Set["There is nothing to attack."]
		This.UIErrorMsgStrings:Set["You must be behind your target"]
		This.UIErrorMsgStrings:Set["Invalid target"]
		This.UIErrorMsgStrings:Set["Can only use outside"]
		This.UIErrorMsgStrings:Set["Can't do that while moving"]
		This.UIErrorMsgStrings:Set["You can't mount while shapeshifted."]
		This:Output["UI Error Hooks created"]
	}
	
	method UIErrorMessage(string Id, string Msg)
	{
		if ${This.UIErrorMsgStrings.Element[${Msg}](exists)} && !${Bot.PauseFlag} 
		{
			This:Output[UI Error: ${Msg}]
			if ${Msg.Equal["Can't use items while shapeshifted."]} || ${Msg.Equal["You are in shapeshift form"]} || ${Msg.Equal["You can't take a taxi while shapeshifted!"]} || ${Msg.Equal["You can't mount while shapeshifted."]}
			{
				Class:Shapeshift[Caster]
			}
			if ${Msg.Equal["You must be behind your target"]}
			{
				move forward 100
				if ${Math.Rand[100]} > 50
				{
					move left 300
				}
				else
				{
					move right 300
				}
			}
			if ${Msg.Equal["Target not in line of sight"]}
			{
				if !${Class.MoveWait}
				{
					Toon:ToMelee
				}
			}
			if ${Msg.Equal["Can't do that while moving"]}
			{
				move -stop
				MWait:Set[${LavishScript.RunningTime} + 1500]
				
			}
		}
	}
	
	member DoubleCast()
	{
		if ${Me(unit).Casting.Name.Find["Entangling Roots"]} && ${Class.TargetRooted}
		{
			return TRUE
		}
		if ${Class.IsHeal[${Me(unit).Casting.Name}]}
		{
		if ${Me.InCombat} && ${Me.PctHPs} > ${Math.Calc[${HealToHP}*1.1]}
			{
				return TRUE
			}
			if ${Me.PctHPs} > 95
			{
				return TRUE
			}
		}			
		return FALSE
	}
	
	member NeedRest()
	{
		if !${Me.InCombat}
		{
			CombatStart:Set[${LavishScript.RunningTime}]
		}
		if (${Me.Buff[Drink](exists)} && ${Me.PctMana} < 95) || (${Me.Buff[Food](exists)} && ${Me.PctHPs} < 95)
		{
			return TRUE
		}
		if ${Me.PctHPs} < ${RestHP} || ${Me.PctMana} < ${RestMana}
		{
			return TRUE
		}
		if ${Me.Buff["Ressurection Sickness"](exists)}
		{
			return TRUE
		}
		return FALSE
	}
	
	method RestPulse()
	{
		if ${Class.DoubleCast}
		{
			This:Output["Stopping Double Cast of ${Me(unit).Casting.Name}"]
			Class:StopCasting
		}
		if ${Me.Target(exists)}
		{
			WoWScript ClearTarget()
		}
		if ${Me.Buff["Ressurection Sickness"](exists)} && ${Class.OutputTimer}
		{
			This:Output["Rest - Rez Sickness: Waiting (${Me.Buff["Ressurection Sickness"].Duration.Round})"]
			if !${Class.MoveWait}
			{
				move -stop
			}
			if ${This.Usable["Shadowmeld"]} && ${CurrentForm.Equal["Caster"]}
			{
				Class:Cast[Shadowmeld]
			}
			return
		}
		if (${Me.Buff[Drink](exists)} && ${Me.PctMana} < 95) || (${Me.Buff[Food](exists)} && ${Me.PctHPs} < 95)
		{
			if ${This.Usable["Shadowmeld"]} && ${CurrentForm.Equal["Caster"]}
			{
				Class:Cast[Shadowmeld]
			}
			return
		}
		if ${Class.NeedHeal} || ${Class.NeedMana}
		{
			return
		}
	}

	member NeedBuff()
	{
		if !${Me.Buff["Mark of the Wild"](exists)}
		{
			if ${This.Usable["Mark of the Wild"]}
			{
				return TRUE
			}
		}
		if !${Me.Buff["Thorns"](exists)}
		{
			if ${This.Usable["Thorns"]}
			{
				return TRUE
			}
		}
		if !${Me.Buff["Omen of Clarity"](exists)}
		{
			if ${This.Usable["Omen of Clarity"]}
			{
				return TRUE
			}
		}
		if ${Toon.canUseScroll}
		{
			return TRUE
		}			
		return FALSE
	}
	
	method BuffPulse()
	{
		if ${Me.Target(exists)}
		{
			WoWScript ClearTarget()
		}
		if !${Me.Buff["Mark of the Wild"](exists)}
		{
			if ${This.Usable["Mark of the Wild"]}
			{
				Class:Cast[Mark of the Wild]
			}
		}
		if !${Me.Buff["Thorns"](exists)}
		{
			if ${This.Usable["Thorns"]}
			{
				Class:Cast[Thorns]
			}
		}
		if !${Me.Buff["Omen of Clarity"](exists)}
		{
			if ${This.Usable["Omen of Clarity"]}
			{
				Class:Cast[Omen of Clarity]
			}
		}
		if ${Toon.canUseScroll}
		{
			Toon:UseScroll
			return
		}
	}
	
	method StopCasting()
	{
		variable int Random = ${Math.Rand[100]}
		CD:Set[0]
		if ${Random} > 80
		{
			move left 50
			return
		}
		if ${Random} > 60
		{
			move right 50
			return
		}
		if ${Random} > 40
		{
			move backward 50
			return
		}
		if ${Random} > 20
		{
			move forward 50
			return
		}
		if ${Random} > 0
		{
			WoWScript SpellStopCasting()
			return
		}
	}
	
	method PullPulse()
	{
		if ${Class.DoubleCast}
		{
			This:Output["Stopping Double Cast of ${Me(unit).Casting.Name}"]
			Class:StopCasting
		}
			
		if ${Me.Casting}
		{
			if ${Class.GotNewTarget} && !${Class.IsHeal[${Me(unit).Casting.Name}]}
			{
				This:Output[Switching Pull targets]
				Class:StopCasting
			}
			return
		}
		
		Class:Shapeshift
		if ${PullTimeOut} == 0
		{
			PullTimeOut:Set[${LavishScript.RunningTime} + ${PullTimer}]
		}
		elseif ${LavishScript.RunningTime} > ${PullTimeOut}
		{
			This:Output[Failed Pull! Pull time out exceeded.]
			if !${RangedPull}
			{
				This:Output[Trying Ranged Pull]
				RangedPull:Set[TRUE]
				PullTimeOut:Set[0]
			}
			else
			{
				This:Output[Blacklisting Mob]
				GlobalBlacklist:Insert[${Target.GUID},3600000]
				WoWScript ClearTarget()
				PullTimeOut:Set[0]
				return
			}	
		}
		if ${Class.GotNewTarget}
		{
			This:Output[New Target Aquired]
			if !${Target.InCombat}
			{
				return
			}
		}
		if ${CurrentForm.Equal["Caster"]}
		{
			Class:CasterPull
		}
		if ${CurrentForm.Equal["Moonkin"]}
		{
			Class:MoonkinPull
		}
		if ${RangedPull}
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
			if ${Class.OutputTimer}
			{
				This:Output["Trying a ranged pull"]
			}
			if ${Target.Distance} > ${Toon.MinRanged}
			{
				if ${Spell["Faerie Fire (Feral)"](exists)}
				{
					Class:Cast[Faerie Fire (Feral)]
				}
				elseif ${Spell["Moonfire"](exists)}
				{
					Class:Cast[Moonfire]
					return
				}
			}
			return
		}
		if ${CurrentForm.Equal["Bear"]}
		{
			Class:BearPull
		}
		if ${CurrentForm.Equal["Kitty"]}
		{
			Class:KittyPull
		}
		if ${CurrentForm.Equal["Travel"]}
		{
			Class:TravelPull
		}
	}
	
	member OutputTimer()
	{
		if ${Math.Calc[${LavishScript.RunningTime}%5]} == 0
		{
			return TRUE
		}
		return FALSE
	}
	
	member NeedInterupt()
	{
		if !${Target.Buff[Maim](exists)} && !${Target.Buff[Bash](exists)} && !${Target.Buff[War Stomp](exists)} && !${Target.Buff[Cyclone](exists)} && !${Target.Buff[Cyclone](exists)}
		{
			if ${Target.Casting(exists)}
			{
				if ${Class.Usable[Maim]} || ${Class.Usable[Bash]} || ${Class.Usable[War Stomp]} || ${Class.Usable[Cyclone]} || ${Class.Usable[Feral Charge]}
				{
					return TRUE
				}
			}
			if ${Me.PctHPs} < ${HealHP}
			{
				if ${CurrentForm.Equal[Kitty]}
				{
					if ${Class.Usable[Maim]}
					{
						return TRUE
					}
				}
				if ${CurrentForm.Equal[Bear]}
				{
					if ${Class.Usable[Bash]}
					{
						return TRUE
					}
					if ${Class.Usable[Feral Charge]}
					{
						return TRUE
					}
				}
				if ${Class.Usable[War Stomp]} && ${Target.Distance} < 8
				{
					return TRUE
				}
				if ${Class.Usable[Cyclone]}
				{
					return TRUE
				}
			}
		}
		return FALSE
	}
	
	method Interupt()
	{
		if ${CurrentForm.Equal[Kitty]}
		{
			if ${Class.Usable[Maim]}
			{
				Class:Cast[Maim]
			}
		}
		if ${CurrentForm.Equal[Bear]}
		{
			if ${Class.Usable[Bash]}
			{
				Class:Cast[Bash]
			}
			if ${Class.Usable[Feral Charge]}
			{
				Class:Cast[Feral Charge]
			}
		}
		if ${Class.Usable[War Stomp]} && ${Target.Distance} < 8
		{
			Class:Cast[War Stomp]
		}
		if ${Class.Usable[Cyclone]}
		{
			Class:Cast[Cyclone]
		}
	}
	
	method AttackPulse()
	{
		if ${Class.DoubleCast}
		{
			This:Output["Stopping Double Cast of ${Me(unit).Casting.Name}"]
			Class:StopCasting
		}
		
		if ${Me.Casting}
		{
			return
		}
		if (${Target.TappedByMe} && !${Target.Target.Name.Equal[${Me.Name}]} && ${Target.Target.Player(exists)}) || (!${Target.TappedByMe} && ${Target.Tapped} && ${Target.InCombat})
		{
			GlobalBlacklist:Insert[${Target.GUID},3600000]
		}
		if !${Target.Buff[Maim](exists)}
		{
			Toon:AutoAttack
		}
		if ${Class.NeedInterupt}
		{
			Class:Interupt
			return
		}
		if ${Class.NeedMana}
		{
		}
		if ${Class.NeedHeal}
		{
			return
		}
		if !${Toon.TargetIsBestTarget} && ${Target.PctHPs} > 20
		{
			Toon:BestTarget
		}
		if ${Class.GotNewTarget}
		{
			This:Output[New Target Aquired]
		}
		if ${Toon.ValidTarget[${Target.GUID}]}
		{
			Class:Shapeshift
		}
		if ${Me.Equip[13](exists)}
		{
			if ${WoWScript[GetInventoryItemCooldown("player"\, 13)]} == 0
			{
				Me.Equip[13]:Use       
			}
		}
		if ${Me.Equip[14](exists)}
		{
			if ${WoWScript[GetInventoryItemCooldown("player"\, 14)]} == 0
			{
				Me.Equip[14]:Use   
			}
		}
		if ${CurrentForm.Equal["Caster"]}
		{
			Class:CasterPulse
		}
		if ${CurrentForm.Equal["Bear"]}
		{
			Class:BearPulse
		}
		if ${CurrentForm.Equal["Kitty"]}
		{
			Class:KittyPulse
		}
		if ${CurrentForm.Equal["Moonkin"]}
		{
			Class:MoonkinPulse
		}
		if ${CurrentForm.Equal["Travel"]}
		{
			Class:TravelPulse
		}
	}
	
	member NeedMana()
	{
		Mana:Set[${Me.PctMana}]
		if !${Me.InCombat}
		{
			if ${Mana} < ${RestMana}
			{
				This:Output["Need more Mana! (${Mana}/${RestMana})"]
				Class:RegMana
				return TRUE
			}
		}
		elseif ${Mana} < ${LowMana} && ${Me.Power.Equal["Mana"]}
		{
			This:Output["Need more Mana! (${Mana}/${LowMana})"]
			Class:RegMana
			return TRUE
		}
		return FALSE
	}
	
	member MoveWait()
	{
		if ${MWait} > ${LavishScript.RunningTime}
		{
			return TRUE
		}
		MWait:Set[${LavishScript.RunningTime} + 500]
		return FALSE
	}
	
	method RegMana()
	{
		if ${Me.Casting} || ${Me.Buff[Innervate](exists)}
		{
			return
		}
		if ${Me.InCombat}
		{
			variable string PotionName = ${Item[-inventory,"Mana Potion"].Name}
			if ${Class.Usable[Innervate]}
			{
				Class:Cast[Innervate]
			}
			if ${Mana} < 5 && ${Item[${PotionName}](exists)} && ${Item[${PotionName}].Usable} && !${WoWScript["GetContainerItemCooldown(${Item[${PotionName}].Bag.Number}, ${Item[${PotionName}].Slot})", 2]}
			{
				Item[${PotionName}]:Use
				This:Output[Using ${Item[-inventory,"Mana Potion"].Name}]
				CD:Set[${LavishScript.RunningTime} + (${CastPrecision}/2)]
			}
		}
		else
		{
			if ${Movement.Speed}
			{
				if !${Class.MoveWait}
				{
					move -stop
					return
				}
			}
			if ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)}
			{
				Consumable:useDrink
				CD:Set[${LavishScript.RunningTime} + 1000]
			}
		}
	}
	
	member NeedHeal()
	{
		if !${Me.Casting}
		{
			HP:Set[${Me.PctHPs}]
		}
		if ${HP} > 10
		{
			HP:Inc[${Me.Buff[Lifebloom].Application}*2]
			HP:Inc[${Me.Buff[Regrowth].Duration}*0.4]
			HP:Inc[${Me.Buff[Rejuvenation].Duration}*0.5]
		}
		if ${Healing}
		{
			if ${HP} < ${HealToHP}
			{
				This:Output["Need more healing! (${HP}/${HealToHP})"]
				Class:Heal
			}
			else
			{
				This:Output["Fully healed to ${HealToHP}% (${HP}/${HealToHP})"]
				Healing:Set[FALSE]
			}
			return TRUE
		}
		else
		{
			if !${Me.InCombat} && ${HP} < ${RestHP} || ${HP} < ${HealHP}
			{
				Healing:Set[TRUE]
			}
		}
		return FALSE
	}

	
	method Heal()
	{
		variable string PotionName = ${Item[-inventory,"Healing Potion"].Name}
		if ${Me.Casting} || ${Me.Buff[Food](exists)}
		{
			return
		}
		if !${Me.InCombat}
		{
			if ${Movement.Speed}
			{
				if !${Class.MoveWait}
				{
					move -stop
					return
				}
			}
			if ${Consumable.HasFood} && !${Me.Buff[Food](exists)}
			{
				Consumable:useFood
				CD:Set[${LavishScript.RunningTime} + 1000]
			}
		}
		if ${HP} < 10 && ${Class.Usable[Regrowth]} && !${Me.Buff[Regrowth](exists)}
		{
			Class:Cast[Regrowth]
		}
		if ${HP} < 80 && ${Class.Usable[Rejuvenation]} && !${Me.Buff[Rejuvenation](exists)}
		{
			Class:Cast[Rejuvenation]
		}
		if ${HP} > 25 && ${Class.Usable[Lifebloom]} && (${Me.Buff[Lifebloom].Application} < 3 || ${Me.Buff[Lifebloom].Duration} < 1)
		{
			Class:Cast[Lifebloom]
		}
		if ${Class.Usable[Healing Touch]}
		{
			Class:Cast[Healing Touch]
		}
		if ${Class.Usable[Lifebloom]} && (${Me.Buff[Lifebloom].Application} < 3 || ${Me.Buff[Lifebloom].Duration} < 1)
		{
			Class:Cast[Lifebloom]
		}
		if ${HP} < 5 && ${Item[${PotionName}](exists)} && ${Item[${PotionName}].Usable} && !${WoWScript["GetContainerItemCooldown(${Item[${PotionName}].Bag.Number}, ${Item[${PotionName}].Slot})", 2]}
		{
			Item[${PotionName}]:Use
			This:Output[Using ${Item[-inventory,"Healing Potion"].Name}]
			CD:Set[${LavishScript.RunningTime} + (${CastPrecision}/2)]
		}
	}
	
	method Cast(string SpellName)
	{
		if ${Spell[${SpellName}].CastTime} > 0
		{
			if ${Movement.Speed}
			{
				if !${Class.MoveWait}
				{
					move -stop
				}
			}
		}
		if ${Spell[${SpellName}].CastTime} > 1 && ${Class.Usable[Barkskin]} && ${Toon.AggroWithin[10,TRUE]} > 0
		{
			if ${BarkskinForHeals}
			{
				if ${Class.IsHeal[${SpellName}]}
				{
					This:Output["Casting Barkskin to protect ${SpellName}"]
					Cast "Barkskin"
					CD:Set[${LavishScript.RunningTime} + (${CastPrecision}/2)]
					return
				}
			}
			else
			{
				This:Output["Casting Barkskin to protect ${SpellName}"]
				Cast "Barkskin"
				CD:Set[${LavishScript.RunningTime} + (${CastPrecision}/2)]
				return
			}
		}
		This:Output["Casting ${SpellName}"]
		Cast "${SpellName}"
		CD:Set[${LavishScript.RunningTime} + ${Spell[${SpellName}].CastTime} + ${CastPrecision}]
		return
	}
	
	member Ready(string thisSpell)
	{
		if ${Spell[${thisSpell}](exists)} && !${Spell[${thisSpell}].Cooldown}
		{
			return TRUE
		}
		return FALSE
	}
	
	method CombatEvent(string unitID, string unitAction, string isCrit, string amtDamage, string damageType)
	{
		if ${unitID.Equal["target"]} && ${unitAction.Equal["immune"]}		
		{
			if ${damageType.Equal["6"]}
			{
				ArcaneImmune:Set[TRUE]
				This:Output["Immune! Stopping Arcane spells."]
			}
			if ${damageType.Equal["3"]}
			{
				NatureImmune:Set[TRUE]
				This:Output["Immune! Stopping Nature spells."]
			}
		}
	}
	
	variable string Arcane = Moonfire/Starfire/
	variable string Nature = Wrath/Insect Swarm/Faerie Fire/Faerie Fire(feral)/Thorns/Nature's Grasp/Entangling Roots/Cyclone/
	variable string Bleed = Rake/Lacerate/Rip/
	
	member Usable(string thisSpell)
	{
		variable int CostMulti = 1
		variable int SpellSchool = 0
		if ${LavishScript.RunningTime} > ${CD}
		{
			if ${Me.Power.Equal["Rage"]}
			{
				CostMulti:Set[0.1]
			}
			if ${Arcane.Find[${thisSpell}/]}
			{
				SpellSchool:Set[1]
			}
			elseif ${Nature.Find[${thisSpell}/]}
			{
				SpellSchool:Set[2]
			}
			elseif ${Bleed.Find[${thisSpell}/]}
			{
				SpellSchool:Set[3]
			}
			if ${Spell[${thisSpell}](exists)} && !${Spell[${thisSpell}].Cooldown} && ${Me.Action[${thisSpell}].Usable} && !${Me.Action[${thisSpell}].Active}
			{
				if (${Class.PowerIsMana[${thisSpell}]} && ${Me.CurrentMana} > ${Spell[${thisSpell}].Mana}) ||${Me.CurrentPower} > (${Spell[${thisSpell}].Mana}*${CostMulti}) || ${Me.Buff[Clearcasting](exists)}
				{
					if ${IsDot[${thisSpell}]} && ${Target.PctHPs} < ${StopDots}
					{
						return FALSE
					}
					if (${ArcaneImmune} && ${SpellSchool} == 1) || (${NatureImmune} && ${SpellSchool} == 2) || (${BleedImmune} && ${SpellSchool} == 3)
					{
						return FALSE
					}
					return TRUE
				}
			}
		}
		return FALSE
	}
	
	member CheckDebuff(string DebuffName)
	{
		variable int i = 0
		do
		{
			if ${DebuffName.Equal[${WoWScript["UnitDebuff("target",${i})",1]}]}
			{
				return ${WoWScript["UnitDebuff("target",${i})",7]}
			}
			i:Inc
		}
		while ${WoWScript["UnitDebuff("target",${Math.Calc[${i}+1]})",7](exists)}
		return 0
	}
	
	method SetCurrentForm()
	{
		if ${WoWScript[GetShapeshiftForm()]} == 0
		{
			CurrentForm:Set[Caster]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Bear"]}
		{
			CurrentForm:Set[Bear]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Cat"]}
		{
			CurrentForm:Set[Kitty]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Moonkin"]}
		{
			CurrentForm:Set[Moonkin]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Flight"]}
		{
			CurrentForm:Set[Flight]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Travel"]}
		{
			CurrentForm:Set[Travel]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
		if ${WoWScript[GetShapeshiftFormInfo(${WoWScript[GetShapeshiftForm()]}),2].Find["Tree"]}
		{
			CurrentForm:Set[Tree]
			This:Output[Shapeshifted to ${CurrentForm} Form!]
			return
		}
	}
	
	member TargetRooted()
	{
		if ${Target.Buff[Entangling Roots](exists)} || ${Target.Buff[Frost Nova](exists)}
		{
			return TRUE
		}
		return FALSE
	}
	
	variable string Heals = Healing Touch/Regrowth/Rejuvenation/Lifebloom/Tranquillity/Nature's Swiftness/Thorns/Mark of the Wild/Omen of Clarity
	
	member IsHeal(string SpellName)
	{
		if ${Heals.Find[${SpellName}]}
		{
			return TRUE
		}
		return FALSE
	}
	
	variable string ManaSpells = Wrath/Starfire/Moonfire/Insect Swarm/Force of Nature/Faerie Fire/Hurricane/Barkskin/Hibernate/Soothe Beast/Teleport: Moonglade/Entangling Roots/Cyclone/Innervate/Abolish Poison/Cure Poison/Remove Curse/Rebirth/Gift of the Wild/Healing Touch/Regrowth/Rejuvenation/Lifebloom/Tranquillity/Nature's Swiftness/Thorns/Mark of the Wild/Omen of Clarity/
	
	member PowerIsMana(string SpellName)
	{
		if ${ManaSpells.Find[${SpellName}/]}
		{
			return TRUE
		}
		return FALSE
	}
	
	method CasterPull()
	{
		cast "Bear Form"
		This:Output[Shapeshifted to ${CurrentForm} Form!]
		return
		Class:BearPulse
		if ${Class.Usable[Entangling Roots]} && !${Class.TargetRooted} && !${Mount.IsIndoors} && !${Class.IsCaster}
		{
			Class:Cast[Entangling Roots]
		}
		if ${Class.Usable[Starfire]}
		{
			Class:Cast[Starfire]
		}
		if ${Class.Usable[Wrath]}
		{
			Class:Cast[Wrath]
		}
		if !${Me.Casting}
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
		}
	}
	
	method KittyPull()
	{
		if !${Toon.DetectAdds[${Target.GUID},1,25]} || ${Target.Distance} < ${Toon.MaxMelee} + 5
		{
			if ${Target.Distance} < ${Toon.MaxMelee} + 5
			{
				if ${Me.PctPower} > 80
				{
					if ${Toon.isFacingAway}
					{
						if ${Class.Usable[Pounce]}
						{
							Class:Cast[Pounce]
							return
						}
						if ${Class.Usable[Ravage]}
						{
							Class:Cast[Ravage]
							return
						}
						if ${Class.Usable[Shred]}
						{
							Class:Cast[Shred]
							return
						}
					}
					else
					{
						if ${Class.Usable[Pounce]}
						{
							Class:Cast[Pounce]
							return
						}
						if ${Class.Usable[Claw]}
						{
							Class:Cast[Claw]
						}
					}
					if !${Class.MoveWait}
					{
						Toon:ToMelee
					}
				}
				else
				{
					if !${Class.MoveWait}
					{
						move -stop
					}
				}
			}
			elseif ${Target.Distance} < 20
			{
				if ${Class.Usable[Prowl]}
				{
					Class:Cast[Prowl]
				}
				else
				{
					if ${Class.Usable[Tiger's Fury]} && !${Me.Buff[Tiger's Fury](exists)} && ${Me.PctPower} > 80
					{
						Class:Cast[Tiger's Fury]
					}
					if ${Me.PctPower} > 75
					{
						if !${Class.MoveWait}
						{
							Toon:ToMelee
						}
					}
					else
					{
						if !${Class.MoveWait}
						{
							move -stop
						}
					}
				}
			}
			else
			{
				if !${Class.MoveWait}
				{
					Toon:ToMelee
				}
			}
		}
		else
		{
			This:Output[Hostile Adds Detected!]
			RangedPull:Set[TRUE]
		}
	}
	
	method BearPull()
	{
		Toon:AutoAttack
		if !${Toon.DetectAdds[${Target.GUID},1,25]}
		{
			if !${Class.MoveWait}
			{
				Toon:ToMelee
			}
			if ${Class.Usable[Enrage]}
			{
				Class:Cast[Enrage]
			}
			if ${Class.Usable[Maul]}
			{
				Class:Cast[Maul]
			}
			if ${Class.Usable[Feral Charge]}
			{
				Class:Cast[Feral Charge]
			}
			if ${Class.Usable[Faerie Fire (Feral)]}
			{
				Class:Cast[Faerie Fire (Feral)]
			}
		}
		else
		{
			This:Output[Hostile Adds Detected!]
			RangedPull:Set[TRUE]
		}
	}
	
	method KittyPulse()
	{
		if ${Target.Distance} > 30
		{
			if ${Class.Usable[Dash]}
			{
				Class:Cast[Dash]
			}
		}
		if ((${Target.Target(exists)} && ${Target.Target.Name.NotEqual[${Me.Name}]}) || ${Class.CheckDebuff[Maim]} > 0.5 || ${Class.CheckDebuff[Bash]} > 0.5 || ${Class.CheckDebuff[Cyclone]} > 0.5 || ${Class.CheckDebuff[Pounce]} > 0.5) && ${Target.PctHPs} > 10
		{
			if ${Math.Abs[${Target.Heading} - ${Me.HeadingTo[${Target.X},${Target.Y}]}]} < 90
			{
				if ${Target.Buff[Maim](exists)} && ${Me.PctPower} < 80
				{
					if !${Class.MoveWait}
					{
						Toon:ToMelee
					}
					if ${Class.OutputTimer}
					{
						This:Output[Behind my Target: Waiting for energy]
					}
					return
				}
			}
			elseif ${Target.Distance} < 10
			{
				if ${Class.OutputTimer}
				{
					This:Output[Moving behind my target]
				}
				move forward 1500
				return
			}
			else
			{
				if !${Class.MoveWait}
				{
					Toon:ToMelee
					return
				}
			}
		}
		if !${Toon.DetectAdds[${Target.GUID},1,25]} && ${Target.Distance} > 10 && !${Class.IsCaster}
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
			if ${Class.Usable[Faerie Fire (Feral)]} && !${Target.Buff[Faerie Fire (Feral)](exists)} && !${Target.Buff[Faerie Fire](exists)}
			{
				Class:Cast[Faerie Fire (Feral)]
			}
		}
		else
		{
			if !${Class.MoveWait}
			{
				Toon:ToMelee
			}
			if ${Me.ComboPoints}*3.5 > ${Target.PctHPs}
			{
				if ${Me.PctPower} >= 65
				{
					if ${Class.Usable[Tiger's Fury]} && !${Me.Buff[Tiger's Fury](exists)}
					{
						Class:Cast[Tiger's Fury]
					}
				}
				if ${Class.Usable[Ferocious Bite]}
				{
					Class:Cast[Ferocious Bite]
				}
			}
			if ${Me.ComboPoints} > 1 && (30 + (${Me.ComboPoints}*10) > ${Target.PctHPs} && ${Toon.AggroWithin[40,TRUE]} < 2 && ${Target.PctHPs} > 10
			{
				if ${Me.PctPower} >= 65
				{
					if ${Class.Usable[Tiger's Fury]} && !${Me.Buff[Tiger's Fury](exists)}
					{
						Class:Cast[Tiger's Fury]
					}
				}
				if ${Class.Usable[Maim]}
				{
					Class:Cast[Maim]
				}
			}
			if ${Class.Usable[Mangle (Cat)]} && !${Target.Buff[Mangle (Cat)](exists)} && !${Target.Buff[Mangle (Bear)](exists)}
			{
				Class:Cast[Mangle (Cat)]
			}
			if ${Me.ComboPoints} > 3 && ${Target.PctHPs} > 75
			{
				if ${Me.PctPower} >= 60
				{
					if ${Class.Usable[Tiger's Fury]} && !${Me.Buff[Tiger's Fury](exists)}
					{
						Class:Cast[Tiger's Fury]
					}
				}
				if ${Class.Usable[Rip]}
				{
					Class:Cast[Rip]
				}
			}
			if ${Toon.isFacingAway}
			{
				if ${Class.Usable[Shred]}
				{
					Class:Cast[Shred]
				}
				if !${Class.Ready[Shred]} && ${Class.Usable[Claw]}
				{
					Class:Cast[Claw]
				}
			}
			else
			{
				if ${Class.Usable[Rake]} && !${Target.Buff[Rake](exists)}
				{
					Class:Cast[Rake]
				}
				if ${Class.Usable[Mangle (Cat)]}
				{
					Class:Cast[Mangle (Cat)]
				}
				if ${Class.Usable[Claw]}
				{
					Class:Cast[Claw]
				}
			}
			if ${Class.Usable[Faerie Fire (Feral)]} && !${Target.Buff[Faerie Fire (Feral)](exists)} && !${Target.Buff[Faerie Fire](exists)}
			{
				Class:Cast[Faerie Fire (Feral)]
			}
		}
	}
	
	method TravelPulse()
	{
		if ${Class.OutputTimer}	
		{
			This:Output[Danger too high, Fleeing!]
		}
		Toon:Flee
	}
	
	method TravelPulse()
	{
		if ${Class.OutputTimer}	
		{
			This:Output[Danger too high, Fleeing!]
		}
		Toon:Flee
	}
	
	method FleePulse()
	{
		if ${Me.Attacking}
		{
			WoWScript AttackTarget()
			return
		}
		if ${Class.Danger.Equal["MEDIUM"]} || ${Class.Danger.Equal["LOW"]}
		{
			Toon:Flee[FALSE]
		}
		if ${Class.Usable[Frenzied Regeneration]}
		{
			Class:Cast[Frenzied Regeneration]
		}
		if ${Class.Usable[Dash]}
		{
			Class:Cast[Dash]
		}
	}
	
	method BearPulse()
	{
		if !${Toon.DetectAdds[${Target.GUID},1,25]} && ${Target.Distance} > 10 && !${Class.IsCaster}
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
			if ${Class.Usable[Faerie Fire (Feral)]} && !${Target.Buff[Faerie Fire (Feral)](exists)} && !${Target.Buff[Faerie Fire](exists)}
			{
				Class:Cast[Faerie Fire (Feral)]
			}
		}
		else
		{
			if !${Class.MoveWait}
			{
				Toon:ToMelee
			}
			if ${Me.PctHPs} > 30 && ${Class.Usable[Enrage]}
			{
				Class:Cast[Enrage]
			}
			if ${Me.Buff[Frenzied Regeneration](exists)}
			{
				return
			}
			if !${Class.IsCaster} || (${Class.IsCaster} && ${Target.Casting(exists)})
			{
				if ${Class.Usable[Feral Charge]}
				{
					Class:Cast[Feral Charge]
				}
			}
			if ${Class.Usable[Mangle (Bear)]}
			{
				Class:Cast[Mangle (Bear)]
			}
			if ${Me.PctHPs} < 70
			{
				if ${Class.Usable[Frenzied Regeneration]}
				{
					Class:Cast[Frenzied Regeneration]
				}
			}
			if ${Class.Usable[Maul]}
			{
				Class:Cast[Maul]
			}
			if ${Class.Usable[Demoralizing Roar]} && !${Target.Buff[Demoralizing Roar](exists)} && ${Target.Distance} < 8
			{
				Class:Cast[Demoralizing Roar]
			}
			if ${Me.PctPower} > 10 && ${Class.Usable[Swipe]} && ${Toon.AggroWithin[8,TRUE]} > 1
			{
				Class:Cast[Swipe]
			}
			if ${Me.PctPower} > 35 && ${Class.Usable[Lacerate]}
			{
				Class:Cast[Lacerate]
			}
			if ${Class.Usable[Faerie Fire (Feral)]} && !${Target.Buff[Faerie Fire (Feral)](exists)} && !${Target.Buff[Faerie Fire](exists)}
			{
				Class:Cast[Faerie Fire (Feral)]
			}
		}
	}
	
	member GotNewTarget()
	{
		if ${Me.Target(exists)} && ${Target.GUID.NotEqual[${OldTargetGUID}]}
		{
			OldTargetGUID:Set[${Target.GUID}]
			Caster:Set[FALSE]
			ArcaneImmune:Set[FALSE]
			NatureImmune:Set[FALSE]
			if ${Target.CreatureType.Equal[Undead]} || ${Target.CreatureType.Equal[Mechanical]} || ${Target.CreatureType.Equal[Elemental]}
			{
				BleedImmune:Set[TRUE]
			}
			else
			{
				BleedImmune:Set[FALSE]
			}
			PullTimeOut:Set[0]
			RangedPull:Set[FALSE]
			return TRUE
		}
		if ${Me.Target(exists)}
		{
			OldTargetGUID:Set[${Target.GUID}]
		}
		return FALSE
	}
	
	method CasterPulse()
	{
		if ${Class.IsCaster} && ${Me.PctMana} < 10 && !${Toon.DetectAdds[${Target.GUID},1,25]}
		{
			if !${Class.MoveWait}
			{
				Toon:ToMelee
			}
		}
		elseif ${Target.Distance} > 10 || ${Class.TargetRooted}
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
		}
		else
		{
			if !${Class.MoveWait} && !${Toon.DetectAdds[${Target.GUID},1,20]}
			{
				Toon:ToMelee
			}
		}
		if ${Toon.AggroWithin[8,TRUE]} > 0
		{
			if !${Target.Buff[Entangling Roots](exists)} && ${Target.PctHPs} > 30 && !${Mount.IsIndoors} && ${Class.Usable[Nature's Grasp]}
			{
				Class:Cast[Nature's Grasp]
			}
		}
		if (${Toon.AggroWithin[30,TRUE]} > 1 || ${Class.IsCaster}) && ${Class.Usable[Force of Nature]}
		{
			Class:Cast[Force of Nature]
			ISXWoW:ClickTerrain[${Target.X}]}, ${Target.Y}]}, ${Target.Z}]
		}
		if ${Class.Usable[Entangling Roots]} && !${Target.Buff[Entangling Roots](exists)} && ${Target.PctHPs} > 30 && !${Mount.IsIndoors} && !${Class.IsCaster}
		{
			Class:Cast[Entangling Roots]
		}
		if ${Class.Usable[Moonfire]} && !${Target.Buff[Moonfire](exists)} && ${Me.PctMana} > 40
		{
			Class:Cast[Moonfire]
		}
		if ${Class.Usable[Insect Swarm]} && !${Target.Buff[Insect Swarm](exists)} && ${Target.PctHPs} > 30
		{
			Class:Cast[Insect Swarm]
		}
		if ${Class.Usable[Starfire]} && ${Target.PctHPs} > 25 && (${Target.Distance} > 20 || ${Me.Buff[Barkskin].Duration} > ${Spell[Starfire].CastTime})
		{
			Class:Cast[Starfire]
		}
		if ${Class.Usable[Wrath]}
		{
			Class:Cast[Wrath]
		}
	}
	
	method MoonkinPulse()
	{
		if (${Target.Distance} > 10 || ${Class.TargetRooted}) && ${Target.PctHPs} > 20
		{
			if !${Class.MoveWait}
			{
				Toon:ToRanged
			}
		}
		else
		{
			if !${Class.MoveWait}
			{
				Toon:ToMelee
			}
		}
		if ${Toon.AggroWithin[8,TRUE]} > 0
		{
			if !${Target.Buff[Entangling Roots](exists)} && ${Target.PctHPs} > 30 && !${Mount.IsIndoors} && ${Class.Usable[Nature's Grasp]}
			{
				Class:Cast[Nature's Grasp]
			}
		}
		if ${Toon.AggroWithin[30,TRUE]} > 1 && ${Class.Usable[Force of Nature]}
		{
			Class:Cast[Force of Nature]
			ISXWoW:ClickTerrain[${Target.X}]}, ${Target.Y}]}, ${Target.Z}]
		}
		if ${Class.Usable[Entangling Roots]} && !${Target.Buff[Entangling Roots](exists)} && ${Target.PctHPs} > 30 && !${Mount.IsIndoors} && !${Class.IsCaster}
		{
			Class:Cast[Entangling Roots]
		}
		if ${Class.Usable[Moonfire]} && !${Target.Buff[Moonfire](exists)} && ${Me.PctMana} > 40
		{
			Class:Cast[Moonfire]
		}
		if ${Class.Usable[Insect Swarm]} && !${Target.Buff[Insect Swarm](exists)} && ${Target.PctHPs} > 30
		{
			Class:Cast[Insect Swarm]
		}
		if ${Class.Usable[Starfire]} && ${Target.PctHPs} > 25 && (${Target.Distance} > 20 || ${Me.Buff[Barkskin].Duration} > ${Spell[Starfire].CastTime})
		{
			Class:Cast[Starfire]
		}
		if ${Class.Usable[Wrath]}
		{
			Class:Cast[Wrath]
		}
	}
	
	member Danger()
	{
		variable int CombatTime
		variable guidlist Aggros
		variable int DangerLevel
		Aggros:Search[-units,-nearest,-attackable,-aggro,-alive,-range 0-40]
		DangerLevel:Set[${DangerLevel} * 0.5]
		DangerLevel:Inc[${Aggros.Count}*6.5]
		DangerLevel:Inc[(100 - ${Me.PctMana})*0.1]
		CombatTime:Set[${Math.Calc[${LavishScript.RunningTime} - ${CombatStart}].Round}]
		DangerLevel:Inc[${CombatTime}/5000]
		if ${Target.Level} > ${Me.Level}
		{
			DangerLevel:Inc[(${Target.Level} - ${Me.Level})*2]
		}
		elseif ${Me.Level} > ${Target.Level}
		{
			DangerLevel:Inc[(${Target.Level} - ${Me.Level})*1]
		}
		if ${WoWScript[UnitIsPlusMob(unit)]}
		{
			DangerLevel:Inc[20]
		}
		if ${Target.Player(exists)} && ${Target.Attackable}
		{
			DangerLevel:Inc[20]
		}
		if ${Inventory.NeedRepair}
		{
			DangerLevel:Inc[30]	
		}
		if ${DangerLevel} < 0
		{
			DangerLevel:Set[0]
		}
		if ${DangerLevel} > 100
		{
			return VERYHIGH
		}
		if ${DangerLevel} > 30
		{
			return HIGH
		}
		if ${DangerLevel} > 15
		{
			return MEDIUM
		}
		return LOW
	}
		
	method Shapeshift(string Form)
	{
		if ${Form.Length} == 0
		{
			if ${Class.Danger.Equal["LOW"]}
			{
				Form:Set[${DangerLow}]
			}
			elseif ${Class.Danger.Equal["MEDIUM"]}
			{
				Form:Set[${DangerMedium}]
			}
			elseif ${Class.Danger.Equal["HIGH"]}
			{
				Form:Set[${DangerHigh}]
			}
			elseif ${Class.Danger.Equal["VERYHIGH"]}
			{
				Form:Set[${DangerVeryHigh}]
			}
		}
		if ${Class.CurrentForm.NotEqual[${Form}]}
		{
			if ${Form.Equal[Bear]}
			{
				if ${Spell[Dire Bear Form](exists)}
				{
					cast "Dire Bear Form"
				}
				elseif ${Spell[Bear Form](exists)}
				{
					cast "Bear Form"
				}
			}
			if ${Form.Equal[Kitty]}
			{
				if ${Spell[Cat Form](exists)}
				{
					cast "Cat Form"
				}
				return
			}
			if ${Form.Equal[Moonkin]}
			{
				if ${Spell[Moonkin Form](exists)}
				{
					cast "Moonkin Form"
				}
				return
			}
			if ${Form.Equal[Travel]}
			{
				if ${Spell[Travel Form](exists)} && !${Mount.IsIndoors}
				{
					cast "Travel Form"
				}
			}
			if ${Form.Equal[Caster]}
			{
				if ${WoWScript[GetShapeshiftForm()]} != 0
				{
					 WoWScript CastShapeshiftForm(${WoWScript[GetShapeshiftForm()]})
				}
			}
			return
		}
	}
	
	member IsCaster()
	{
		if ${Caster}
		{
			return TRUE
		}
		if ${Target.Casting(exists)}
		{
			Caster:Set[TRUE]
			return TRUE
		}
		return FALSE
	}
	
	method CureAll()
	{
		if ${Me.PctMana} < 15
		{
			return
		}
		variable int i
		for (i:Set[0]; ${i} <= 10; i:Inc)
		{
			if ${Me.Buff[${i}].Harmful} && ${Me.Buff[${i}].Duration} > 15
			{
				if ${Me.Buff[${i}].DispelType.Equal[Curse]}
				{
					if ${Class.Usable[Remove Curse]}
					{
						This:Output["Removing Curse: ${Me.Buff[${i}].Name}"]
						Class:Cast[Remove Curse]
						return
					}
				}
				if ${Me.Buff[${i}].DispelType.Equal[Poison]}
				{
					if !${Me.Buff[Abolish Poison](exists)}
					{
						if ${Class.Usable[Abolish Poison]}
						{
							This:Output["Removing Poison: ${Me.Buff[${i}].Name}"]
							Class:Cast[Abolish Poison]
							return
						}
						if ${Class.Usable[Cure Poison]}
						{
							This:Output["Removing Poison: ${Me.Buff[${i}].Name}"]
							Class:Cast[Cure Poison]
							return
						}
					}
				}
				if ${Me.Buff[${i}].DispelType.Equal[Root]} && ${Me.PctMana} > 25
				{
					if ${WoWScript[GetShapeshiftForm()]} != 0
					{
						This:Output["Shapeshifting out of immobilize: Caster Form"]
						WoWScript CastShapeshiftForm(${WoWScript[GetShapeshiftForm()]})
					}
					else
					{
						if ${Spell[Travel Form](exists)} && !${Mount.IsIndoors}
						{
							This:Output["Shapeshifting out of immobilize: Travel Form"]
							cast "Travel Form"
						}
						elseif ${Spell[Bear Form](exists)}
						{
							This:Output["Shapeshifting out of immobilize: Bear Form"]
							cast "Bear Form"
						}
					}
				}
			}
		}
	}
	
	
	
}