/*
---------------------------------------------------------------------------
          iiDD          ttKK##WWLLLLDDDDtt..    ttWW##DDLL  ::GG####LLLL
          ffWW            LL##DD    iiKKKKff      LL##ii      ..WWKK    
          KK##ii          tt##GG      ..KK##jj    tt##..        KKGG    
        ttttKKDD;;        tt##GG        iiEEWW    tt##..        KKGG    
        DD  jj##GG        tt##GG          LL##;;  tt##..        KKGG    
      ;;LL  ..####..      tt##GG          tt##ii  tt##LLLLLLLLLLWWGG    
      DDGGLLLLWW##tt      tt##GG          LL##;;  tt##..        KKGG    
    ::GG      iiEEKK      tt##GG        iiEEWW    tt##..        KKGG    
    tttt      ..LL##..    tt##GG        ffWWGG    tt##..        KKGG    
    DD..        ;;##jj    tt##GG      tt##WW..    tt##..        KKGG    
ttDD##LL      iiGG####LLttWW##WWLLLLDDDDii..    ttWW##DDLL  ::GG####LLLL
---------------------------------------------------------------------------

; Reworked routine from "Project: Awesome Hunter Routine", which was originally created by Etox

; reworked by kras
*/

;Leave this define Intact. Its testing if this file is loaded or not.
#define ROUTINES

;Toggleable defines:			/* Commenting out a "Toggleable" define will disable the feature */


#define REVIVE_PET			/* Revive your pet in downtime?*/
#define FOOD_NAME "Tough Hunk of Bread"		/* Name of food to feed pet with */
#define MEND_LIMIT 40			/* % Hp limit for Mend Pet in combat */
#define MAX_STUCK 10 			/* How many attempts to free yourself when stuck before using heartstone and logout */
#define USE_MARK 			/* Do you want to cast hunters mark when pulling? */
#define USE_SERPENT			/* Do you want to use Serpent Sting? */
;#define PULL_FIRST			/* concussive shot pull to open? /*
;#define USE_SCORPID			/* Do you want to use Scorpid Sting? */
#define USE_ARCANE_MP 90		/* Do you want to use Arcane hots? */
;#define USE_CONCUSSIVE 20		/* Do you want to use Concussive hots on humanoids? If so at what %? */
#define USE_AIMED_SHOT			/* Do you want to pull with Aimed shot? */
#define AIMED_MP 65
;#define USE_MONGOOSE			/* Do you want to use Mongoose Bite? */
#define SWITCH_MONKEY 			/* Do you want aspect of the monkey when entering melee?(Pure melee not affected)*/
	
;Pure value defines:			/* Just change the values in the following ones */

#define ARROW_NAME "Razor Arrow"	/* Name of your arrows */
#define FEIGN_LIMIT 10			/* % Hp limit for when to feign death */
#define REVIVE_COST 188	/* The mana cost of your "Reive Pet" spell */


;
; The CombatPrep function is called once you have selected a target but before you enter combat.
;
function CombatPrep()
{   
	;Reset flag
	DoCombatPrep:Set[FALSE]
}

function Attack(string AttackGUID)
{
   
declare SavX float ${Me.X}
declare SavY float ${Me.Y}
declare SavZ float ${Me.Z}
declare BailOut int ${Math.Calc[${LavishScript.RunningTime}+(1000*${CombatBailout})]}
declare HavePulled bool FALSE
declare StuckCheck bool FALSE
declare StuckCheckTime int
declare HaveArrows guidlist
declare Aggros guidlist
declare AggroCount int 0
declare AggroMe int 0
declare AggroPet int 0
declare AggroGUID string
declare Index int 0
if !${Script[wowbot].Variable[AttackState](exists)}
	declare AttackState string script RANGED
else
	AttackState:Set[RANGED]

if !${Script[wowbot].Variable[EvadeCount](exists)}
	declare EvadeCount int script 0

; Reset the count for evades
EvadeCount:Set[0]

; triggers
addtrigger evade "[Event:@*@:CHAT_MSG_SPELL_SELF_DAMAGE](\"Your @SPELLNAME@ was evaded by @MOB@.@*@"
;"
if ${AttackGUID.Equal[NULL]}||${AttackGUID.Equal[NOTARGET]}
{
	call UpdateHudStatus "No target to attack"
}
  
call UpdateHudStatus "Attacking ${Object[${AttackGUID}].Name}"
  
Do
{
	SavX:Set[${Me.X}]
	SavY:Set[${Me.Y}]
	SavZ:Set[${Me.Z}]

	; Check we still have a valid target
	if !${Unit[${AttackGUID}](exists)}
	{
		call UpdateHudStatus "Target lost"
		TargetGUID:Set[NOTARGET]
		Return
 	}
 	
 	if ${Unit[${AttackGUID}].FactionGroup.Equal[Alliance]} 
			   { 
			      ;add them to a blacklist or whatever here... 
			      call UpdateHudStatus "Target is an alliance member, don't bother attacking them" 
			      GUIDBlacklist:Set[${AttackGUID},AVOID] 
			      TargetGUID:Set[NOTARGET] 
			      Return 
	   		   } 
	
			if ${Unit[${AttackGUID}].Faction.Equal[Cenarion Circle]} 
			   { 
			      ;add them to a blacklist or whatever here... 
			      call UpdateHudStatus "Target is an alliance member, don't bother attacking them" 
			      GUIDBlacklist:Set[${AttackGUID},AVOID] 
			      TargetGUID:Set[NOTARGET] 
			      Return 
	   		   } 

       
	; Check if the target is engaged already
	if ${Unit[${AttackGUID}].Tapped}
	{
		call UpdateHudStatus "Target already engaged"
		TargetGUID:Set[NOTARGET]
		WoWScript PetFollow()
		Return         
 	}
	
	; If we dont have our chosen unit targeted and were in range target it
	if !${Target.GUID.Equal[${AttackGUID}]}&&${Unit[${AttackGUID}].Distance}<${TargetingRange}
	{
 		debug(*Routine* Current Target: ${Target.GUID} Targeting Unit: ${Unit[${AttackGUID}].Name}[${AttackGUID}])
 		Target ${AttackGUID}
 		waitframe
	}

	; Ensure we are still facing our target loc
	call SmartFace ${Unit[${AttackGUID}].X} ${Unit[${AttackGUID}].Y}
	
	; Check if we still have ammo
	HaveArrows:Search[-exact,ARROW_NAME]

	; and go pure melee if we don't
	if (!${HaveArrows.Count} || ${Me.Equip[ranged].Durability}==0) &&${AttackState.NotEqual[PURE_MELEE]}
	{
		debug(*Routine* We are now out of ammo and wondering why the heck we choosed to bot a hunter)
		AttackState:Set[PURE_MELEE]
	}

	if ${Target.PctHPs}>99
		declare Immune-Serp bool global FALSE
		
	Event[CHAT_MSG_SPELL_SELF_DAMAGE]:AttachAtom[immunechecks]

	; check if we have pulled, if so do the attack stuff
	if ${HavePulled}
	{
		; Check if the target is engaged already
			if ${Unit[${AttackGUID}].Tapped}
			{
				call UpdateHudStatus "Target already engaged"
				TargetGUID:Set[NOTARGET]
				WoWScript PetFollow()
				Return         
 			}
		
		if !${Me.Pet.Target.GUID.Equal[${AttackGUID}]}
		{
			debug(*Routine* Asking pet to attack)
			wowscript PetAttack()
		}
		switch ${AttackState}
		{
			case RANGED
				
				call Ranged ${AttackGUID}
				if ${Return.Equal[MELEE]}
				{
					Call UpdateHudStatus "Switching to Melee"
					AttackState:Set[MELEE]
				}
				break

			case MELEE

				call Melee ${AttackGUID}
				if ${Return.Equal[RANGED]}
				{
					Call UpdateHudStatus "Switching to Ranged"
					AttackState:Set[RANGED]
				}
				break

			case PURE_MELEE

				call Melee ${AttackGUID}
				break

			default debug(*Routine* We don't have an AttackState)
 		}
	}
	; Else pull if we still have some ammo.
	else
	{
		; Check if another mob aggroed before we pull
		Aggros:Search[-units,-nopets,-nearest,-aggro,-alive,-range 0-100]

		if !${Unit[${AttackGUID}].Aggro}&&${Aggros.Count}>0
		{
			debug(*Routine* The Unit: ${Unit[${Aggros.GUID[1]}].Name}[${Unit[${Aggros.GUID[1]}]}] has aggroed us. Interupting the pulling.)
			TargetGUID:Set[NOTARGET]
			return
		}
		Aggros:Clear

		if ${HaveArrows.Count}&&!${Unit[${AttackGUID}].Aggro}
		{
			call Pull ${AttackGUID}
			if ${Return}
			{
				HavePulled:Set[TRUE]
				continue
			}
		}
		else
		{
			HavePulled:Set[TRUE]
			continue
		}
	}

	;wait for half a second to give our pc a chance to move
	wait 5

	; Stuck checks
	if ${AttackState.Equal[RANGED]}
	{

		
		; Check if the target is engaged already
			if ${Unit[${AttackGUID}].Tapped}
			{
				call UpdateHudStatus "Target already engaged"
				TargetGUID:Set[NOTARGET]
				WoWScript PetFollow()
				Return         
 	}
		
		; Check to make sure we have moved if not then try and avoid the
		; obstacle thats in our path
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${SavX},${SavY},${SavZ}]}<1&&${Unit[${AttackGUID}].Distance}>${RangedMaxDist}
		{
			; I think i might be stuck so save off the current time
			if !${StuckCheck}
			{
				debug(*Routine* I might be stuck)
				StuckCheck:Set[TRUE]
				StuckCheckTime:Set[${LavishScript.RunningTime}]
			} 
			else
			{
				; If I am still stuck after 8 seconds then try and avoid the obstacle.
				if ${Math.Calc[${LavishScript.RunningTime}-${StuckCheckTime}]}>8000
				{
					debug(*Routine* Yep I am stuck trying to free myself)
					call Obstacle
					StuckCheckCount:Inc
					StuckCheck:Set[FALSE]
				}
			}
		}
	}
	elseif ${AttackState.Equal[MELEE]}||${AttackState.Equal[PURE_MELEE]}
	{
		;wait for half a second to give our pc a chance to move
	 	wait 5
       
      		; Check if the target is engaged already
			if ${Unit[${AttackGUID}].Tapped}
			{
				call UpdateHudStatus "Target already engaged"
				TargetGUID:Set[NOTARGET]
				WoWScript PetFollow()
				Return         
 	}
      		
      		; Check to make sure we have moved if not then try and avoid the
      		; obstacle thats in our path
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${SavX},${SavY},${SavZ}]}<1&&${Unit[${AttackGUID}].Distance}>${CombatMaxDist}
      		{
        		; I think i might be stuck so save off the current time
        		if !${StuckCheck}
        		{
        			debug(I might be stuck)
            			StuckCheck:Set[TRUE]
            			StuckCheckTime:Set[${LavishScript.RunningTime}]
         		}
         		else
         		{
            			; If I am still stuck after 8 seconds then try and avoid the obstacle.
            			if ${Math.Calc[${LavishScript.RunningTime}-${StuckCheckTime}]}>8000
            			{
               				debug(Yep I am stuck trying to free myself)
               				call Obstacle
					StuckCheckCount:Inc
               				StuckCheck:Set[FALSE]
            			}
         		}
  		}
	}

	; If I have moved away from my saved spot reset my stuck toggle
	if ${StuckCheck}&&${Math.Distance[${Me.X},${Me.Y},${Me.Z},${SavX},${SavY},${SavZ}]}>3
	{
		debug(*Routine* I am no longer stuck)
		StuckCheck:Set[FALSE]
		StuckCheckCount:Set[0]
	}

	#ifdef MAX_STUCK
	;If I have been stuck too many times then quit.
	if ${StuckCheckCount}>MAX_STUCK
	{
		debug(*Routine* Got stuck to often. Quitting the game)
		call ExitGame
	}
	#endif
		
	; Check if we have exceeded bail out timer and the mob is still at full health
	if ${LavishScript.RunningTime}>${BailOut}&&${Unit[${TargetGUID}].PctHPs}>99
	{
		GUIDBlacklist:Set[${TargetGUID},AVOID]
		call UpdateHudStatus "Combat timeout reached"
		TargetGUID:Set[NOTARGET]
		return
	}

	; Safety things

	; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			WoWScript PetFollow()
			Return         
 	}
	
	; Feign Death if less than FEIGN_LIMIT % HP
	if ${Me.PctHPs}<FEIGN_LIMIT&&${Spell[Feign Death](exists)}&&!${Spell[Feign Death].Cooldown}
 	{
		move -stop
		waitframe
		call UpdateHudStatus "Feigning Death"
		call CastSpell "Feign Death" ${Me.GUID}
		wait 10
		if ${Me.Buff[Feign Death](exists)}
		{
			while ${Me.InCombat}
			{
				wait 10
			}
			; Jump once to break out of fd
			wowpress jump
			wait 10

			;Reset flags to do combat prep and downtime
			DoDowntime:Set[TRUE]
			DoCombatPrep:Set[TRUE]
			return
		}
		else
		{
			debug(*Routine* Feign Death got resisted. Time to flee!)
			RLG:Set[TRUE]
			return
		}
	}

	; Check if we should flee
	AggroMe:Set[0]
	AggroPet:Set[0]
	Index:Set[0]
	Aggros:Search[-units,-nopets,-nearest,-aggro,-alive,-range 0-40]

	; Count the aggros
	while ${Index:Inc}<=${Aggros.Count}
	{
		if ${Unit[${Aggros.GUID[${Index}]}].Target.GUID.Equal[${Me.Pet.GUID}]}
			AggroPet:Inc
		elseif ${Unit[${Aggros.GUID[${Index}]}].Target.GUID.Equal[${Me.GUID}]}
		{
			if !${AggroMe}
				AggroGUID:Set[${Aggros.GUID[1]}]
			AggroMe:Inc
		}
	}
	AggroCount:Set[${AggroPet} + ${AggroMe}]
	
	if ${Spell[Bestial Wrath](exists)} && !${Spell[Bestial Wrath].Cooldown} && ${AggroCount}>1
		{
			cast "Bestial Wrath"
		}
		
		if ${Me.Action[Rapid Fire].Usable} && ${AggroCount}>1 && !${Me.Pet.Buff[Bestial Wrath](exists)} && !${Me.Action[Bestial Wrath].Usable}
		{
			call CastSpell "Rapid Fire" ${Me.GUID}
		}
	

	if (${AggroCount}>=${Math.Calc[${PanicThreshold}+2]})||(${AggroCount}>${PanicThreshold}&&${Me.PctHPs}<40||!(${Me.Pet.Health}!=0)&&${Me.PctHPs}<40&&${Unit[${AttackGUID}].PctHPs}>30||${Me.Pet.Health}>0&&${AggroPet}&&${AggroMe}&&${Me.PctHPs}<30&&${Unit[${AttackGUID}].PctHPs}>30
	{ 
		debug(*Routine* I have ${AggroCount} Aggro mobs. Time to flee!)
		RLG:Set[TRUE]
		return
	}

	; If there is mob/mobs on us and pet only has one, order him to help out
	if ${AggroMe}&&${AggroPet}<3
	{
		while ${Unit[${AggroGUID}].Target.GUID.NotEqual[${Me.Pet.GUID}]}&&${Me.Pet.Health}!=0
		{
			if !${Target.GUID.Equal[${AggroGUID}]}
			{
				target ${AggroGUID}
				waitframe
			}
			if !${Me.Pet.Target.GUID.Equal[${AggroGUID}]}&&${Me.Pet.Health}!=0
			{
				wowscript PetAttack()
				waitframe
			}
			waitframe
		}
	}
	Aggros:Clear

	if ${QueuedCommands}
		ExecuteQueued evade
}
while !${Unit[${AttackGUID}].Dead}&&!${Me.Dead}

move -stop

; Update stats
if !${Me.Dead}
{
	call UpdateStats
}

wowpress -release movebackward
wowpress -release moveforward

;Reset flags to do combat prep and downtime
DoDowntime:Set[TRUE]
DoCombatPrep:Set[TRUE]

Return
}


function Ranged(string AttackGUID)
{
	; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			WoWScript PetFollow()
			Return         
 		}
	
	
	if ${Me.Action[Intimidation].Usable} && (${Unit[${AttackGUID}].Casting(exists)} || ${Me.Target.Target.Name.Equal[${Me}]} && ${Target.PctHPs}>20 && ${Target.PctHPs}<90
		call CastSpell "Intimidation" ${Target.GUID}
	; Cast Bestial Wrath
	
	
	if !${Me.Buff[Aspect of the Hawk](exists)}
	{
		call CastOnRun "Aspect of the Hawk"
	}
          
	if !${Me.Action[Auto Shot].AutoRepeat}&&${Unit[${AttackGUID}].Distance}<${RangedMaxDist}&&${Unit[${AttackGUID}].Distance}>${RangedMinDist}
	{
		cast "Auto Shot"
	}

	; Check if we are close enough and have mana
	if ${Unit[${AttackGUID}].Distance}<${RangedMaxDist}&&${Unit[${AttackGUID}].Distance}>${RangedMinDist}&&${Me.PctMana}>10
	{
		
		
		#ifdef USE_SERPENT
		; Cast Serpent Sting
		if !${Immune-Serp} && !(${Target.CreatureType.Equal[Mechanical]} || ${Target.CreatureType.Equal[Undead]}) && ${Me.Action[Serpent Sting].Usable}&&${Unit[${AttackGUID}].PctHPs}>20&&!${Unit[${AttackGUID}].Buff[Serpent Sting](exists)}
		{
			call CastSpell "Serpent Sting" ${AttackGUID}
		}
		#endif

		#ifdef USE_SCORPID
		; Cast Scorpid Sting
		if !${Spell[Scorpid Sting].Cooldown}&&${Unit[${AttackGUID}].PctHPs}>20&&!${Unit[${AttackGUID}].Buff[Scorpid Sting](exists)}
		{
			call CastSpell "Scorpid Sting" ${AttackGUID}
		}
		#endif
		
		#ifdef USE_AIMED_SHOT
		if ${Me.Action[Aimed Shot].Usable}&&${Unit[${AttackGUID}].PctHPs}>50&&${Me.PctMana}>AIMED_MP
		{
			call CastSpell "Aimed Shot" ${AttackGUID}
		}		
		#endif
		
		#ifdef USE_ARCANE_MP
		; Cast Arcane Shot
		if !${Spell[Arcane Shot].Cooldown}&&${Unit[${AttackGUID}].PctHPs}>20&&${Me.PctMana}>USE_ARCANE_MP
		{
			call CastSpell "Arcane Shot" ${AttackGUID}
		}
		#endif

		#ifdef USE_CONCUSSIVE
		; If Target is humanoid and has Low HP. Cast Slowing Spell
		if !${Spell[Concussive Shot].Cooldown}&&${Unit[${AttackGUID}].CreatureType.Equal[Humanoid]}&&${Unit[${AttackGUID}].PctHPs}<USE_CONCUSSIVE
		{
			call CastSpell "Concussive Shot" ${AttackGUID}
		}
		#endif
	
		#ifdef MEND_LIMIT
		; Mend Pet
		if ${Me.Action[Mend Pet].Usable} && ${Me.Pet.PctHPs}<MEND_LIMIT&&${Me.Pet.Health}!=0
		{
			call MendPet
		}
		#endif
      	}

 	; If we are to close and the mob has targeted us go into melee
	if ${Unit[${AttackGUID}].Target.GUID.Equal[${Me.GUID}]}&&${Unit[${AttackGUID}].Distance}<${RangedMinDist}
	{
		debug(*Routine* *Switching to Melee* Mobs target: ${Unit[${AttackGUID}].Target.GUID} Me: ${Me.GUID} Distance: ${Unit[${AttackGUID}].Distance}<${RangedMinDist})
		return MELEE
	}
			
	; Else run backward
	if ${Unit[${AttackGUID}].Distance}<${RangedMinDist}
	{
		debug(*Routine* To close for ranged attacks. Backing)
		;press and hold the backward button
		wowpress -release moveforward
		wowpress -hold movebackward
	}     


	;If too far away run forward
	if ${Unit[${AttackGUID}].Distance}>${RangedMaxDist}
	{
		debug(*Routine* to far away for ranged attacks. Closing.)
		;press and hold the forward button
		wowpress -release movebackward
		wowpress -hold moveforward
	}

	;If we are close enough stop running
	if ${Unit[${AttackGUID}].Distance}>${RangedMinDist}&&${Unit[${AttackGUID}].Distance}<${RangedMaxDist}
	{
		wowpress -release moveforward
		wowpress -release movebackward
	}
}

function Melee(string AttackGUID)
{
	; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			WoWScript PetFollow()
			Return         
 	}
	
	;initiate attack
	if !${Me.Attacking}
	{
		Call UpdateHudStatus "Attacking Target in Melee"
		WoWScript AttackTarget()
	}

	#ifdef SWITCH_MONKEY
	if !${Me.Buff[Aspect of the Monkey](exists)}
	#else
	if ${AttackState.Equal[PURE_MELEE]}&&!${Me.Buff[Aspect of the Monkey](exists)}
	#endif
	{
		call CastOnRun "Aspect of the Monkey"
	}

	#ifdef USE_MONGOOSE
	if ${Me.Action[Mongoose Bite].Usable}&&${Unit[${AttackGUID}].Distance}<${CombatMaxDist}&&${Me.PctMana}>20
	{
		call CastSpell "Mongoose Bite" ${AttackGUID}
	}
	#endif

	
		
	;Cast Disengage
	if ${Me.Action[Disengage].Usable} && ${Me.Pet(exists)}
	{
		call CastSpell "Disengage" ${AttackGUID}
	}
	
	;Cast Raptor Strike
	elseif !${Spell[Raptor Strike].Cooldown}&&${Unit[${AttackGUID}].Distance}<${CombatMaxDist}&&${Me.PctMana}>20
	{
		call CastSpell "Raptor Strike" ${AttackGUID}
	}
	
	#ifdef MEND_LIMIT
	; Mend Pet
	if ${Me.Pet.PctHPs}<MEND_LIMIT&&!${Me.Pet.Dead}
	{
		call MendPet
	}
	#endif

	; If pet has regained aggro we switch back to ranged state
	if ${Unit[${AttackGUID}].Target.GUID.Equal[${Me.Pet.GUID}]}&&${AttackState.NotEqual[PURE_MELEE]}
	{
		return RANGED
	}

	;If we are close enough stop running
	if ${Unit[${AttackGUID}].Distance}>${CombatMinDist}&&${Unit[${AttackGUID}].Distance}<${CombatMaxDist}
	{
		wowpress -release moveforward
		wowpress -release movebackward
	}

	;If too far away run forward
	if ${Unit[${AttackGUID}].Distance}>${CombatMaxDist}	
	{
		debug(*Routine* To far away for melee. Closing.)
		;press and hold the forward button
		wowpress -release movebackward
		wowpress -hold moveforward
	}

	;If too close then run backward
	if ${Unit[${AttackGUID}].Distance}<${CombatMinDist}
	{
      		debug(*Routine* To close for melee. Backing.)
       		;press and hold the backward button
       		wowpress -release moveforward
       		wowpress -hold movebackward
	}
}

function Pull(string AttackGUID)
{
	
	; Ensure we are still facing our target loc
	call SmartFace ${Unit[${AttackGUID}].X} ${Unit[${AttackGUID}].Y}
	
	;If too far away run forward
	if ${Unit[${AttackGUID}].Distance}>${RangedMaxDist}
	{
		debug(*Routine* To far away to pull)
		;press and hold the forward button
		wowpress -release movebackward
		wowpress -hold moveforward
	}	

	; If to close run back
	if ${Unit[${AttackGUID}].Distance}<${RangedMinDist}
	{
		debug(*Routine* to close to pull)
		;press and hold the backward button
		wowpress -release moveforward
		wowpress -hold movebackward
	}     

	; Once we get close to our target then pull it
	if ${Unit[${AttackGUID}].Distance}>${RangedMinDist}&&${Unit[${AttackGUID}].Distance}<${RangedMaxDist}
	{	
		;First stop
 		move -stop
		
		; If we dont have our chosen unit targeted, target it
		if !${Target.GUID.Equal[${AttackGUID}]}
		{
 			debug(*Routine* *Pulling* Current Target: ${Target.GUID} Targeting Unit ${Unit[${AttackGUID}].Name}[${AttackGUID}])
 			Target ${AttackGUID}
 			waitframe
 			
		}

		#ifdef USE_MARK
		call UpdateHudStatus "Casting Hunter's Mark"
		call CastSpell "Hunter's Mark" ${Target.GUID}
		#endif
		
		#ifdef PULL_FIRST
		call CastSpell "Concussive Shot" ${Target.GUID}
		wait 10
		#endif
		
		; Send in pet
		wowscript PetAttack()
		waitframe

		
		
		#ifdef USE_AIMED_SHOT
		waitframe
		if ${Me.Action[Aimed Shot].Usable}
		call CastSpell "Aimed Shot"
		else		
		call CastSpell "Arcane Shot"
		wait 70 ${Me.Action[Auto Shot].AutoRepeat}&&${Math.Distance[${Me.Pet.X},${Me.Pet.Y},${Unit[${AttackGUID}].X},${Unit[${AttackGUID}].Y}]}<10
		return TRUE
		#else
		wait 10 ${Math.Distance[${Me.Pet.X},${Me.Pet.Y},${Unit[${AttackGUID}].X},${Unit[${AttackGUID}].Y}]}<10
		return TRUE
		#endif
 	}
	return FALSE
}

#ifdef MEND_LIMIT
function MendPet()
{
	declare SavX float local ${Me.X}
	declare SavY float local ${Me.Y}
	declare SavZ float local ${Me.Z}
	declare StuckCheck bool local FALSE
	declare StuckCheckTime int local

	while ${Me.Pet.Health}!=0
	{
		; Ensure we are still facing our target loc
		call SmartFace ${Me.Pet.X} ${Me.Pet.Y}

		; Else run backward
		if ${Me.Pet.Distance}<${CombatMinDist}
		{
			debug(*Routine* To close for mending. Backing.) 
			;press and hold the backward button
			wowpress -release moveforward
			wowpress -hold movebackward
		}     


		;If too far away run forward
		if ${Me.Pet.Distance}>20
		{
			debug(*Routine* To far away for mending. Closing.)
			;press and hold the forward button
			wowpress -release movebackward
			wowpress -hold moveforward
		}

		;If we are close enough stop running and mend pet
		if ${Me.Pet.Distance}>${CombatMinDist}&&${Me.Pet.Distance}<20
		{
			wowpress -release moveforward
			wowpress -release movebackward
			waitframe
			call CastSpell "Mend Pet" ${Me.Pet.GUID}
			break
		}

		;wait for half a second to give our pc a chance to move
		wait 5

		; Check to make sure we have moved if not then try and avoid the
		; obstacle thats in our path
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${SavX},${SavY},${SavZ}]}<1&&${Me.Pet.Distance}>${RangedMaxDist}
		{
			; I think i might be stuck so call back pet
			wowscript PetPassiveMode()
			wait 50 ${Me.Pet.Distance}<20
		}
	}
}
#endif

function evade(string Line, string Spellname, string Mob)
{
	call UpdateHudStatus "Your ${Spellname} was evaded by ${Mob}"
	EvadeCount:Inc
	debug(EvadeCount: ${EvadeCount})
}

function Downtime(int repeat=0)
{
	if ${Item[-inventory,Scroll of](exists)}
	{
		Item:[Scroll of]:Use
	}
	
	#ifdef REVIVE_PET
	; Revive pet if dead, else call him
	if !(${Me.Pet.Health}!=0)
	{
		move -stop
		call UpdateHudStatus "Trying to call pet"
		call CastSpell "Call Pet" ${Me.GUID}
		wait 20 !${Me.GlobalCooldown}
		if !(${Me.Pet.Health}!=0)
		{
			if ${Me.CurrentMana}>REVIVE_COST
			{
				wait 15
				call UpdateHudStatus "Pet seems to be dead, lets rez him"
				CastSpell "Revive Pet"
				wait 20 ${Me.Casting}
				while ${Me.Casting}
				{
					waitframe
				}
				wait 10
				call UpdateHudStatus "Mending Pet"
				CastSpell "Mend Pet"
				wait 20 ${Me.Casting}
				while ${Me.Casting}
				{
					waitframe
				}
				wait 10
			}
			else
			{
				repeat:Inc
			}
		}
		wait 10
	}
	#endif

	#ifdef FOOD_NAME
	if ${Me.Pet.PctHappiness}<70&&${Me.Pet.Health}!=0
	/* &&${Item[FOOD_NAME](exists)}*/
	{
		/*cast "feed pet"
		wait 20 ${WoWScript[SpellIsTargeting()]}
		waitframe
		Item[-exact,FOOD_NAME]:Use
		wait 1
		wowscript SpellStopTargeting()
		*/
		type f
		wait 10
	}
	#endif

	if (${Me.PctHPs}<${MinHealthPct}||${Me.PctMana}<${MinManaPct}||${repeat}==1)&&!${Me.Dead}&&!${Me.Ghost}
	{
		if ${SitWhenRest}&&!${Me.Sitting}
		{
			wowpress SITORSTAND
		}

		if ${Me.PctHPs}<80 && !${Me.Buff[Food](exists)}
		{
			call Eat
			wait 40 ${Me.Buff[Food](exists)}
		}
		
		if ${Me.PctMana}<80 && !${Me.Buff[Drink](exists)}
		{
			call Drink
			wait 40 ${Me.Buff[Drink](exists)}
		}

		while (${Me.PctHPs}<90||${Me.PctMana}<90)&&!${Me.InCombat}&&!${Me.Dead}&&!${Me.Ghost}
		{
			waitframe
		}
	}

	call check_for_lootable_containers
	
	;Make sure we are stood up.
	if ${Me.Sitting}
	{
		wowpress SITORSTAND
	}

	; Check if we need to repair
	call CheckDurability

	; Reset downtime flag
	DoDowntime:Set[FALSE]

	; Do we need to repeat downtime?
	if ${repeat}==1
		call Downtime ${repeat:Inc}
}

function check_for_lootable_containers() 
{ 
   while ${Item["Small Barnacled Clam"].Slot(exists)} && ${Item["Small Barnacled Clam"].Bag.Number(exists)} 
      { 
         call lootContainer "Small Barnacled Clam" 
   } 
   
   while ${Item["Big-mouth Clam"].Slot(exists)} && ${Item["Big-mouth Clam"].Bag.Number(exists)} 
   { 
      call lootContainer "Big-mouth Clam" 
   } 
   while ${Item["Thick-shelled Clam"].Slot(exists)} && ${Item["Thick-shelled Clam"].Bag.Number(exists)} 
      { 
         call lootContainer "Thick-shelled Clam" 
   } 
   while ${Item["Bloated Catfish"].Slot(exists)} && ${Item["Bloated Catfish"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Catfish" 
   } 
   while ${Item["Bloated Mud Snapper"].Slot(exists)} && ${Item["Bloated Mud Snapper"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Mud Snapper" 
   } 
   while ${Item["Bloated Redgill"].Slot(exists)} && ${Item["Bloated Redgill"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Redgill" 
   } 
   while ${Item["Bloated Salmon"].Slot(exists)} && ${Item["Bloated Salmon"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Salmon" 
   } 
   while ${Item["Bloated Smallfish"].Slot(exists)} && ${Item["Bloated Smallfish"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Smallfish" 
   } 
   while ${Item["Bloated Trout"].Slot(exists)} && ${Item["Bloated Trout"].Bag.Number(exists)} 
   { 
      call lootContainer "Bloated Trout" 
   } 
   while ${Item["Dented Crate"].Slot(exists)} && ${Item["Dented Crate"].Bag.Number(exists)} 
   { 
      call lootContainer "Dented Crate" 
   } 
   while ${Item["Heavy Crate"].Slot(exists)} && ${Item["Heavy Crate"].Bag.Number(exists)} 
   { 
      call lootContainer "Heavy Crate" 
   } 
   while ${Item["Message in a Bottle"].Slot(exists)} && ${Item["Message in a Bottle"].Bag.Number(exists)} 
   { 
      call lootContainer "Message in a Bottle" 
   } 
   while ${Item["Sealed Crate"].Slot(exists)} && ${Item["Sealed Crate"].Bag.Number(exists)} 
   { 
      call lootContainer "Sealed Crate" 
   } 
   while ${Item["Small Chest"].Slot(exists)} && ${Item["Small Chest"].Bag.Number(exists)} 
   { 
      call lootContainer "Heavy Crate" 
   } 
   while ${Item["Waterlogged Crate"].Slot(exists)} && ${Item["Waterlogged Crate"].Bag.Number(exists)} 
   { 
      call lootContainer "Waterlogged Crate" 
   } 
   while ${Item["Battered Chest"].Slot(exists)} && ${Item["Battered Chest"].Bag.Number(exists)} 
   { 
      call lootContainer "Battered Chest" 
   } 
   while ${Item["Large Battered Chest"].Slot(exists)} && ${Item["Large Battered Chest"].Bag.Number(exists)} 
   { 
      call lootContainer "Large Battered Chest" 
   } 
}


function lootContainer(string itemName) 
{ 
   if !${Me.Casting} 
   { 
      Item["${itemName}"]:Use 
      wait 10 ${LootWindow(exists)} 

      lootall 
      wait 15 !${LootWindow(exists)} 
   } 
   else 
   { 
      wait 10 
   } 
}

atom(script) immunechecks(string eventid , text, Message)
{
	if ${Message.Find["Serpent Sting"]}&&${Message.Find["failed"]}&&${Message.Find["immune"]}
	{
		declare Immune-Serp bool global TRUE
	}
	
	if ${Message.Find["afflicted by Serpent Sting"]}||${Message.Find["damage from your Serpent Sting"]}
	{
		declare Immune-Serp bool global FALSE
	}
}