objectdef oClass inherits oBase
{
  ;******************************************************************************** /
  ;** Variables                                                                   * /
  ;******************************************************************************** /

	;--- Rest
	variable int RestMana = 35
	variable int StandMana = 85
	variable int RestHP = 70
	variable int StandHP = 80
	
	;--- Range and checks
	variable int AttackRange = 35
	variable int FollowRange = 35
	variable int MaxHeightDif = 5
	variable int Friends = 1
	
	;--- Pull ----------------------------------------------------------------------- /
	variable bool UsePullDot1 = TRUE
	variable string PullDot1 = "Moonfire"
	variable bool UsePullDot2 = TRUE
	variable string PullDot2 = "Insect Swarm"
	
	;--- Rest ----------------------------------------------------------------------- /
	variable int 	RestMyHealthTouch = 70
	
	;--- Buff ----------------------------------------------------------------------- /
	variable bool BuffMark = TRUE
	variable bool BuffThorns = TRUE
	
	;--- CombatBuff ----------------------------------------------------------------- /
	variable bool CombatBuffRacial = TRUE
	variable bool CombatBuffTrinket = TRUE
	variable bool CombatBuffSwiftness = TRUE
	variable bool CombatBuffBarkskin = TRUE
	variable bool CombatBuffStone = TRUE
	variable int  CombatBuffMyHealthStone = 25
	variable bool CombatBuffInnervate = TRUE
	
	;--- Prebuff -------------------------------------------------------------------- /
	variable bool PrebuffTable = TRUE
	variable int PrebuffTableStacks = 10
	variable bool PrebuffSoulwell = TRUE
	variable bool PrebuffMark = TRUE
	variable bool PrebuffThorns	= TRUE
	
	;--- Guard ---------------------------------------------------------------------- /
	variable bool GuardBloom = TRUE
	variable int  GuardTargetHealthBloom = 70
	variable int  GuardMyManaBloom = 50
	
	;--- Healer --------------------------------------------------------------------- /
	variable bool HealerRejuvenation = TRUE
	variable int  HealerTargetHealthRejuvenation = 80
	variable int  HealerMyManaRejuvenation = 20
	variable bool HealerRegrowth = TRUE
	variable int  HealerTargetHealthRegrowth = 40
	variable int  HealerMyManaRegrowth = 20
	variable bool HealerBloom = TRUE
	variable int  HealerTargetHealthBloom = 60
	variable int  HealerMyManaBloom	= 20
	variable bool HealerTouch = TRUE	
	variable int  HealerTargetHealthTouch = 20
	variable int  HealerMyManaTouch = 10
	
	;--- Trinkets
	variable string TrinketName1 = "Battlemaster's Perseverance"
	variable int TrinketMyHealth1 = 30 /* 100 for always use */
	variable int TrinketMyMana1 = 100 /* 100 for always use */
	variable int TrinketPvP1 = FALSE /* Only PvP Trinket   */
	
	variable string TrinketName2 = "Insignia of the Horde"
	variable int TrinketMyHealth2 = 100 /* 100 for always use*/
	variable int TrinketMyMana2 = 100 /* 100 for always use*/
	variable int TrinketPvP2 = TRUE	/* Only PvP Trinket   */
	
  ;******************************************************************************** /
  ;** Pull & Attack Functions                                                     * /
  ;******************************************************************************** /
	;** - Pull Setup - ************************************************************** /
	;** - Attack Setup - ************************************************************ /
  ;******************************************************************************** /

	;** - Pull Setup - ************************************************************** /
	variable int PullBailOut = ${LavishScript.RunningTime}
	variable int RandomPull = 99

	method PullPulse()
	{
		This:BGChk
		
		if ${Me.Casting}
		{
			return
		}		
		
		if ${Toon.TargetIsNew}
		{
			This.PullBailOut:Set[${This.InMilliseconds[${Config:GetSlider["sldPullBailOutTimer"]}]
		}

		if !${Toon.ValidTarget[${Target.GUID}]} && ${This.FriendsChk}
		{
			This:Output["DRUID Routine: Need a target"]
			Toon:NeedTarget[1]
			return
		}
		
		if !${Target.LineOfSight}
		{
			This:Output["DRUID Routine: Target is out of sight, skipping! ${Target.LineOfSight}."]
			;WoWScript ClearTarget()
			Toon:Stop
			if ${This.FriendsChk}
			{
      	Toon:NextBestTarget
      }
			return
		}
		
		if (!${Toon.TargetIsBestTarget} || ${Target.Dead} || !${Target.LineOfSight}) || (${Target.Distance} > ${This.FollowRange})
    {
    	This:Output["DRUID Routine: Target is no longer best target."]
    	;WoWScript ClearTarget()
      if ${This.FriendsChk}
      {
      	Toon:BestTarget
      }
      return
    }
		
		if (${Target.Distance} > ${This.AttackRange}) && (${Target.Distance} < ${This.FollowRange}) && (${Math.Abs[${Target.Z} - ${Me.Z}]} < ${This.MaxHeightDif})
		{
			This:Output["Target is too far away but within follow range, moving closer."]
			Toon:ToRanged
			return
		}
		elseif !${Target.LineOfSight}
		{
			This:Output["DRUID Routine: Target is out of sight, skipping! ${Target.LineOfSight}."]
			;WoWScript ClearTarget()
			Toon:Stop
			if ${This.FriendsChk}
			{
      	Toon:NextBestTarget
      }
			return
		}
		elseif ${Movement.Speed} && ${Target.Distance} < ${This.AttackRange} - 2
		{
			Toon:Stop
		}
		
		if ${This.NeedFaceForSpell}
		{
			This:FaceForSpellPulse
			return
		}
		
		if ${This.UsePullDot1} && !${This.NeedHealer}
		{
			if ${Toon.canCast[${This.PullDot1}]} && ${Toon.canBuff[${Target.GUID}, ${This.PullDot1}]} && !${Movement.Speed}
			{
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				Toon:CastSpellGUID[${Target.GUID}, ${This.PullDot1}]
				return
			}
		}
		
		if ${This.UsePullDot2} && !${This.NeedHealer}
		{
			if ${Toon.canCast[${This.PullDot2}]} && ${Toon.canBuff[${Target.GUID}, ${This.PullDot2}]} && !${Movement.Speed}
			{
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				Toon:CastSpellGUID[${Target.GUID}, ${This.PullDot2}]
				return
			}
		}
	}
	
	;** - Attack Setup - ************************************************************ /
	method AttackPulse()
	{		
		;if ${Me.Casting}
		;{
		;	return
		;}
		;important
		
		This:BGChk
		
		if ${This.NeedCombatHealing}
		{
			This:CombatHealingPulse
			return
		}
		
		if ${This.NeedHealer} && ${This.FriendsChk}
		{
			This:HealerPulse
			return
		}
		
		if !${Toon.ValidTarget[${Target.GUID}]} || ${Target.Dead} || !${Me.Target(exists)} || ${Target.Distance} > ${This.AttackRange}
		{
			Toon:Stop
			Toon:NeedTarget[1]
			return
		}
		
		if !${Toon.TargetIsBestTarget} && ${Object[${Toon.BestTarget}](exists)} && ${Toon.BestTarget.NotEqual[NULL]}
    {
    	This:Output["Target is no longer best target. Getting new target."]
      Toon:BestTarget
      return
    }
    
    if ${Target.Distance} > ${This.FollowRange}
		{
			This:Output["Target is to far away! ${Target.Distance}"]
			;WoWScript ClearTarget()
			Toon:Stop
			Toon:NextBestTarget
			return
		}
		
		if (${Target.Distance} > ${This.AttackRange}) && (${Target.Distance} < ${This.FollowRange}) && (${Math.Abs[${Target.Z} - ${Me.Z}]} < ${This.MaxHeightDif})
		{
			This:Output["Target is too far away but within follow range, moving closer."]
			Toon:ToRanged
			return
		}
		elseif ${Movement.Speed} && ${Target.Distance} < ${This.AttackRange} - 2
		{
			Toon:Stop
		}
		
		if ${This.NeedFaceForSpell}
		{
			This:FaceForSpellPulse
			return
		}

		if ${This.NeedNoMoreSpell}
		{
			This:NoMoreSpellPulse
			return
		}
		
		if ${This.NeedClassAttack} && ${Target.Type.Equal["player"]} && ${Target.FactionGroup.NotEqual[${Me.FactionGroup}]}
		{
			This:ClassAttackPulse
			return
		}

		if ${This.NeedCombatSpell} && !${This.NeedHealer} && !${This.FriendsChk}
			{
				This:CombatSpellPulse
				return
			}
		
		return
		
	}

  ;******************************************************************************** /
  ;** Need & Pulse Functions                                                      * /
  ;******************************************************************************** /
 
	;** - Rest - ******************************************************************** /
	member NeedRest()
	{
		if ${Me.InCombat}
		{
			return FALSE
		}
		
		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < ${This.RestHP} && ${Item["Conjured Manna Biscuit"](exists)}
		{
			return TRUE
		}
		
		if ${Me.PctMana} < ${This.RestMana} && ${Item["Conjured Manna Biscuit"](exists)}
		{
			return TRUE
		}
		
		if ${Me.PctMana} < ${This.StandMana} && ${Me.Sitting}
		{
			return TRUE
		}
		
		return FALSE
	}
	method RestPulse()
	{
		if ${Me.Casting}
		{
			return
		}
			
		if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
		{
			Toon:Stop
		}
		
		if ${Me.PctHPs} < ${This.RestHP} && !${Me.Sitting} && !${Me.Casting}
		{

			if ${Toon.canCast[Healing Touch]} && ${Me.PctHPs} < ${This.RestMyHealthTouch} 
			{
				Toon:CastSpellGUID[${Me.GUID}, Healing Touch]
				return
			}
			
		}

		if ${Item["Conjured Manna Biscuit"](exists)} && ${Me.PctHPs} < ${This.RestHP} && !${Me.Buff[Food](exists)}
		{
			Item["Conjured Manna Biscuit"]:Use
			return
		}

		if ${Item["Conjured Manna Biscuit"](exists)} && ${Me.PctMana} < ${This.RestMana} && !${Me.Buff[Drink](exists)}
		{
			Item["Conjured Manna Biscuit"]:Use
			return
		}

		if ${Me.Buff[Resurrection Sickness](exists)}
		{
			Toon:Sitdown
			return
		}

		if ${Me.PctHPs} >= ${This.StandHP} && ${Me.Sitting} && ${Me.PctMana} >= ${This.StandMana}
		{
			Toon:Standup
			return
		}
		
	}
	
	;** - Buff Setup - ************************************************************** /
	member NeedBuff()
	{
		
		if ${This.BuffMark} && ${Toon.canBuff[${Me.GUID}, Mark of the Wild]} && !${Me.Buff[Gift of the Wild](exists)}
		{
			return TRUE
		}
		
		if ${This.BuffThorns} && ${Toon.canBuff[${Me.GUID}, Thorns]}
		{
			return TRUE
		}
		
		return FALSE
	}
	method BuffPulse()
	{

		if ${This.BuffMark} && ${Toon.canBuff[${Me.GUID}, Mark of the Wild]} && !${Me.Buff[Gift of the Wild](exists)}
		{
			Toon:CastSpellGUID[${Me.GUID}, Mark of the Wild]
			return
		}
		
		if ${This.BuffThorns} && ${Toon.canBuff[${Me.GUID}, Thorns]}
		{
			Toon:CastSpellGUID[${Me.GUID}, Thorns]
			return
		}
		
	}
	
method BGChk()
{
	if ${WoWScript[GetBattlefieldWinner()](exists)} || ${BG.ShouldLeaveBG}       
	{
		This:Output["Battle Ground Has a Winner, leaving."]
		move -stop
		BG:LeaveBG
	}
	
	return
}
	
	;** - CombatBuff Setup - ******************************************************** /
	member NeedCombatBuff()
	{
		
		if ${This.CombatBuffRacial} && ${This.NeedRacial}
		{
			return TRUE
		}

		if ${This.CombatBuffTrinket} && ${This.NeedTrinket}
		{	
			return TRUE
		}
		
		if ${This.CombatBuffSwiftness} && ${Toon.canCast[Nature's Swiftness]} && ${Me.PctHPs} < 40
		{
			return TRUE
		}
		
		if ${This.CombatBuffBarkskin} && ${Toon.canCast[Barkskin]} && ${Me.PctHPs} < 50 && ${This.PvPAggroWithin[8,TRUE]} > 0
		{
			return TRUE
		}
		
		if ${This.CombatBuffStone} && ${Item[Master Healthstone](exists)} && ${Me.PctHPs} < ${This.CombatBuffMyHealthStone}
		{
			return TRUE
		}
		
		if ${This.CombatBuffInnervate} && ${Toon.canCast[Innervate]} && ${Me.PctMana} < 40
		{
			return TRUE
		}
		
		return FALSE
	}
	
	method CombatBuffPulse()
	{
		
		if ${This.CombatBuffRacial} && ${This.NeedRacial}
		{
			This:RacialPulse
			return
		}

		if ${This.CombatBuffTrinket} && ${This.NeedTrinket}
		{	
			This:TrinketPulse
			return
		}
		
    if ${This.CombatBuffSwiftness} && ${Toon.canCast[Nature's Swiftness]} && ${Me.PctHPs} < 40
		{
			This:Output["DRUID Routine: Using Nature's Swiftness!"]
			Toon:CastSpell[Nature's Swiftness]
			return
		}
		
    if ${This.CombatBuffBarkskin} && ${Toon.canCast[Barkskin]} && ${Me.PctHPs} < 50 && ${This.PvPAggroWithin[5,TRUE]} > 0
		{
			Toon:CastSpellGUID[${Me.GUID}, Barkskin]
			return
		}
		
		if ${This.CombatBuffStone} && ${Item[Master Healthstone](exists)} && ${Me.PctHPs} < ${This.CombatBuffMyHealthStone}
		{
			This:Output["DRUID Routine: Using Master Healthstone!"]
			Item[Master Healthstone]:Use
			return
		}

    if ${This.CombatBuffInnervate} && ${Toon.canCast[Innervate]} && ${Me.PctMana} < 40
		{
			Toon:CastSpellGUID[${Me.GUID}, Innervate]
			return
		}
		
		return
	}
	
	;** - Combat Healing - ********************************************************** /
	member NeedCombatHealing()
	{
		
		if ${Me.Buff[Nature's Swiftness](exists)} && ${Toon.canCast[Healing Touch]} && ${Me.PctHPs} < 70
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 50 && ${Toon.canBuff[${Me.GUID}, Swiftmend]} && ( ${Me.Buff[Rejuvenation](exists)} || ${Me.Buff[Regrowth](exists)} )
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 80 && ${Toon.canBuff[${Me.GUID}, Rejuvenation]} && !${Me.Buff[Rejuvenation](exists)}
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 90 && (${Toon.canBuff[${Me.GUID}, Lifebloom]} || !${Me.Buff[Lifebloom](exists)}) 
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 80 && (${Toon.canBuff[${Me.GUID}, Lifebloom]} || ${Me.Buff[Lifebloom].Application} < 2) 
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 70 && (${Toon.canBuff[${Me.GUID}, Lifebloom]} || ${Me.Buff[Lifebloom].Application} < 3) 
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 60 && ${Toon.canBuff[${Me.GUID}, Regrowth]}
		{
			return TRUE
		}
		
		if ${Me.PctHPs} < 20 && ${Toon.canCast[Healing Touch]}
		{
			return TRUE
		}
		
		return FALSE
	}
	
	method CombatHealingPulse()
	{
		
		if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
		{
			Toon:Stop
		}
		
		if ${Me.Buff[Nature's Swiftness](exists)} && ${Toon.canCast[Healing Touch]} && ${Me.PctHPs} < 50
		{
			This:Output["DRUID Routine: Casting Healing Touch with Nature's Swiftness."]
			Toon:CastSpellGUID[${Me.GUID}, Healing Touch]
			return
		}
		
		if ${Me.PctHPs} < 50 && ${Toon.canBuff[${Me.GUID}, Swiftmend]} && ( ${Me.Buff[Rejuvenation](exists)} || ${Me.Buff[Regrowth](exists)} )
		{
			Toon:CastSpellGUID[${Me.GUID}, Swiftmend]
			return
		}
		
		if ${Me.PctHPs} < 80 && ${Toon.canBuff[${Me.GUID}, Rejuvenation]} && !${Me.Buff[Rejuvenation](exists)}
		{
			Toon:CastSpellGUID[${Me.GUID}, Rejuvenation]
			return
		}
		
		if ${Me.PctHPs} < 90 && ( ${Toon.canBuff[${Me.GUID}, Lifebloom]} || !${Me.Buff[Lifebloom](exists)} ) 
		{
			Toon:CastSpellGUID[${Me.GUID}, Lifebloom]
			return
		}
		
		if ${Me.PctHPs} < 80 && ( ${Toon.canBuff[${Me.GUID}, Lifebloom]} || ${Me.Buff[Lifebloom].Application} < 2 ) 
		{
			Toon:CastSpellGUID[${Me.GUID}, Lifebloom]
			return
		}
		
		if ${Me.PctHPs} < 70 && ( ${Toon.canBuff[${Me.GUID}, Lifebloom]} || ${Me.Buff[Lifebloom].Application} < 3 ) 
		{
			Toon:CastSpellGUID[${Me.GUID}, Lifebloom]
			return
		}

		if ${Me.PctHPs} < 60 && ${Toon.canBuff[${Me.GUID}, Regrowth]}
		{
			Toon:CastSpellGUID[${Me.GUID}, Regrowth]
			return
		}
		
		if ${Me.PctHPs} < 20 && ${Toon.canCast[Healing Touch]}
		{
			Toon:CastSpellGUID[${Me.GUID}, Healing Touch]
			return
		}
		
		return
	}
	
	;** - Combat Spell - ************************************************************ /
	member NeedCombatSpell()
	{
		
		if ${Target.IsTotem} || ${Me.PctMana} < 20 || ${Me.Casting}
		{
			return FALSE
		}
		
		if ${Toon.canBuff[${Target.GUID}, Moonfire]} && ${Toon.canCast[Moonfire]}
		{
			return TRUE
		}

		if ${Toon.canCast[Wrath]}
		{
			return TRUE
		}
		
		return FALSE
	}
	method CombatSpellPulse()
	{
		
		if ${Toon.canBuff[${Target.GUID}, Moonfire]} && ${Toon.canCast[Moonfire]}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Moonfire]
			return
		}

		if ${Toon.canCast[Wrath]}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Wrath]
			return
		}
		
		return
	}
	
	;** - Racial - ****************************************************************** /
	member NeedRacial()
	{
		if ${Toon.canCast[War Stomp]} && ${This.PvPAggroWithin[5,TRUE]} > 0 && ${Me.PctHPs} < 50
		{
			return TRUE
		}
		
		return FALSE
	}
	method RacialPulse()
	{		
		if ${Toon.canCast[War Stomp]} && ${This.PvPAggroWithin[5,TRUE]} > 0 && ${Me.PctHPs} < 50
		{
			This:Output["DRUID Routine: Using War Stomp!"]
			Toon:CastSpell[War Stomp]
		}
		
		return
	}
	
	;** - Prebuff All - ************************************************************* /
	variable bool HookBGPrebuff = TRUE
	member NeedBGPrebuff()
	{
		
		if ${This.PrebuffTable} && ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", ${This.PrebuffTableStacks}]}
		{
			return TRUE
		}
		
		if ${This.PrebuffSoulwell} && ${This.NeedBGObjects["Soulwell","Master Healthstone", 1]}
		{
			return TRUE
		}
		
		if ${This.PrebuffMark} && ${This.NeedSpellOn[friendly, Mark of the Wild, Gift of the Wild]} && !${Movement.Speed}
		{
			return TRUE
		}
		
		if ${This.PrebuffThorns} && ${This.NeedSpellOn[friendly, Thorns]} && !${Movement.Speed}
		{
			return TRUE
		}
		
		return FALSE
	}
	method BGPrebuffPulse()
	{
		
		if ${This.PrebuffTable} && ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", ${This.PrebuffTableStacks}]}
		{
			This:BGObjectsPulse["Refreshment Table","Conjured Manna Biscuit", ${This.PrebuffTableStacks}]
			return
		}
		
		if ${This.PrebuffSoulwell} && ${This.NeedBGObjects["Soulwell","Master Healthstone", 1]}
		{
			This:BGObjectsPulse["Soulwell","Master Healthstone", 1]
			return
		}
		
		if ${This.PrebuffMark} && ${This.NeedSpellOn[friendly, Mark of the Wild, Gift of the Wild]} && !${Movement.Speed}
		{
			This:SpellOnPulse[friendly, Mark of the Wild, Gift of the Wild]
			return
		}
		
		if ${This.PrebuffThorns} && ${This.NeedSpellOn[friendly, Thorns]} && !${Movement.Speed}
		{
			This:SpellOnPulse[friendly, Thorns]
			return
		}

		return
	}
	
	;** - Guarding All - ************************************************************ /
	variable bool HookBGGuard = TRUE
	member NeedBGGuard()
  {
  
   	if ${This.GuardBloom} && ${This.NeedSpellOn[friendly, Lifebloom, none, ${This.GuardTargetHealthBloom}]} && ${Me.PctMana} > ${This.GuardMyManaBloom}
		{
			return TRUE
		}
		
		return FALSE
	}
	method BGGuardPulse()
	{
		
		if ${This.GuardBloom} && ${This.NeedSpellOn[friendly, Lifebloom, none, ${This.GuardTargetHealthBloom}]} && ${Me.PctMana} > ${This.GuardMyManaBloom}
		{
			This:SpellOnPulse[friendly, Lifebloom, none, ${This.GuardTargetHealthBloom}]
			return
		}
		
		return
	}
	
	;** - Healer - ****************************************************************** /
	member NeedHealer()
	{

		if ${This.HealerRejuvenation} && ${This.NeedSpellOn[friendly, Rejuvenation, none, ${This.HealerTargetHealthRejuvenation}, 0, 35]} && ${Me.PctMana} > ${This.HealerMyManaRejuvenation}
		{
			return TRUE
		}
		
		if ${This.HealerRegrowth} && ${This.NeedSpellOn[friendly, Regrowth, none, ${This.HealerTargetHealthRegrowth}]} && ${Me.PctMana} > ${This.HealerMyManaRegrowth}
		{
			return TRUE
		}
		
		if ${This.HealerBloom} && ${This.NeedSpellOn[friendly, Lifebloom, none, ${This.HealerTargetHealthBloom}, 0, 35, 3]} && ${Me.PctMana} > ${This.HealerMyManaBloom}
		{
			return TRUE
		}
		
		if ${This.HealerTouch} && ${This.NeedSpellOn[friendly, Healing Touch, none, ${This.HealerTargetHealthTouch}]} && ${Me.PctMana} > ${This.HealerMyManaTouch}
		{
			return TRUE
		}
				
		return FALSE
	}
	
	method HealerPulse()
	{
		
		if ${This.HealerRejuvenation} && ${This.NeedSpellOn[friendly, Rejuvenation, none, ${This.HealerTargetHealthRejuvenation}, 0, 35]} && ${Me.PctMana} > ${This.HealerMyManaRejuvenation}
		{
			This:SpellOnPulse[friendly, Rejuvenation, none, ${This.HealerTargetHealthRejuvenation}, 0, 35]
			return
		}

		if ${This.HealerRegrowth} && ${This.NeedSpellOn[friendly, Regrowth, none, ${This.HealerTargetHealthRegrowth}]} && ${Me.PctMana} > ${This.HealerMyManaRegrowth}
		{
			This:SpellOnPulse[friendly, Regrowth, none, ${This.HealerTargetHealthRegrowth}]
			return
		}
		
		if ${This.HealerBloom} && ${This.NeedSpellOn[friendly, Lifebloom, none, ${This.HealerTargetHealthBloom}, 0, 35, 3]} && ${Me.PctMana} > ${This.HealerMyManaBloom}
		{
			This:SpellOnPulse[friendly, Lifebloom, none, ${This.HealerTargetHealthBloom}, 0, 35, 3]
			return
		}

		if ${This.HealerTouch} && ${This.NeedSpellOn[friendly, Healing Touch, none, ${This.HealerTargetHealthTouch}]} && ${Me.PctMana} > ${This.HealerMyManaTouch}
		{
			This:SpellOnPulse[friendly, Healing Touch, none, ${This.HealerTargetHealthTouch}]
			return
		}
		
		return
	}
	
	;** - Dead Setup - ************************************************************** /
	member NeedDead()
	{
		return FALSE
	}
	method DeadPulse()
	{
		return
	}
	
	;** - Trinket - ***************************************************************** /
	member NeedTrinket()
	{
		if ${Item[${TrinketName1}](exists)} && ${Me.Action[${TrinketName1}].Usable} && ${Me.PctHPs} < ${This.TrinketMyHealth1} && ${Me.PctMana} < ${This.TrinketMyMana1} && ( !${This.TrinketPvP1} || ${This.TrinketPvPDebuff} )
		{
			return TRUE
		}
		
		if ${Item[${TrinketName2}](exists)} && ${Me.Action[${TrinketName2}].Usable} && ${Me.PctHPs} < ${This.TrinketMyHealth2} && ${Me.PctMana} < ${This.TrinketMyMana2} && ( !${This.TrinketPvP2} || ${This.TrinketPvPDebuff} )
		{
			return TRUE
		}
		
		return FALSE
	}
	
	method TrinketPulse()
	{
		if ${Item[${TrinketName1}](exists)} && ${Me.Action[${TrinketName1}].Usable} && ${Me.PctHPs} < ${This.TrinketMyHealth1} && ${Me.PctMana} < ${This.TrinketMyMana1} && ( !${This.TrinketPvP1} || ${This.TrinketPvPDebuff} )
		{
			This:Output["DRUID Routine: Using Trinket ${TrinketName1}"]
			Item[${TrinketName1}]:Use
			return
		}
		
		if ${Item[${TrinketName2}](exists)} && ${Me.Action[${TrinketName2}].Usable} && ${Me.PctHPs} < ${This.TrinketMyHealth2} && ${Me.PctMana} < ${This.TrinketMyMana2} && ( !${This.TrinketPvP2} || ${This.TrinketPvPDebuff} )
		{
			This:Output["DRUID Routine: Using Trinket ${TrinketName2}"]
			Item[${TrinketName2}]:Use
			return
		}
		
		return
	}

;** - SpellOn - ***************************************************************** /
	variable objectref kPlayer
	member NeedSpellOn(string unityp="all", string name1="none", string name2="none", int value1=0, int value2=0, int kMinRange=0, int kMaxRange=25)
	{
		variable int i = 1
		variable guidlist kPlayerList

		kPlayerList:Search[-players, -${unityp}, -noself, -alive, -lineofsight, -range ${kMinRange}-${kMaxRange}]
    
		i:Set[1]
		if ${kPlayerList.Count}
		{
			do
			{
				kPlayer:Set[${kPlayerList.Object[${i}].GUID}]

				if !${kPlayer.Buff[${name1}](exists)}&& ${Toon.canCast[${name1}]} && (!${kPlayer.Buff[${name2}](exists)} || ${name2.Equal["none"]}) && (${kPlayer.PctHPs} < ${value1} || !${value1}) && (${kPlayer.PctHPs} > ${value2} || !${value2})
				{
					return TRUE
				}
			}
			while ${i:Inc} <= ${kPlayerList.Count}
		}
		kPlayerList:Clear

		return FALSE
	}
	method SpellOnPulse(string unityp, string name1="none", string name2="none", int value1=0, int value2=0, int kRange=25, int kApply=0)
	{
		variable int i = 1
		variable guidlist kPlayerList
		variable objectref kPlayer

		kPlayerList:Search[-players, -${unityp}, -noself, -alive, -lineofsight, -range ${kMinRange}-${kMaxRange}]

		i:Set[1]
		if ${kPlayerList.Count}
		{
			do
			{
				kPlayer:Set[${kPlayerList.Object[${i}].GUID}]
				
				if (!${kPlayer.Buff[${name1}](exists)} || ${kPlayer.Buff[${name1}](exists)} && ${kPlayer.Buff[${name1}].Application} < ${kApply}) && ${Toon.canCast[${name1}]} && (!${kPlayer.Buff[${name2}](exists)} || ${name2.Equal["none"]}) && (${kPlayer.PctHPs} < ${value1} || !${value1}) && (${kPlayer.PctHPs} > ${value2} || !${value2})
				{
					Toon:CastSpellGUID[${kPlayer}, ${name1}]
					if ${WoWScript[SpellIsTargeting()]}
					{
						WoWScript SpellStopTargeting()
					}
					
					return
				}
			}
			while ${i:Inc} <= ${kPlayerList.Count}
		}
		kPlayerList:Clear

		return
	}
	;** - NeedClassAttack - ********************************************************* /
	member NeedClassAttack()
	{
		;--- All Class -----------------------------------------------------------
		
		;--- Druid ---------------------------------------------------------------
		if ${Target.Class.Equal["Druid"]}
		{
		}
		;--- Hunter --------------------------------------------------------------
		if ${Target.Class.Equal["Hunter"]}
		{
		}
		;--- Mage ----------------------------------------------------------------
		if ${Target.Class.Equal["Mage"]}
		{
		}
		
		;--- Paladin -------------------------------------------------------------
		if ${Target.Class.Equal["Paladin"]}
		{
		}
		
		;--- Priest --------------------------------------------------------------
		if ${Target.Class.Equal["Priest"]}
		{
		}
		
		;--- Rogue ---------------------------------------------------------------
		if ${Target.Class.Equal["Rogue"]}
		{
			if !${Target.Buff[Faerie Fire](exists)} && ${Toon.canBuff[${Target.GUID}, Faerie Fire]}
			{
				return TRUE
			}
			if !${Target.Buff[Entangling Roots](exists)} && ${Toon.canCast[Entangling Roots]} && !${Movement.Speed} && !${Me.Casting} && ${Target.Target.GUID.NotEqual[${Me.GUID}]}
			{
				return TRUE
			}
		}
		
		;--- Shaman --------------------------------------------------------------
		if ${Target.Class.Equal["Shaman"]}
		{
		}
		
		;--- Warlock -------------------------------------------------------------
		if ${Target.Class.Equal["Warlock"]}
		{
		}
		
		;--- Warrior -------------------------------------------------------------
		if ${Target.Class.Equal["Warrior"]}
		{
			if !${Target.Buff[Entangling Roots](exists)} && ${Toon.canCast[Entangling Roots]} && !${Movement.Speed} && !${Me.Casting} && ${Target.Target.GUID.NotEqual[${Me.GUID}]}
			{
				return TRUE
			}
		}
		
		return FALSE
	}
	method ClassAttackPulse()
	{	
		;--- All Class -----------------------------------------------------------

		;--- Druid ---------------------------------------------------------------
		if ${Target.Class.Equal["Druid"]}
		{
			return
		}
		;--- Hunter --------------------------------------------------------------
		if ${Target.Class.Equal["Hunter"]}
		{
			return
		}
		;--- Mage ----------------------------------------------------------------
		if ${Target.Class.Equal["Mage"]}
		{
			return
		}
		;--- Paladin -------------------------------------------------------------
		if ${Target.Class.Equal["Paladin"]}
		{
			return
		}
		
		;--- Priest --------------------------------------------------------------
		if ${Target.Class.Equal["Priest"]}
		{
			return
		}
		
		;--- Rogue ---------------------------------------------------------------
		if ${Target.Class.Equal["Rogue"]}
		{
			if !${Target.Buff[Faerie Fire](exists)} && ${Toon.canBuff[${Target.GUID}, Faerie Fire]}
			{
				Toon:CastSpellGUID[${Target.GUID},  Faerie Fire]
				return
			}
			if !${Target.Buff[Entangling Roots](exists)} && ${Toon.canCast[Entangling Roots]} && !${Movement.Speed} && !${Me.Casting} && ${Target.Target.GUID.NotEqual[${Me.GUID}]}
			{
				Toon:CastSpellGUID[${Target.GUID},  Entangling Roots]
				return
			}
		}
		
		;--- Shaman --------------------------------------------------------------
		if ${Target.Class.Equal["Shaman"]}
		{
			return
		}
		
		;--- Warlock -------------------------------------------------------------
		if ${Target.Class.Equal["Warlock"]}
		{
			return
		}
		
		;--- Warrior -------------------------------------------------------------
		if ${Target.Class.Equal["Warrior"]}
		{
			if !${Target.Buff[Entangling Roots](exists)} && ${Toon.canCast[Entangling Roots]} && !${Movement.Speed} && !${Me.Casting} && ${Target.Target.GUID.NotEqual[${Me.GUID}]}
			{
				Toon:CastSpellGUID[${Target.GUID},  Entangling Roots]
				return
			}
		}
	
		return
	}
	
	;** - BGObjects Get - *********************************************************** /
	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}]
				if ${UseableObject.Name.Equal[${objectName}]} && ${Consumable.ItemX[${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}]} && ${Consumable.ItemX[${objectItem}]} < ${objectValue}
				{
					if ${UseableObject.Distance} > 4 && !${Navigator.MovingToPoint[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]}
					{
						This:Output["DRUID Routine: Moving towards ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
						Navigator:MoveToLoc[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]
					}
					
					if ${UseableObject.Distance} < 4
					{
						Toon:Stop
						This:Output["DRUID Routine: Inventory ${Consumable.ItemX[${objectItem}]} ${objectItem} of Stacks!"]
						This:Output["DRUID Routine: Using ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
						UseableObject:Use
						Bot.RandomPause:Set[16]
					}
					
					return
				}

			}
			while ${i:Inc} <= ${objectref.Count}
		}
		UsableObjs:Clear

		return
	}
	
	;** - FaceForSpell - ************************************************************ /
	member NeedFaceForSpell()
	{
		variable string currentSpell
		
		currentSpell:Set[${WoWScript[UnitCastingInfo("player")]}]
		
    if ${currentSpell.Equal[Wrath]}
    {
        return TRUE
    }
    
    return FALSE
	}
	method FaceForSpellPulse()
	{
		if ${Movement.Speed}
		{
			return
		}
		Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		return
	}
	
	;** - NoMoreSpell - ************************************************************* /
	member NeedNoMoreSpell()
	{
		variable string currentSpell
		
		currentSpell:Set[${WoWScript[UnitCastingInfo("player")]}]
		
    if ${Object[${Target.GUID}].Buff[${currentSpell}](exists)}
    {
        return TRUE
    }
    
    if ${currentSpell.Equal[Wrath]} && ( ${This.NeedCombatHealing} || ${This.NeedHealer} )
    {
        return TRUE
    }
    
    return FALSE
	}
	method NoMoreSpellPulse()
	{
		WoWScript SpellStopCasting()
		return
	}
	
	;Friends check
	variable objectref kFriendsList
	member FriendsChk()
	{    
	  variable guidlist kFriendsList
    kFriendsList:Search[-players, -friendly, -noself, -alive, -range 0-40]
    
    if ${kFriendsList.Count} <= ${This.Friends}
    {
      This:Output["No friends to heal, moving on. ${kFriendsList.Count}"]
      return FALSE
    }
    return TRUE
	}
	
	;******************************************************************************** /
  ;** Functions, no code                                                          * /
  ;******************************************************************************** /
	;** - Assist Mode - ************************************************************* /
	;** - Flee Setup - ************************************************************** /
	;** - Idle Setup - ************************************************************** /
	;** - Event Hooking - *********************************************************** /
  ;** - CombatEvent - ************************************************************* /
  ;******************************************************************************** /

	;** - Assist Mode - ************************************************************* /
	member IsAssistMode()
	{
		; returns a check that determines if the bot is in party mode
		if ${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
			return TRUE

		return FALSE
	}

	;** - Flee Setup - ************************************************************** /
	variable bool HookFlee = FALSE
	method FleePulse()
	{
		
	}

	;** - Idle Setup - ************************************************************** /
	variable bool NeedCombatIdle = FALSE
	method CombatIdle()
	{

		return
	}

	;** - Event Hooking - *********************************************************** /
	variable bool needUIHook = TRUE
	method UIErrorMessage(string Id, string Msg)
	{
		
	}

  ;** - CombatEvent - ************************************************************* /
	variable bool needCombatHook = TRUE
	method CombatEvent(string unitID, string unitAction, string isCrit, string amtDamage, string damageType)
	{
		
	}
  
  ;******************************************************************************** /
  ;** Special Functions                                                           * /
  ;******************************************************************************** /
	;** - Inventory Counter Items - ************************************************* /
	;** - CustOutput - ************************************************************** /
	;** - PvPAggroWithin - ********************************************************** /
	;** - myWait - ****************************************************************** /
	;** - debuffAll - *************************************************************** /
	;** - canBuff - ***************************************************************** /
  ;******************************************************************************** /

	;** - PvP Trinket Debuffed - **************************************************** /
	member TrinketPvPDebuff()
	{
		if ${Me.Buff[Fear](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Psychic Scream](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Howl of Terror](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Intimidating Shout](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Polymorph](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Freezing Trap Effect](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Wyvern Sting](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Charge Stun](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Hammer Stun](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Intercept Stun](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Mace Stun Effect](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Shield Charge Stun](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Stun](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Blast Wave](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Dragon's Breath](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Repentance](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Hammer of Justice](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Bash](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Scatter Shot](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Blackout](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Cheap Shot](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Concussion Blow](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Intimidation](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Improved Concussive Shot](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Kidney Shot](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Blind](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Cyclone](exists)}
		{
			return TRUE
		}
		
		if ${Me.Buff[Gouge](exists)}
		{
			return TRUE
		}
		
		return FALSE
	}
	
	;** - DispelBuff - ************************************************************** /
	/* 
		TODO: Add all Debuffs & Buffs
	*/
	member DispelBuff(string theGUID)
	{

		
		return FALSE
	}
	
	;** - CustOutput - ************************************************************** /
	method CustOutput(string Txt)
	{
		UIElement[ClassGUI].FindChild[Pages].FindChild[Output].FindChild[Console]:Echo["${Txt}"]
		return
	}
	
	;** - PvPAggroWithin - ********************************************************** /
	member PvPAggroWithin(int Range, bool TargetingMe = FALSE)
	{
		variable guidlist Aggros
		if ${TargetingMe}
		{
			Aggros:Search[-players,-pvp,-targetingme,-alive,-notflying,-lineofsight,-notmounted,-attackable,-range 0-${Range}]
		}
		else
		{
			Aggros:Search[-players,-pvp,-alive,-notflying,-lineofsight,-notmounted,-attackable,-range 0-${Range}]
		}
		
		return ${Aggros.Count}
	}
	
	;** - myWait - ****************************************************************** /
	variable int myTimer = 0
	member myWait()
	{
		if ${This.myTimer} < ${LavishScript.RunningTime}
		{
			This.myTimer:Set[${This.InSeconds[3]}]
			return TRUE
		}
		
		return FALSE
	}

	;******************************************************************************** /
  ;** Gui Functions                                                               * /
  ;******************************************************************************** /
	;** - Initialize - ************************************************************** /
	;** - Shutdown - **************************************************************** /
	;** - GUI Setup - *************************************************************** /
	;** - SaveGUI - ***************************************************************** /
  ;******************************************************************************** /

	;** - Initialize - ************************************************************** /
	method Initialize()
	{
		This:Output["Darkfriend's DRUID Routine STARTED - Modified by Moi!"]
	}
	;** - Init Druid GUI - ********************************************************* /
	method InitDruidGUI()
	{
	}

	;** - Class GUI Change - ******************************************************** /
	method ClassGUIChange(string Action)
	{
	}
	;** - Shutdown - **************************************************************** /
	method Shutdown()
	{
	}

	;** - GUI Setup - *************************************************************** /
	method SetGUI()
	{
	}

	;** - SaveGUI - ***************************************************************** /
	method SaveGUI()
	{
	}
	
}