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

	;--- Rest
	variable int RestMana								= 35
	variable int StandMana 							= 85
	
	variable int RestHP									= 70
	variable int StandHP								= 80
	
	;--- Range
	variable int AttackRange          	= 40
	variable int FollowRange						= 50
	
	;--- Trinkets
	variable string TrinketName1				= "Battlemaster's Audacity"
	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				= "Medallion of the Horde"
	variable int TrinketMyHealth2				= 50													/* 100 for always use*/
	variable int TrinketMyMana2					= 100 												/* 100 for always use*/
	variable int TrinketPvP2						= TRUE												/* Only PvP Trinket   */
	
	;--- Prebuff
	variable bool	usePrebuffTable							= TRUE
	variable int	PrebuffTableStacks					= 10
	variable bool	usePrebuffSoulwell					= TRUE
	
	;--- CombatBuff
	variable bool useCombatBuffRacial					= TRUE
	variable bool useCombatBuffTrinket				= TRUE
	variable bool useCombatBuffStone					= TRUE
	variable int  CombatBuffMyHealthStone			= 20
	variable bool useCombatBuffStandards			= TRUE
	variable string Standards									= "Frostwolf Battle Standard"
	;--- Buff
	variable bool useBuffAspect								= TRUE
	variable string BuffAspect								= "Aspect of the Hawk"
	
	;--- Melee
	variable bool useMeleeTrap								= TRUE
	variable string MeleeTrap									= "Frost Trap"
	variable bool useMeleeMongoose						= TRUE
	variable bool useMeleeWing								= TRUE
	variable bool useMeleeRaptor							= TRUE

	;--- Shot
	variable bool useShotAimed								= TRUE
	variable bool useShotArcane								= TRUE
	variable bool useShotMulti								= TRUE
	variable bool useShotConcussive						= TRUE
	variable bool useShotSteady								= TRUE
	variable bool useShotSting								= TRUE
	variable string ShotSting									= "Serpent Sting"
	variable bool useShotTrap									= TRUE
	variable string ShotTrap									= "Snake Trap"
	
	;--- Guard
	variable bool useGuardTrap								= TRUE
	variable string GuardTrap									= "Freezing Trap"
  variable bool useGuardFlare								= TRUE
  
  ;-------------------------------------------------------------------------------- /
	;*** DO NOT TOUCH VARIABLES BELOW ***
	;--- Flags
	variable bool OutOfAmmo						 				= FALSE												/* will be set TRUE if we have run out of ammo */
	variable bool NeedCallPet 								= TRUE												/* TRUE: try call pet, FALSE: rez pet					 */
	variable bool NoPet 											= FALSE												/* set when we do not have a pet							 */
	;--- Timers
	variable int LastPetCallTime 							= ${LavishScript.RunningTime}	/* last time we tried to call our pet					 */
  variable int LastFlareTime 								= ${LavishScript.RunningTime}	/* last time we flared the ground    					 */
  variable int LastPetAttackTime						= ${LavishScript.RunningTime}	/* last time we sended pet out to attack		   */
 	variable int LastSteadyShotTime					  = ${LavishScript.RunningTime} /* last time we Shot steady              		   */
 	variable int LastStingTime    		 				= ${LavishScript.RunningTime}	/* last time we stinged                 		   */
  ;******************************************************************************** /
  ;** Pull & Attack Functions                                                     * /
  ;******************************************************************************** /
	;** - Pull Setup - ************************************************************** /
	;** - Attack Setup - ************************************************************ /
  ;******************************************************************************** /

	;** - Pull Setup - ************************************************************** /
	variable int RandomPull = 99

	method PullPulse()
	{
		if ${Me.InCombat} || ${Me.Casting}
			return
			
		if !${Toon.ValidTarget[${Target.GUID}]}
    {
    	This:Output["Need a target"]
      Toon:NeedTarget[1]
      return
    }
    
    if !${Toon.TargetIsBestTarget}
    {
    	This:Output["Target is no longer best target. Getting new target. Calling Pet back."]
      Toon:BestTarget
      WoWScript PetFollow()
      return
    }
		
		if ${Target.Distance} > ${This.FollowRange}
		{
			This:Output["Target is to far away! ${Target.Distance}  Calling Pet back."]
			WoWScript ClearTarget()
			Toon:Stop
			Toon:NextBestTarget
			WoWScript PetFollow()
			return
		}

		if ${Target.Distance} > ${This.AttackRange}
		{
			This:Output["Target is to far away, moving closer."]
			Toon:ToRanged
			return
		}
		elseif !${Target.LineOfSight}
		{
			This:Output["Target is out of sight! ${Target.LineOfSight}."]
			Toon:ToMelee
			return
		}
		elseif ${Movement.Speed} && ${Target.Distance} < ${This.AttackRange} - 2
		{
			Toon:Stop
		}
		
		if ${This.NeedPetCommand}
		{
			This:PetCommandPulse
			return
		}
		
		if ${This.NeedFaceForSpell}
		{
			This:FaceForSpellPulse
			return
		}
		
		if ${Target.Distance} < 5
		{
			if ${This.NeedMelee}
			{
				This:MeleePulse
				return
			}
			elseif !${Me.Attacking}
			{
				WoWScript AttackTarget()
				return
			}
		}
		
		if ${This.OutOfAmmo}
		{
			Toon:ToMelee
			return
		}
		
		if ${Me.Action[Auto Shot].Usable}
		{
			if ${This.NeedShot}
			{
				This:ShotPulse
				return
			}
		}

		return
	}
	
	;** - Attack Setup - ************************************************************ /
	method AttackPulse()
	{
		
		if !${Toon.ValidTarget[${Target.GUID}]} || !${Me.Target(exists)}
		{
			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. Calling Pet back."]
      Toon:BestTarget
      WoWScript PetFollow()
      return
    }
		
		if ${Target.Distance} > ${This.FollowRange}
		{
			This:Output["Target is to far away! ${Target.Distance}  Calling Pet back."]
			WoWScript ClearTarget()
			Toon:Stop
			Toon:NextBestTarget
			WoWScript PetFollow()
			return
		}
		
		if ${Target.Distance} > ${This.AttackRange}
		{
			This:Output["Target is to far away, moving closer."]
			Toon:ToRanged
			return
		}
		elseif !${Target.LineOfSight}
		{
			This:Output["Target is out of sight! ${Target.LineOfSight}."]
			Toon:ToMelee
			return
		}
		elseif ${Movement.Speed} && ${Target.Distance} < ${This.AttackRange} - 2
		{
			Toon:Stop
		}
		
		if ${This.NeedPetCommand}
		{
			This:PetCommandPulse
			return
		}
		
		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 ${Target.Distance} < 5
		{
			if ${This.NeedMelee}
			{
				This:MeleePulse
				return
			}
		}
		
		if ${This.OutOfAmmo}
		{
			Toon:ToMelee
			return
		}
		
		if ${Me.Action[Auto Shot].Usable}
		{
			if ${This.NeedShot}
			{
				This:ShotPulse
				return
			}
		}
		else
		{
			if ${This.NeedRandomMove}
			{
				This:RandomMovePulse
			}
			Toon:ToRanged
			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 ${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 ${useBuffAspect} && ${Toon.canBuff[${Me.GUID}, ${BuffAspect}]}
		{
			return TRUE
		}
		
		return FALSE
	}
	method BuffPulse()
	{
		if ${useBuffAspect} && ${Toon.canBuff[${Me.GUID}, ${BuffAspect}]}
		{
			Toon:CastSpellGUID[${Me.GUID}, ${BuffAspect}]
			return
		}
		
		return
	}
	
	;** - Pull Setup - ************************************************************** /
	member NeedPullBuff()
	{

		return FALSE
	}
	method PullBuffPulse()
	{
		
		return
	}
	
	;** - CombatBuff Setup - ******************************************************** /
	member NeedCombatBuff()
	{
		
		if ${useCombatBuffRacial} && ${This.NeedRacial}
		{
			return TRUE
		}

		if ${useCombatBuffTrinket} && ${This.NeedTrinket}
		{	
			return TRUE
		}

		if ${useCombatBuffStone} && ${Item[Master Healthstone](exists)} && ${Me.PctHPs} < ${This.CombatBuffMyHealthStone}
		{
			return TRUE
		}
		
		if ${useCombatBuffStandards} && ${Item[${Standards}](exists)} && ${Me.Action[${Standards}].Usable} && ${Target.Classification.Equal[Elite]}
		{
			return TRUE
		}

		if ${Toon.canCast[Bestial Wrath]} && ${Me.Target.PctHPs} > 70
		{
			return TRUE
		}
		
		if ${Toon.canCast[Rapid Fire]} && ${Me.Target.PctHPs} > 60
		{
			return TRUE
		}

		return FALSE
	}
	method CombatBuffPulse()
	{
		
		if ${useCombatBuffRacial} && ${This.NeedRacial}
		{
			This:RacialPulse
			return
		}

		if ${useCombatBuffTrinket} && ${This.NeedTrinket}
		{	
			This:TrinketPulse
			return
		}
		
		if ${useCombatBuffStone} && ${Item[Master Healthstone](exists)} && ${Me.PctHPs} < ${This.CombatBuffMyHealthStone}
		{
			This:Output["Using Master Healthstone!"]
			Item[Master Healthstone]:Use
			return
		}

		if ${useCombatBuffStandards} && ${Item[${Standards}](exists)} && ${Me.Action[${Standards}].Usable} && ${Target.Classification.Equal[Elite]}
		{
			This:CustOutput["Using Standards ${Standards} to help on ${Target.Name}!"]
			Item[${Standards}]:Use
			return
		}
		
		if ${Toon.canCast[Bestial Wrath]} && ${Me.Target.PctHPs} > 70
		{
			This:Output["Casting Bestial Wrath, AAAAAATTTTTACK!"]
			Toon:CastSpell[Bestial Wrath]
			return
		}
		
		if ${Toon.canCast[Rapid Fire]} && ${Me.Target.PctHPs} > 60
		{
			This:Output["Casting Rapid Fire, Shot after Shot gona kick ${Target.Name}'s Ass now...!"]
			Toon:CastSpell[Rapid Fire]
			return
		}
		
		return
	}
	
	;** - Pet Action - ************************************************************** /
	member NeedPetCommand()
	{
		if ${This.NoPet} || ${This.PetDead}
		{
			return FALSE
		}

		if  ${Toon.canCast[Mend Pet]} && !${Me.Pet.Buff[Mend Pet](exists)} && ${Me.Pet.PctHPs} < 30 
		{
			return TRUE
		}
		
		if ${Me.Pet.Target.GUID.Equal[${Target.GUID}]} && ${This.isCCed[${Target.GUID}, "root"]} || ${This.isCCed[${Target.GUID}, "immo"]} || ${This.isCCed[${Target.GUID}, "fear"]}
		{
			return TRUE
		}
		
		if !${Me.Pet.Target.GUID.Equal[${Target.GUID}]} && ${This.LastPetAttackTime} < ${LavishScript.RunningTime} - 2000 
		{
			return TRUE
		}

		if ${Me.Pet.Target.GUID.Equal[${Target.GUID}]}
		{
			if ${Me.Action[Intimidation].Usable}
			{
				return TRUE
			}
			
			if ${Me.Action[Kill Command].Usable}
			{
				return TRUE
			}
		}

		return FALSE
	}
	method PetCommandPulse()
	{
		if  ${Toon.canCast[Mend Pet]} && !${Me.Pet.Buff[Mend Pet](exists)} && ${Me.Pet.PctHPs} < 30 
		{
			This:Output["Casting: Mend Pet on Pet (${Me.Pet.Name})"]
			Toon:CastSpell[Mend Pet]
			return
		}

		if ${Me.Pet.Target.GUID.Equal[${Target.GUID}]} && ${This.isCCed[${Target.GUID}, "root"]} || ${This.isCCed[${Target.GUID}, "immo"]} || ${This.isCCed[${Target.GUID}, "fear"]}
		{
			This:Output["Calling Pet back ${Target.Name} is CCed"]
			WoWScript PetFollow()
			return
		}

		if !${Me.Pet.Target.GUID.Equal[${Target.GUID}]} && ${This.LastPetAttackTime} < ${LavishScript.RunningTime} - 2000 
		{
			This:Output["Casting: PetAttack on ${Target.Name}"]
			WoWScript PetAttack()
			LastPetAttackTime:Set[${LavishScript.RunningTime}]
			return
		}
		
		if ${Me.Pet.Target.GUID.Equal[${Target.GUID}]}
		{
			if ${Me.Action[Intimidation].Usable}
			{
				Toon:CastSpellGUID[${Target.GUID}, Intimidation]
				return
			}
			
			if ${Me.Action[Kill Command].Usable}
			{
				Toon:CastSpellGUID[${Target.GUID}, Kill Command]
				return
			}
		}
		
		return
	}
	
	;** - Melee - ******************************************************************* /
	member NeedMelee()
	{
		
		if ${Target.IsTotem} || ${Me.Casting}
		{
			return FALSE
		}

		if ${useMeleeTrap} && ${Toon.canCast[${MeleeTrap}]}
		{
			return TRUE
		}

		if ${This.isCCed[${Target.GUID}, "root"]} || ${This.isCCed[${Target.GUID}, "immo"]} || ${This.isCCed[${Target.GUID}, "fear"]}
		{
			return FALSE
		}
		
		if ${useMeleeMongoose} && ${Toon.canCast[Mongoose Bite]} && ${Me.Action[Mongoose Bite].Usable}
		{
			return TRUE
		}
		
		if ${useMeleeWing} && ${Toon.canCast[Wing Clip]} && ${Toon.canBuff[${Target.GUID}, Wing Clip]} && ${Toon.isFacingAway}
		{
			return TRUE
		}
		
		if ${useMeleeRaptor} && ${Toon.canCast[Raptor Strike]}
		{
			return TRUE
		}
		
		if !${Me.Attacking}
		{
			return TRUE
		}
		

		return FALSE
	}
	method MeleePulse()
	{

		if ${useMeleeTrap} && ${Toon.canCast[${MeleeTrap}]}
		{
			This:Output["Casting: ${MeleeTrap} to trap?! ${Target.Name}"]
			Toon:CastSpell[${MeleeTrap}]
			return
		}
		
		if ${useMeleeMongoose} && ${Toon.canCast[Mongoose Bite]} && ${Me.Action[Mongoose Bite].Usable}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Mongoose Bite]
			return
		}
		
		if ${useMeleeWing} && ${Toon.canCast[Wing Clip]} && ${Toon.canBuff[${Target.GUID}, Wing Clip]} && ${Toon.isFacingAway}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Wing Clip]
			return
		}
		
		if ${useMeleeRaptor} && ${Toon.canCast[Raptor Strike]}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Raptor Strike]
			return
		}
		
		if !${Me.Attacking}
		{
			WoWScript AttackTarget()
			return
		}

		return
	}
	
	;** - Shot - ******************************************************************** /
	member NeedShot()
	{
		
		if ${Target.IsTotem} || ${Me.Casting} || ${This.OutOfAmmo}
		{
			return FALSE
		}

		if ${useShotAimed} && ${Toon.canCast[Aimed Shot]} && ${This.PvPAggroWithin[15, TRUE]} < 1 || !${Me.InCombat}
		{
			return TRUE
		}
		
		if ${useShotArcane} && ${Toon.canCast[Arcane Shot]}
		{
			return TRUE
		}
		
		if ${useShotMulti} && ${Toon.canCast[Multishot]} && ${This.PvPAggroWithin[30, FALSE]} > 3
		{
			return TRUE
		}
	
		if ${useShotConcussive} && ${Toon.canCast[Concussive Shot]} && ${Toon.canBuff[${Target.GUID}, Concussive Shot]}
		{
			return TRUE
		}

		if ${useShotSteady} && ${Toon.canCast[Steady Shot]} && ${Me.Buff[Concussive Shot](exists)} && ${This.PvPAggroWithin[15, TRUE]} < 1 && ${This.LastSteadyShotTime} < ${LavishScript.RunningTime} - 15000 
		{
			return TRUE
		}
	
		if ${useShotSting} && ${Toon.canCast[${ShotSting}]} && ${Toon.canBuff[${Target.GUID}, ${ShotSting}]}  && ${This.LastStingTime} < ${LavishScript.RunningTime} - 15000 
		{
			return TRUE
		}

		if ${useShotTrap} && ${Toon.canCast[${ShotTrap}]}
		{
			return TRUE
		}

		if !${Me.Action[Auto Shot].AutoRepeat}
		{
			return TRUE
		}

		return FALSE
	}
	method ShotPulse()
	{
		if ${useShotAimed} && ${Toon.canCast[Aimed Shot]} && ${This.PvPAggroWithin[15, TRUE]} < 1
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Aimed Shot]
			return
		}
		
		if ${useShotArcane} && ${Toon.canCast[Arcane Shot]}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Arcane Shot]
			return
		}
		
		if ${useShotMulti} && ${Toon.canCast[Multishot]} && ${This.PvPAggroWithin[30, FALSE]} > 3
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Multishot]
			return
		}
	
		if ${useShotConcussive} && ${Toon.canCast[Concussive Shot]} && ${Toon.canBuff[${Target.GUID}, Concussive Shot]}
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Concussive Shot]
			return
		}

		if ${useShotSteady} && ${Toon.canCast[Steady Shot]} && ${Me.Buff[Concussive Shot](exists)} && ${This.PvPAggroWithin[15, TRUE]} < 1 && ${This.LastSteadyShotTime} < ${LavishScript.RunningTime} - 15000 
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, Steady Shot]
			LastSteadyShotTime:Set[${LavishScript.RunningTime}]
			return
		}
	
		if ${useShotSting} && ${Toon.canCast[${ShotSting}]} && ${Toon.canBuff[${Target.GUID}, ${ShotSting}]}  && ${This.LastStingTime} < ${LavishScript.RunningTime} - 15000 
		{
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpellGUID[${Target.GUID}, ${ShotSting}]
			LastStingTime:Set[${LavishScript.RunningTime}]
			return
		}
		
		if ${useShotTrap} && ${Toon.canCast[${ShotTrap}]}
		{
			This:Output["Casting: ${ShotTrap} to kick ... whatever to ${Target.Name}"]
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
			Toon:CastSpell[${ShotTrap}]
			return
		}

		if !${Me.Action[Auto Shot].AutoRepeat}
		{
			Toon:CastSpellGUID[${Target.GUID}, Auto Shot]
			return
		}
		
		return
	}

	;** - Racial - ****************************************************************** /
	member NeedRacial()
	{
		;--- Blood Elf
		if ${Toon.canCast[Arcane Torrent]} && ${Me.Buff[Mana Tap].Application} < 3 && ${Me.Target.PctMana} > 0
			return TRUE
		if ${Toon.canCast[Mana Tap]} && ${Target.Casting(exists)} && ${Target.Distance} < 10 && ${Me.Target.PctMana} > 0
			return TRUE
		;--- Tauren
		if ${Toon.canCast[War Stomp]} && ( ${Target.Casting(exists)} && ${Target.Distance} < 8 || ${This.PvPAggroWithin[8, FALSE]} > 1 && ${Me.PctHPs} < 50 )
			return TRUE
		;--- Dwarf
		if ( ${Me.Buff[Poisoned](exists)} || ${Me.Buff[Diseased](exists)} || ${Me.Buff[Bleeding](exists)} ) &&  ${Toon.canCast[Stoneform]}
			return TRUE
		;--- Orc
		if ${Toon.canCast[Blood Fury]} && ${Me.PctHPs} > 90 && ${Target.PctHPs} > 50 && ${This.PvPAggroWithin[10, TRUE]} < 1
			return TRUE
		;--- Troll
		if ${Toon.canCast[Berserking]} && ${Me.PctHPs} > 90 && ${Target.PctHPs} > 50 && ${This.PvPAggroWithin[10, TRUE]} < 1
			return TRUE

		return FALSE
	}
	method RacialPulse()
	{
		;--- Blood Elf
		if ${Toon.canCast[Arcane Torrent]} && ${Me.Buff[Mana Tap].Application} < 3 && ${Me.Target.PctMana} > 0
		{
			This:Output["Casting: Racial Arcane Torrent"]
			Toon:CastSpell[Arcane Torrent]
			return
		}
		if ${Toon.canCast[Mana Tap]} && ${Target.Casting(exists)} && ${Target.Distance} < 10 && ${Me.Target.PctMana} > 0
		{
			This:Output["Casting: Racial Mana Tap"]
			Toon:CastSpell[Mana Tap]
			return
		}
		;--- Tauren
		if ${Toon.canCast[War Stomp]} && ( ${Target.Casting(exists)} && ${Target.Distance} < 8 || ${This.PvPAggroWithin[8, FALSE]} > 1 && ${Me.PctHPs} < 50 )
		{
			This:Output["Casting: Racial War Stomp"]
			Toon:CastSpell[War Stomp]
			return
		}
		;--- Dwarf
		if ( ${Me.Buff[Poisoned](exists)} || ${Me.Buff[Diseased](exists)} || ${Me.Buff[Bleeding](exists)} ) &&  ${Toon.canCast[Stoneform]}
		{
			This:Output["Casting: Racial Stoneform"]
			Toon:CastSpell[Stoneform]
			return
		}
		;--- Orc
		if ${Toon.canCast[Blood Fury]} && ${Me.PctHPs} > 90 && ${Target.PctHPs} > 50 && ${This.PvPAggroWithin[10, TRUE]} < 1
		{
			This:Output["Casting: Racial Blood Fury"]
			Toon:CastSpell[Blood Fury]
			return
		}	
		;--- Troll
		if ${Toon.canCast[Berserking]} && ${Me.PctHPs} > 90 && ${Target.PctHPs} > 50 && ${This.PvPAggroWithin[10, TRUE]} < 1
		{
			This:Output["Casting: Racial Berserking"]
			Toon:CastSpell[Berserking]
			return
		}		
		
		return
	}
	
	;** - Prebuff All - ************************************************************* /
	variable bool HookBGPrebuff = TRUE
	member NeedBGPrebuff()
	{
		This:SortAmmo
						
		if ${This.PetDead} && ${This.LastPetCallTime} < ${LavishScript.RunningTime} - 2000
		{
			if ${This.NeedCallPet} && ${Toon.canCast[Call Pet]} 
			{
				return TRUE
			}
			elseif ${Toon.canCast[Revive Pet]} 
			{
				return TRUE
			}
		}
		
		if ${usePrebuffTable} && ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", ${PrebuffTableStacks}]}
		{
			return TRUE
		}
		
		if ${usePrebuffSoulwell} && ${This.NeedBGObjects["Soulwell","Master Healthstone", 1]}
		{
			return TRUE
		}
		
		return FALSE
	}
	method BGPrebuffPulse()
	{
		
		if ${This.PetDead} && ${LastPetCallTime} < ${LavishScript.RunningTime} - 2000
		{
			Toon:Standup
			
			if ${This.NeedCallPet} && ${Toon.canCast[Call Pet]} 
			{
				This:Output["Casting: Call Pet"]
				Toon:CastSpell[Call Pet]
				return
			}	
			elseif ${Toon.canCast[Revive Pet]} 
			{
				This:Output["Casting: Revive Pet"]
				Toon:CastSpell[Revive Pet]
				return
			}
			LastPetCallTime:Set[${LavishScript.RunningTime}]
		}
		
		if ${usePrebuffTable} && ${This.NeedBGObjects["Refreshment Table","Conjured Manna Biscuit", ${PrebuffTableStacks}]}
		{
			This:BGObjectsPulse["Refreshment Table","Conjured Manna Biscuit", ${PrebuffTableStacks}]
			return
		}
		
		if ${usePrebuffSoulwell} && ${This.NeedBGObjects["Soulwell","Master Healthstone", 1]}
		{
			This:BGObjectsPulse["Soulwell","Master Healthstone", 1]
			return
		}
		
		return
	}

	;** - Guarding All - ************************************************************ /
	variable bool HookBGGuard = TRUE
	member NeedBGGuard()
  {
   	
		This:SortAmmo

		; pulse in here because of randomness ...
   	if ${This.NeedRandomMove}
   	{
			return TRUE
   	}

		if ${This.PetDead} && ${This.LastPetCallTime} < ${LavishScript.RunningTime} - 2000
		{
			if ${This.NeedCallPet} && ${Toon.canCast[Call Pet]} 
			{
				return TRUE
			}
			elseif ${Toon.canCast[Revive Pet]} 
			{
				return TRUE
			}
		}
		
		if ${useGuardTrap} && ${Toon.canCast[${GuardTrap}]}
		{
			return TRUE
		}
		
		if ${useGuardFlare} && ${Toon.canCast[Flare]} && ${This.LastFlareTime} < ${LavishScript.RunningTime} - 60000
		{
			return TRUE
		}

		return FALSE
	}
	method BGGuardPulse()
	{

		This:RandomMovePulse

		if ${This.PetDead} && ${This.LastPetCallTime} < ${LavishScript.RunningTime} - 2000
		{
			if ${This.NeedCallPet} && ${Toon.canCast[Call Pet]} 
			{
				This:Output["Casting: Call Pet"]
				Toon:CastSpell[Call Pet]
				return
			}	
			elseif ${Toon.canCast[Revive Pet]} 
			{
				This:Output["Casting: Revive Pet"]
				Toon:CastSpell[Revive Pet]
				return
			}
			LastPetCallTime:Set[${LavishScript.RunningTime}]
		}
		
		if ${useGuardTrap} && ${Toon.canCast[${GuardTrap}]}
		{
				This:Output["Casting: ${GuardTrap}"]
				Toon:CastSpell[${GuardTrap}]
				return
		}
		
		if ${useGuardFlare} && ${Toon.canCast[Flare]} && ${This.LastFlareTime} < ${LavishScript.RunningTime} - 60000
		{
			This:Output["Casting: Flare to see hidden...!"]
			Toon:CastSpell[Flare]
			ISXWoW:ClickTerrain[${Me.X},${Me.Y},${Me.Z}]
			LastFlareTime:Set[${LavishScript.RunningTime}]
			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[${TrinketName1}](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:CustOutput["Use Trinket ${TrinketName1}"]
			Item[${TrinketName1}]:Use
			return
		}
		
		if ${Item[${TrinketName1}](exists)} && ${Me.Action[${TrinketName2}].Usable} && ${Me.PctHPs} < ${This.TrinketMyHealth2} && ${Me.PctMana} < ${This.TrinketMyMana2} && ( !${This.TrinketPvP2} || ${This.TrinketPvPDebuff} )
		{
			This:Output["Use Trinket ${TrinketName2}"]
			Item[${TrinketName2}]:Use
			return
		}
		
		return
	}

	;** - NeedClassAttack - ********************************************************* /
	member NeedClassAttack()
	{
		;--- All Class -----------------------------------------------------------

		;--- Druid ---------------------------------------------------------------
		if ${Target.Class.Equal["Druid"]}
		{
			if ${Toon.canBuff[${Target.GUID}, "Hunter's Mark"]} && ${Toon.canCast["Hunter's Mark"]}
			{
				return TRUE
			}
		}
		;--- 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 ${Toon.canBuff[${Target.GUID}, "Hunter's Mark"]} && ${Toon.canCast["Hunter's Mark"]}
			{
				return TRUE
			}
		}
		
		;--- Shaman --------------------------------------------------------------
		if ${Target.Class.Equal["Shaman"]}
		{
		}
		
		;--- Warlock -------------------------------------------------------------
		if ${Target.Class.Equal["Warlock"]}
		{
		}
		
		;--- Warrior -------------------------------------------------------------
		if ${Target.Class.Equal["Warrior"]}
		{
		}
		
		return FALSE
	}
	method ClassAttackPulse()
	{
		
		;--- All Class -----------------------------------------------------------

		;--- Druid ---------------------------------------------------------------
		if ${Target.Class.Equal["Druid"]}
		{
			if ${Toon.canBuff[${Target.GUID}, "Hunter's Mark"]} && ${Toon.canCast["Hunter's Mark"]}
			{
				Toon:CastSpellGUID[${Target.GUID}, "Hunter's Mark"]
				return
			}
			
			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 ${Toon.canBuff[${Target.GUID}, "Hunter's Mark"]} && ${Toon.canCast["Hunter's Mark"]}
			{
				Toon:CastSpellGUID[${Target.GUID}, "Hunter's Mark"]
				return
			}
			
			return
		}
		
		;--- Shaman --------------------------------------------------------------
		if ${Target.Class.Equal["Shaman"]}
		{
			return
		}
		
		;--- Warlock -------------------------------------------------------------
		if ${Target.Class.Equal["Warlock"]}
		{
			return
		}
		
		;--- Warrior -------------------------------------------------------------
		if ${Target.Class.Equal["Warrior"]}
		{
			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 kMinRange=0, int kMaxRange=25)
	{
		Toon:CastSpellGUID[${kPlayer}, ${name1}]
		;WoWScript ClearTarget()
		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:CustOutput["Moving towards ${UseableObject.Name} at distance ${UseableObject.Distance}!"]
						Navigator:MoveToLoc[${UseableObject.X},${UseableObject.Y},${UseableObject.Z}]
					}
					
					if ${UseableObject.Distance} < 4
					{
						Toon:Stop
						This:CustOutput["Inventory ${Consumable.ItemX[${objectItem}]} ${objectItem} or Stacks!"]
						This:CustOutput["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[Aimed Shot]}
    {
        return TRUE
    }
    
    return FALSE
	}
	method FaceForSpellPulse()
	{
		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
    }
    
    return FALSE
	}
	method NoMoreSpellPulse()
	{
		WoWScript SpellStopCasting()
		return
	}
	
	;** - RandomMove - ************************************************************** /
  variable int randomMove = 0
    
	member NeedRandomMove()
	{

    randomMove:Set[${Math.Rand[100]}]
    
    if ${randomMove} == 13
    {
			return TRUE
    }
    
    if ${randomMove} == 66
    {
			return TRUE
    }
    
    if ${randomMove} == 99
    {
			return TRUE
    }
    
		return FALSE
	}
	method RandomMovePulse()
	{
    variable int randomheading = ${Math.Rand[360]}      
    variable int headingdiff

    if ${randomMove} == 13
    {
    	do
      {
      	randomheading:Set[${Math.Rand[360]}]
        headingdiff:Set[${Math.Abs[${Me.Heading}-${randomheading}]}]
        if ${headingdiff} > 180
        {
        	headingdiff:Set[${Math.Calc[360-${headingdiff}]}]
        }
     }
     while ${headingdiff} < 30
     
     This:Output["Random Facing ... lets make them believe we look around"]
     Face -heading ${randomheading}
     return
    }

    if ${randomMove} == 66
    {
     	This:Output["One-eighty-bowgrab-petbite take this! ohe-oho!"]
    	if ${Me.Heading} > 180
    	{
    		Face -heading ${Math.Calc[${Me.Heading}-180]}
    	}
    	else
    	{
    		Face -heading ${Math.Calc[${Me.Heading}+180]}
    	}
     	WoWPress Jump
     	return
    }
    
    if ${randomMove} == 99
    {
     	This:Output["Random Jump oheeee oho... lets jump ohe...!"]
     	WoWPress Jump
     	return
    }
    
		return
	}

	;******************************************************************************** /
  ;** 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 - *********************************************************** /
	; ---------------------------------------------------------------------
	; --- Event and Message Hooking 
	; ---------------------------------------------------------------------

	variable bool needUIHook = TRUE
	method UIErrorMessage(string Id, string Msg)
	{
		if ${Msg.Find[You are too far away]} && !${Bot.PauseFlag} && !${Movement.Speed}
			CMovement:MoveForward
		elseif ${Msg.Find[Out of range]} && !${Bot.PauseFlag} && !${Movement.Speed}
			CMovement:MoveForward
		elseif ${Msg.Find[You are facing the wrong way]} && !${Bot.PauseFlag} && !${Movement.Speed}
			CMovement:MoveBackward
		elseif ${Msg.Find[You can't mount here]} && !${Bot.PauseFlag} && !${Movement.Speed}
			CMovement:MoveForward
;		elseif ${Msg.Find[Target not in line of sight]} && !${Bot.PauseFlag}
;		{
;			GlobalBlacklist:Insert[${Target.GUID},5000]
;			WoWScript ClearTarget()
;		}
		elseif ${Msg.Find[Can't attack while dead]}
			NeedCallPet:Set[FALSE]																					/* we will need to use Revive Pet									*/
		elseif ${Msg.Find[You already control a summoned creature]}
			NeedCallPet:Set[FALSE]																					/* we will need to use Revive Pet									*/
		elseif ${Msg.Find[Your pet is dead]}
			NeedCallPet:Set[FALSE]																					/* we will need to use Revive Pet									*/
		elseif ${Msg.Find[Your pet is not dead]}
			NeedCallPet:Set[TRUE]																						/* we need to use Call Pet											*/
		elseif ${Msg.Find[You do not have a pet to summon]}
			NoPet:Set[TRUE]
		elseif ${Msg.Find[Ammo needs to be in]}
			This:UseAmmo																										/* try to find some ammo to use										*/
	}
	
  ;** - 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 - ****************************************************************** /
	;** - canBuff - ***************************************************************** /
  ;******************************************************************************** /

	;** - PvP Trinket Debuffed - **************************************************** /
	/* 
		TODO: Add all emergency Debuffs
	*/
	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
		}
		
		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,-attackable,-range 0-${Range}]
		}
		else
		{
			Aggros:Search[-players,-pvp,-alive,-notflying,-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
	}
	;** - PetDead - ***************************************************************** /
	; test if our pet is dead or missing
	member PetDead()
	{

		if (${Me.Pet(exists)} && ${Me.Pet.Dead}) || !${Me.Pet(exists)} || !${Me.Pet.PctHPs}
			return TRUE
			
		return FALSE
	}
	;** - sortAmmo - **************************************************************** /
	; try to move spare ammo to quiver or ammo pouch
	method SortAmmo() 
	{ 
		variable int ContainerIndex = 0 
		variable int Index 
		variable int SpotIndex 
		variable int EmptySpot = 0 
		variable int ApiIndex = 19 
		
		; serarch for a quiver or ammo pouch
		Index:Set[1] 
		do 
		{ 
			if ${Me.Bag[${Index}](exists)} && (${Me.Bag[${Index}].Name.Find["Quiver"]} || ${Me.Bag[${Index}].Name.Find["Ammo Pouch"]})
				ContainerIndex:Set[${Index}] 
		} 
		while ${Me.Bag[${Index:Inc}](exists)} 
	
		; if we have a quiver or ammo pouch, try to fill it
		if ${ContainerIndex} && ${Me.Bag[${ContainerIndex}].EmptySlots} > 0 
		{ 
			Index:Set[1] 
			do 
			{ 
				if !${Me.Bag[${ContainerIndex}].Item[${Index}].Name(exists)} 
					EmptySpot:Set[${Index}] 
			} 
			while ${Index:Inc} <= ${Me.Bag[${ContainerIndex}].Slots} 
		   
			if ${EmptySpot} 
			{ 
				Index:Set[0] 
				do 
				{ 
					if ${Index} != ${ContainerIndex} 
					{ 
						SpotIndex:Set[1] 
						do 
						{ 
							if ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Arrow"]} || ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Shot"]} || ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Slugs"]} || ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Shells"]}
							{ 
								Me.Bag[${Index}].Item[${SpotIndex}]:PickUp 
								This:Timeout
								ApiIndex:Set[${Math.Calc[${ApiIndex} + ${ContainerIndex}]}] 
								WoWScript "PutItemInBag(${ApiIndex})" 
								return 
							} 
						} 
						while ${SpotIndex:Inc} <= ${Me.Bag[${Index}].Slots} 
					} 
				} 
				while ${Me.Bag[${Index:Inc}](exists)} 
			} 
		} 
	}
	;** - UseAmmo - ***************************************************************** /
	; try to find ammo to use
	method UseAmmo() 
	{ 
		variable int Index = 0
		variable int SpotIndex 
		
		OutOfAmmo:Set[TRUE]
		do 
		{ 
			SpotIndex:Set[1] 
			do 
			{ 
				if ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Arrow"]} || ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Shot"]} || ${Me.Bag[${Index}].Item[${SpotIndex}].Name.Find[" Slugs"]}
				{ 
					Me.Bag[${Index}].Item[${SpotIndex}]:Use
					OutOfAmmo:Set[FALSE]	
					return 
				} 
			} 
			while ${SpotIndex:Inc} <= ${Me.Bag[${Index}].Slots} 
		} 
		while ${Me.Bag[${Index:Inc}](exists)} 
	}
	;** - isCCed - ****************************************************************** /
	member isCCed(string theGUID, string debuffTyp="none")
	{
		if (${debuffTyp.Equal["none"]} || ${debuffTyp.Equal["root"]})
		{
			if ${Object[${theGUID}].Buff[Entangling Roots](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Counterattack](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Frost Nova](exists)}
				return TRUE
		}
		if (${debuffTyp.Equal["none"]} || ${debuffTyp.Equal["immo"]})
		{
			if ${Object[${theGUID}].Buff[Cyclone](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Freezing Trap Effect](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Polymorph](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Sap](exists)}
				return TRUE
		}
		if (${debuffTyp.Equal["none"]} || ${debuffTyp.Equal["slow"]})
		{
			if ${Object[${theGUID}].Buff[Concussive Shot](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Frostbolt](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Hamstring](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Frost Shock](exists)}
				return TRUE
		}
		if (${debuffTyp.Equal["none"]} || ${debuffTyp.Equal["fear"]})
		{
			if ${Object[${theGUID}].Buff[Fear](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Howl of Terror](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Psychic Scream](exists)}
				return TRUE
			if ${Object[${theGUID}].Buff[Intimidating Shout](exists)}
				return TRUE
		}
		
		return FALSE
	}
;	;** - ToRangedSpecial - ********************************************************* /
;	method ToRangedSpecial()
;	{
;
;  	if !${Target(exists)} || ${Target.Dead}
;		{
;			Toon:Stop
;			return
;		}
;			
;		if ${Target.Distance} < ${Toon.MaxRanged} && ${Target.Distance} > ${Toon.MinRanged} && ${Movement.Speed}
;		{
;			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
;			Toon:Stop
;			return
;		}
;		elseif ${Target.Distance} > ${Toon.MaxRanged}
;		{
;			Navigator:MoveToMob[${Target.GUID}]
;		}
;		elseif ${Target.Distance} < ${Toon.MinRanged}
;		{
;			Navigator:MoveBackward[1500]
;		}
;	}
	;******************************************************************************** /
  ;** Gui Functions                                                               * /
  ;******************************************************************************** /
	;** - Initialize - ************************************************************** /
	;** - Shutdown - **************************************************************** /
	;** - GUI Setup - *************************************************************** /
	;** - SaveGUI - ***************************************************************** /
  ;******************************************************************************** /

	;** - Initialize - ************************************************************** /
	method Initialize()
	{
		This:SetGUI
		This:InitHunterGUI
		This:CustOutput["Darkfriend's HunterPimp v0.1!"]

		if ${Toon.canCast[Track Hidden]} && !${Me.Buff[Track Hidden](exists)}
		{
			This:CastSpell[Track Hidden]
		}
		This:SortAmmo
		This:UseAmmo	

	}
	;** - Init Hunter GUI - ********************************************************* /
	method InitHunterGUI()
	{
		if ${This.UseVar[Output]}
		{
			UIElement[EnableOutput@Output@Pages@ClassGUI]:SetChecked
		}
	}

	;** - Class GUI Change - ******************************************************** /
	method ClassGUIChange(string Action)
	{
		switch ${Action}
		{
			case EnableOutput
				Class:SetUse[Output,${UIElement[EnableOutput@Output@Pages@ClassGUI].Checked}]
				break
		}
	}
	;** - Shutdown - **************************************************************** /
	method Shutdown()
	{
		This:SaveGUI
	}

	;** - GUI Setup - *************************************************************** /
	method SetGUI()
	{
	   variable string uniqueToon = "${Me.Name}:${Me.Class}:${ISXWoW.RealmName.Replace[',REMOVE,.,REMOVE]}"
	   Config:SetSlider[${uniqueToon},"sldRestHP","sldRestHP@Main@Pages@ClassGUI",60]
	   Config:SetSlider[${uniqueToon},"sldStandHP","sldStandHP@Main@Pages@ClassGUI",100]
	   Config:SetSlider[${uniqueToon},"sldPullBailOutTimer","sldPullBailOutTimer@Main@Pages@ClassGUI",60]
	   
	   ; Abilities, Shadow Stuff
     Config:SetCheckBox[${uniqueToon},"chkUseMBL","chkUseMBL@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseSWP","chkUseSWP@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseSWD","chkUseSWD@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseMFL","chkUseMFL@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseVEM","chkUseVEM@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseDPL","chkUseDPL@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUsePSC","chkUsePSC@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseSIL","chkUseSIL@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseSFO","chkUseSFO@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseTOW","chkUseTOW@Main@Pages@ClassGUI",TRUE]
     
     ; Abilities, Disciple Stuff
     Config:SetCheckBox[${uniqueToon},"chkUsePWS","chkUsePWS@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUsePWF","chkUsePWF@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseIFI","chkUseIFI@Main@Pages@ClassGUI",TRUE]
     
     ; Abilities, Holy Stuff
     Config:SetCheckBox[${uniqueToon},"chkUseREN","chkUseREN@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseFHE","chkUseFHE@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseLHE","chkUseLHE@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseHHE","chkUseHHE@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseGHE","chkUseGHE@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseDMA","chkUseDMA@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseCDI","chkUseCDI@Main@Pages@ClassGUI",TRUE]
     
     ; Abilities, Special Stuff
     Config:SetCheckBox[${uniqueToon},"chkUseTR1","chkUseTR1@Main@Pages@ClassGUI",TRUE]
     Config:SetCheckBox[${uniqueToon},"chkUseTR2","chkUseTR2@Main@Pages@ClassGUI",TRUE]

	}

	;** - SaveGUI - ***************************************************************** /
	method SaveGUI()
	{
	   variable string uniqueToon = "${Me.Name}:${Me.Class}:${ISXWoW.RealmName.Replace[',REMOVE,.,REMOVE]}"
	   Config:SaveSlider[${uniqueToon},"sldRestHP"]
	   Config:SaveSlider[${uniqueToon},"sldStandHP"]
	   Config:SaveSlider[${uniqueToon},"sldPullBailOutTimer"]
	   
 	   ; Abilities, Shadow Stuff
     Config:SaveCheckBox[${uniqueToon},"chkUseMBL"]
     Config:SaveCheckBox[${uniqueToon},"chkUseSWP"]
     Config:SaveCheckBox[${uniqueToon},"chkUseSWD"]
     Config:SaveCheckBox[${uniqueToon},"chkUseMFL"]
     Config:SaveCheckBox[${uniqueToon},"chkUseVEM"]
     Config:SaveCheckBox[${uniqueToon},"chkUseDPL"]
     Config:SaveCheckBox[${uniqueToon},"chkUsePSC"]
     Config:SaveCheckBox[${uniqueToon},"chkUseSIL"]
     Config:SaveCheckBox[${uniqueToon},"chkUseSFO"]
     Config:SaveCheckBox[${uniqueToon},"chkUseTOW"]
     
     ; Abilities, Disciple Stuff
     Config:SaveCheckBox[${uniqueToon},"chkUsePWS"]
     Config:SaveCheckBox[${uniqueToon},"chkUsePWF"]
     Config:SaveCheckBox[${uniqueToon},"chkUseIFI"]
     
     ; Abilities, Holy Stuff
     Config:SaveCheckBox[${uniqueToon},"chkUseREN"]
     Config:SaveCheckBox[${uniqueToon},"chkUseFHE"]
     Config:SaveCheckBox[${uniqueToon},"chkUseLHE"]
     Config:SaveCheckBox[${uniqueToon},"chkUseHHE"]
     Config:SaveCheckBox[${uniqueToon},"chkUseGHE"]
     Config:SaveCheckBox[${uniqueToon},"chkUseDMA"]
     Config:SaveCheckBox[${uniqueToon},"chkUseCDI"]
     
     ; Abilities, Special Stuff
     Config:SaveCheckBox[${uniqueToon},"chkUseTR1"]
     Config:SaveCheckBox[${uniqueToon},"chkUseTR2"]
	}
	
}