;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Original Author: steelx01 ;
; Current Author: Tenshi    ;
; tweaked by rummie	    ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;Configuration options- Comment out to enable/disable

;#define PICK_POCKETS
;#define USE_VANISH
#define VANISH_HP_PCT 10
#define USE_EVASION
#define SINGLE_EVADE_HP 30		/* pop evasion under % hp when fighting 1 mob */
#define EVADE_AGGRO 1 	   		/* pop evasion if more than X mobs aggro'd AND..*/
#define MULTI_EVADE_HP  40 		/* MyHP less than this */
;#define USE_ADRENALINE
;#define ADRENALINE_HP_PCT 40
;#define SAVE_ADRENALINE_ADDS
;#define USE_FLURRY
;#define USE_GHOSTLY_STRIKE
;#define USE_HEMO
#define USE_BAND			/* Bandage post-combat? */
#define BAND_HP 37			/* % hp to bandage below */
#define BANDAGE_NAME Runecloth Bandage  /* explicit name of bandage, no quotes */
;#define GOUGE_BAND			/* enable gouge/bandage combo on single mob if hp below... */
;#define USE_GOUGE
;#define GOUGE_BAND_HP 50
#define BLIND_BAND			/* when fighting 1 mob, enable blind/bandage combo below... */
#define BLIND_BAND_HP 40                /* ...configurable HP percent ?? */
#define SINISTER_COST 45   		/* adjust to reflect talents */
#define EV_MULT 15 			/* combo points * multi = mob health % to FINISHING_MOVE */
#define FINISH_POINTS 4         	/* always FINISHING_MOVE at or above this many combo points */
#define FINISHING_MOVE Eviscerate     /* eviscerate, envenom, etc. no quotes. */
#define JUMP_CHANCE 90          	/* 100-JUMP_CHANCE = chance that char will jump while SS/Evisc */
#define USE_KICK			/* comment out to prevent frivolous kicking */
#define USE_SLICE			/* use slice and dice? */
#define SLICE_POINTS 2			/* slice and dice when combo points <= X and mob hp>50% */
#define RANGED_SPELL Throw		/* exact name of ranged spell, no quotes- Throw Shoot etc. */
;#define RANGED_PULL  			/* Open with Ranged?      ---{DO NOT DEFINE BOTH SIMULTANEOUSLY */
#define CS_PULL    			/* Open with CheapShot?   ---{THERE WILL BE PROBLEMS */
#define HEIGHT_DIFF 1000000             /* note - using CS_PULL, bot will still pull w/ ranged weapon if it exists and the target
					 * mob has a significantly different Z, ie. to avoid getting stuck on hills */

#define POISON_MAIN
#define POISON_OFF
#define MAINHAND_POISON "Deadly Poison IV"	/* explicit names necessary, */
#define OFFHAND_POISON  "Deadly Poison IV"        /* ie. Instant Poison, Deadly Poison III, etc. */
;#define PATROL_STEALTH			/* stealth on patrol? (CS_PULL defined will cause stealth on pull regardless */
#define STEALTH_PULL "Cheap Shot"		/* explicit name of stealth pull attack */



function RogueDebug(string Text)
{
	;echo [${Time.Time24}] ROGUEDEBUG: ${Text}
	;redirect -append roguedebug.txt echo [${Time.Time24}] ROGUEDEBUG: ${Text}
}

/* START ROAMPREP CODE */
function RoamPrep()
{

}

/* START ADVANCEPREP CODE */
function AdvancePrep()
{
 if ${MyMount(exists)} && !${Me.Mount(exists)} && !${Me.Buff[Ghost](exists)} && !${Me.Buff[Wisp](exists)}
      {
         move -stop
         wait 10
         if ${MountSpell}
         {
            cast "${MyMount}"
         }
         else
         {
            Item["${MyMount}"]:Use
         }
         wait 80 ${Me.Mount(exists)}
      }


} 

function CombatPrep()
{

call Dismount	
	/*#ifdef PATROL_STEALTH
	{
		call RogueDebug "Going into stealth"
		cast "Stealth"
	}
	#endif
	*/
	;Reset flag
	DoCombatPrep:Set[FALSE]
}

function Attack(string AttackGUID)
{
	
	
	declare diff float local
	declare SavX float local ${Me.X}
	declare SavY float local ${Me.Y}
	declare SavZ float local ${Me.Z}
	declare BailOut int local ${Math.Calc[${LavishScript.RunningTime}+(1000*${CombatBailout})]}
	declare EvMult int local 
	declare HavePulled bool local FALSE
	declare StuckCheck bool local FALSE
	declare ClosedToMelee bool local FALSE
	declare StuckCheckTime int local
	declare Aggros guidlist local
	declare ObstacleCheckTimer bool local TRUE
	declare PoisonOfChoice string
	declare jump_value int local
	
	EvMult:Set[EV_MULT]
	
	if ${AttackGUID.Equal[NULL]}||${AttackGUID.Equal[NOTARGET]}
	{
		call UpdateHudStatus "No target to attack"
	}
	
	call UpdateHudStatus "Attacking ${Object[${AttackGUID}].Name}" 
	
	call Dismount
	
	Do
	{
		;attempt to bailout on teleported mob
		if ${ClosedToMelee} && ${HavePulled} && ${Unit[${AttackGUID}].Distance}>20 && ${Unit[${AttackGUID}].PctHPs}>15
								
		{
			call UpdateHudStatus "I think mob was teleported, bailing. Verify?"
			TargetGUID:Set[NOTARGET]
			Return			
		}  
		
		
		SavX:Set[${Me.X}]
		SavY:Set[${Me.Y}]
		SavZ:Set[${Me.Z}]
		
		; Ensure we are still facing our target loc
		
		call ImpFacePrecision ${Unit[${AttackGUID}].X} ${Unit[${AttackGUID}].Y}
		call CheckFacing
		
		; Check we still have a valid target
		if !${Unit[${AttackGUID}](exists)}
		{
			call UpdateHudStatus "Target lost"
			TargetGUID:Set[NOTARGET]
			Return
		}
		
		; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return			
		}  

		; no swimmers
		if ${Target.Swimming} && !${Me.Swimming}
		{
			call UpdateHudStatus "I'd rather not drown thx"
			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 
   		   } 

		call CheckAggro
		
		; If we dont have our chosen unit targeted and were in range target it
		if !${Target.GUID.Equal[${AttackGUID}]}
		{
			#ifdef DEBUG
			call Debug "Targeting Unit ${Unit[${AttackGUID}].Distance}[${AttackGUID}]"
			#endif
			Target ${AttackGUID}
			waitframe
		}
		
		
		;if we are pulling and CS'ing and we aren't stealthed then do it
		#ifdef CS_PULL
		if ${Target.Distance}<18 && !${Me.InCombat} && !${Me.Buff[Stealth](exists)} && !${Spell[Stealth].Cooldown}
		{
		cast "Stealth"
		waitframe
		}
		#endif
		
		if ${Unit[${AttackGUID}].Tapped}
				{
					call UpdateHudStatus "Target already engaged"
					TargetGUID:Set[NOTARGET]
					Return			
		}  
		;jump_value:Set[${Math.Rand[100]}]
		;if (jump_value < JUMP_CHANCE)-1
		;		{
		;		wowpress Jump
		;}
		;jump_value:Clear
		
		if !${Me.Attacking}&&${Target(exists)}&&!${Me.Buff[Stealth](exists)}
		{
			WoWScript AttackTarget()
		}


; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return
		}
		; Check we havent picked up aggro
		Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-20]
		if ${Aggros.Count}>0
		{
			#ifdef USE_VANISH
			if ${Aggros.Count}>3
			{
				RLG:Set[TRUE]
				call CastSpell "Vanish"
				return
			}
			#endif
			
			#ifdef USE_EVASION
			if ${Aggros.Count}>EVADE_AGGRO&&!${Spell[Evasion].Cooldown}&&${Me.PctHPs}<MULTI_EVADE_HP || ${Aggros.Count}&&!${Spell[Evasion].Cooldown}&&${Me.PctHPs}<SINGLE_EVADE_HP && ${Target.PctHPs}>25
			{
				Call CastSpell "Evasion"
			}
			#endif
			
			#ifdef USE_ADRENALINE
			if ${Aggros.Count}>1&&!${Spell[Adrenaline Rush].Cooldown}&&${Spell[Blade Flurry].Cooldown} && !${Me.Buff[Blade Flurry](exists)} || ${Me.PctHPs}<MULTI_EVADE_HP && ${Target.PctHPs}>30 && ${Spell[Evasion].Cooldown} && !${Spell[Adrenaline Rush].Cooldown} && !${Me.Buff[Evasion](exists)}&&${Spell[Blade Flurry].Cooldown}<110000
			{
				call CastSpell "Adrenaline Rush"
			}
			#endif
		}
		Aggros:Clear
	
	
	
	; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return
		}

/*
		;if ${Target.Distance} >= ${CombatMaxDist}
		if ${Target.Distance} >= ${PullingRange} && !${HavePulled}
		{
			call ImpFacePrecision ${Target.X} ${Target.Y}
			call CheckFacing
			move forward
			do
			{
        	
				call ImpFacePrecision ${Target.X} ${Target.Y}
				call CheckFacing
				move forward
				WaitFrame
			}
			while ${Target.Distance}>= ${PullingRange}

			move -stop forward

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

;#ifdef CS_PULL
;HavePulled:Set[TRUE]
;#endif

;Check that we are not already there!
           if ${Target.Distance}>= ${CombatMaxDist} 
           ;&& ${HavePulled}
           {
              Do
              {
                 #ifdef CS_PULL
		 		if ${Target.Distance}<18 && !${Me.InCombat} && !${Me.Buff[Stealth](exists)} && !${Spell[Stealth].Cooldown}
		 		{
		 		cast "Stealth"
		 		waitframe
		 		}
		#endif
                 
                 
                 ;ensure we are still facing our target loc
                 call ImpFacePrecision ${Target.X} ${Target.Y}

                 ;press and hold the forward button
                 wowpress -hold moveforward

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

                 ;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
                 {
                    call Obstacle2
                 }
                 ;store our current location for future checking
                 SavX:Set[${Me.X}]
                 SavY:Set[${Me.Y}]
                 SavZ:Set[${Me.Z}]
                 if ${Unit[${AttackGUID}].Tapped}
		 		{
		 			call UpdateHudStatus "Target already engaged"
		 			TargetGUID:Set[NOTARGET]
		 			Return			
		}  
                 
              }
              while (${Target.Distance} >= ${CombatMaxDist}&&(${LavishScript.RunningTime}<${BailOut})

              ;Made it to our target loc
              wowpress -release moveforward
           }
		
		;diff:Set[${Math.Calc[${Target.Z}-${Me.Z}]}]
		#ifdef CS_PULL
		{
			/*
			if ${Unit[${AttackGUID}].Distance}<30&&!${Me.InCombat} && !${HavePulled} && ${Me.Equip[ranged].Durability}>0 && ${Math.Abs[${diff}]}>=HEIGHT_DIFF
			{
			call UpdateHudStatus "Ranged pull b/c height difference ${Math.Calc[${Target.Z}-${Me.Z}]}"
			call CastSpell "RANGED_SPELL" ${Target.GUID}
			wait 60 ${Target.Distance}<10
			}
			*/	
			
			;else
			if !${Me.InCombat} && !${Me.Buff[Stealth](exists)} && !${Spell[Stealth].Cooldown} && ${Target.Distance}<18
			{
			cast "Stealth"
			HavePulled:Set[TRUE]
			}
			
			
		}
		
		#endif

; Check if we have pulled yet and if not do so.
		#ifdef RANGED_PULL
		if ${Unit[${AttackGUID}].Distance}<30&&!${Me.InCombat} && !${HavePulled} && ${Me.Equip[ranged].Durability}>0
		{
		do
					{
		        	
						;call ImpFacePrecision ${Target.X} ${Target.Y}
						;call CheckFacing
						move forward
						WaitFrame
					}
				while ${Target.Distance} >= ${PullingRange} && !${HavePulled}
		
		          call UpdateHudStatus "Supposed to be pulling but I'm a stupid piece of shit. Dist ${Target.Distance}"
			  move -stop
			  call CastSpell "RANGED_SPELL" ${AttackGUID}
			  wait 60 ${Target.Distance}<=${CombatMaxDist}
			  HavePulled:Set[TRUE]
		}
		else
		{
			if ${Unit[${AttackGUID}].Distance}<10
			{
			HavePulled:Set[TRUE]
			}
		}
		#endif
		
;		#ifdef CS_PULL
;		HavePulled:Set[TRUE]
;		#endif
		
		
		;if ${Me.InCombat}
;{
		
	/*
	if ${Target.Distance} >= ${CombatMaxDist}
		;		if ${Target.Distance} >= ${PullingRange}
				{
					call ImpFacePrecision ${Target.X} ${Target.Y}
					call CheckFacing
					move forward
					do
					{
		        	
						call ImpFacePrecision ${Target.X} ${Target.Y}
						call CheckFacing
						move forward
						WaitFrame
					}
					while ${Target.Distance}>= ${CombatMaxDist}
		
					move -stop forward
		
					;wait for half a second to give our pc a chance to move
					wait 5
		}
	*/
		if ${Unit[${AttackGUID}].Distance}<${CombatMinDist}
		{
			#ifdef DEBUG
			call Debug "Too close backing up"
			#endif
			;press and hold the backward button 
			wowpress -release moveforward
			wowpress -hold movebackward
			wait 3
		}


; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return
		}
		

		if ${Me.Buff[Stealth](exists)} && ${Unit[${AttackGUID}].Distance}<6 && ${Me.Action[Cheap Shot].Usable}
		{
			#ifdef PICK_POCKETS
			call CastSpell "Pick Pocket" ${Target.GUID}
			waitframe
			#endif
			
			if ${Target.CreatureType.Equal[Humanoid]} || ${Target.CreatureType.Equal[Demon]}
						{
										call CastSpell "Pick Pocket" ${Target.GUID}
										waitframe
			}
				
			Do
			{
			wowpress -hold moveforward
			call CastOnRun "Cheap Shot" ${Target.GUID}
			waitframe
			}
			while ${Me.Buff[Stealth](exists)} && ${Unit[${AttackGUID}].Distance}<5
			
			
			
			
			
			HavePulled:Set[TRUE]
			
		}
		
		;If we are close enough stop running
				if ${Unit[${AttackGUID}].Distance}>${CombatMinDist}&&${Unit[${AttackGUID}].Distance}<${CombatMaxDist}
				{
					waitframe
					wowpress -release moveforward
					wowpress -release movebackward
					StuckCheck:Set[FALSE]
				}
		
		#ifdef USE_GOUGE
		; Use Gouge and Backstab, if available
		if ${Me.Target(exists)}&&${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>45&&${Spell[Backstab](exists)}&&!${Spell[Backstab].Cooldown}&&${Target.PctHPs}>0
		{
			call GougeBackstab
		}
		#endif
		
		#ifdef BLIND_BAND
		Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-30]
		if ${Aggros.Count}<=1 && ${Me.PctHPs}<BLIND_BAND_HP && ${Item[-inventory,BANDAGE_NAME](exists)} && ${Item[-inventory,Blinding Powder](exists)} && !${Me.Buff[Recently Bandaged](exists)} && ${Me.CurrentEnergy}>${Spell[Blind].Mana} && !${Spell[Blind].Cooldown}
		{
			call CastSpell "Blind" ${Target.GUID}
			wait 20 ${Target.Buff[Blind](exists)}
			if ${Target.Buff[Blind](exists)}
			{
				call BandageMe
			}
		
		}
		#endif
		
		if ${Me.Action[Riposte].Usable}&&${Unit[${AttackGUID}].Distance}<5 && ${Me.CurrentEnergy}>10 && ${Spell[Riposte](exists)} && !${Spell[Riposte].Cooldown}
		{ 
			call CastSpell "Riposte" ${Target.GUID}
		}


		#ifdef USE_KICK
		if ${Unit[${AttackGUID}].Distance}<5&&${Target.Casting.ID(exists)}&&${Me.CurrentEnergy}>25 & ${Spell[Kick](exists)}
		{					
			call CastSpell "Kick" ${Target.GUID}
		}
		#endif

		#ifdef USE_FLURRY
		Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-5]
		if ${Aggros.Count}>1
		{
			if ${Target.PctHPs}>25&&!${Spell[Blade Flurry].Cooldown}&&${Me.CurrentEnergy}>25&&${Spell[Blade Flurry](exists)} && !${Me.Buff[Blade Flurry](exists)}
			{
			call CastSpell "Blade Flurry"
			}
		}
		Aggros:Clear
		#endif

; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return
		}
		
		
		if ${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>=25&&${Target.PctHPs}>48&&!${Spell[Kidney Shot].Cooldown}&&${WoWScript[GetComboPoints()]}>=4
   		{
   			call CastSpell "Kidney Shot" ${Unit[${AttackGUID}]}
   		}
   		
   		
   		if ${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>=35&&${Math.Calc[(${WoWScript[GetComboPoints()]}*${EvMult})]}>${Target.PctHPs}&& !${Spell[FINISHING_MOVE].Cooldown} || ${Unit[${AttackGUID}].Distance}<5 && ${Me.CurrentEnergy}>35 && (${WoWScript[GetComboPoints()]}>=FINISH_POINTS)
					        {
							ClosedToMelee:Set[TRUE]
							if !${Spell[Cold Blood].Cooldown} && ${Spell[Cold Blood](exists)}
							{
								call CastSpell "Cold Blood"
								wait 10
							}
							call UpdateHudStatus "FINISHING_MOVE because Multi value ${WoWScript[GetComboPoints()]}*${EvMult} > Mob Health ${Target.PctHPs}"
							call CastSpell "FINISHING_MOVE"  ${Target.GUID}
                				}

		
	
		#ifdef USE_SLICE
		Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-20]
		if ${Unit[${AttackGUID}].Distance}<5&&(${Me.CurrentEnergy}>${Spell[Slice and Dice].Mana})&&!${Spell[Slice and Dice].Cooldown}&&${WoWScript[GetComboPoints()]}<=SLICE_POINTS && ${Target.PctHPs}>50 && !${Me.Buff[Slice and Dice](exists)} || (${Me.CurrentEnergy}>${Spell[Slice and Dice].Mana})&&!${Spell[Slice and Dice].Cooldown}&&${WoWScript[GetComboPoints()]}<=2 && ${Aggros.Count}>1 && !${Me.Buff[Slice and Dice](exists)}
		{
			ClosedToMelee:Set[TRUE]
			call CastSpell "Slice and Dice"  ${Me.GUID}
			waitframe
		}
		Aggros:Clear
		#endif
		
		;jump_value:Clear
				
		#ifdef USE_GHOSTLY_STRIKE
		if ${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>= 40 &&!${Spell[Ghostly Strike].Cooldown}&&${Spell[Ghostly Strike](exists)}
				{
				
					jump_value:Set[${Math.Rand[100]}]
					if (${jump_value}>JUMP_CHANCE)
						{
						wowpress jump
						}		
					call CastSpell "Ghostly Strike"  ${Target.GUID}
					waitframe
		}
		#endif
		
		if ${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>SINISTER_COST&&!${Spell[Sinister Strike].Cooldown}
		{
			jump_value:Set[${Math.Rand[100]}]
			if (${jump_value}>JUMP_CHANCE)
				{
				wowpress jump
				}		
			ClosedToMelee:Set[TRUE]
			call CastSpell "Sinister Strike"  ${Target.GUID}
			waitframe
		}

		if ${Unit[${AttackGUID}].Distance}<5&&${Me.CurrentEnergy}>35&&${Math.Calc[(${WoWScript[GetComboPoints()]}*${EvMult})]}>${Target.PctHPs} && !${Spell[FINISHING_MOVE].Cooldown} || ${Unit[${AttackGUID}].Distance}<5 && ${Me.CurrentEnergy}>35 && (${WoWScript[GetComboPoints()]}>=FINISH_POINTS)
					        {
							if !${Spell[Cold Blood].Cooldown} && ${Spell[Cold Blood](exists)}
							{
								call CastSpell "Cold Blood"
								wait 10
							}
							call UpdateHudStatus "Evisc because Multi value ${WoWScript[GetComboPoints()]}*EV_MULT > Mob Health ${Target.PctHPs}"
							jump_value:Set[${Math.Rand[100]}]
											if (${jump_value}>JUMP_CHANCE)
											{
											wowpress jump
											}	
		
							call CastSpell "FINISHING_MOVE"  ${Target.GUID}
                }

		
; Check if the target is engaged already
		if ${Unit[${AttackGUID}].Tapped}
		{
			call UpdateHudStatus "Target already engaged"
			TargetGUID:Set[NOTARGET]
			Return
		}		
		#ifdef USE_VANISH
		if ${Unit[${AttackGUID}].Distance}<5&&${Me.PctHPs}<=VANISH_HP_PCT&&${Target.PctHPs}>=35
		{
			RLG:Set[TRUE]
			call CastSpell "Vanish"  ${Target.GUID}
			return
		}
		#endif

		call snarfpotion
		
		if ${ObstacleCheckTimer}
		{
			; Check to make sure we have moved since the last check and if not then try and avoid the
			; obstacle thats in our path
			;if ${Math.Calc[${Me.X}-${SavX}]}<1&&${Math.Calc[${Me.Y}-${SavY}]}<1&&${Unit[${AttackGUID}].Distance}>${CombatMaxDist}
			if ${Math.Distance[${Me.X},${Me.Y},${SavX},${SavY}]}<1 && ${Unit[${AttackGUID}].Distance}>${CombatMaxDist}
			{
				; I think i might be stuck so jump then save off the current time
				;jump_value:Set[${Math.Rand[100]}]
				;		if jump_value<JUMP_CHANCE-1
				;				{
				;				wowpress Jump
				;				}
				;jump_value:Clear
				wowpress jump
				if !${StuckCheck}
				{
					#ifdef DEBUG
						call Debug "I might be stuck"
					#endif
					StuckCheck:Set[TRUE]
					StuckCheckTime:Set[${LavishScript.RunningTime}]
				} 
				else
				{
					; If I am still stuck after .4 seconds then try and avoid the obstacle.
					if ${Math.Calc[${LavishScript.RunningTime}-${StuckCheckTime}]}>400
					{
						#ifdef DEBUG
							call Debug "Yep I am stuck trying to free myself"
						#endif
						wowpress Jump
						;StuckCheck:Set[TRUE]
					}
				
					; If I am still stuck after 3 seconds then try and avoid the obstacle.
					if ${Math.Calc[${LavishScript.RunningTime}-${StuckCheckTime}]}>3000
					{
						#ifdef DEBUG
							call Debug "Yep I am stuck trying to free myself"
						#endif
						call Obstacle
						StuckCheck:Set[FALSE]
					}
				}
			}
			
			; If I have moved away from my saved spot reset my stuck toggle
			if ${StuckCheck}&&${Math.Calc[${Me.X}-${SavX}]}>3||${Math.Calc[${Me.Y}-${SavY}]}>3
			{
				#ifdef DEBUG
					call Debug "I am no longer stuck"
				#endif
				StuckCheck:Set[FALSE]
			}
		
			; Check if we have exceeded bail out timer
			if ${LavishScript.RunningTime}>${BailOut}
			{
				GUIDBlacklist:Set[${TargetGUID},AVOID]
				call UpdateHudStatus "Combat timeout reached"
				TargetGUID:Set[NOTARGET]
				return
			}
			
			; Store our current position.
			SavX:Set[${Me.X}]
			SavY:Set[${Me.Y}]
			
			; Set a timer to check our position again in a second or so.
			TimedCommand 5 ObstacleCheckTimer:Set[TRUE]
		}
		
				
	}
;}
	while !${Unit[${AttackGUID}].Dead}&&!${Me.Dead}
	{
		; Update stats
		if !${Me.Dead}
		{
			call UpdateStats
		}
	}

	
	

	wowpress -release movebackward
	wowpress -release moveforward

	call RogueDebug "Checking Aggro before Downtime"
	;Reset flags to do combat prep and downtime if we are not still aggroed
	Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-50]
	call RogueDebug "Found ${Aggros.Count} aggros"
	if !${Aggros.Count}
	{
		call Debug "Resetting Downtime and CombatPrep Flags"
		DoDowntime:Set[TRUE]
		DoCombatPrep:Set[TRUE]
	}
	Aggros:Clear

}

function snarfpotion() 
{ 
;call UpdateHudStatus "Checking to see if I need to use a potion"
;this needs to be rewritten for mana potions. Priests can heal themselfs if they have mana

if ${Item[Greater Healing Potion](exists)} 
    { 
    if (${Me.PctHPs}<25)&&(${Target.PctHPs}>35) 
       { 
       call UpdateHudStatus "Snarfing Greater Healing Potion" 
       Item[Greater Healing Potion]:Use 
       return 
       } 
    } 
if ${Item[Healing Potion](exists)} 
    { 
    if (${Me.PctHPs}<25)&&(${Target.PctHPs}>35) 
       { 
       call UpdateHudStatus "Snarfing Healing Potion" 
       Item[Healing Potion]:Use 
       return 
       } 
    } 
if ${Item[Lesser Healing Potion](exists)} 
    { 
    if (${Me.PctHPs}<25)&&(${Target.PctHPs}>35) 
       { 
       call UpdateHudStatus "Snarfing Lesser Healing Potion" 
       Item[Lesser Healing Potion]:Use 
       return 
       } 
    } 
if ${Item[Minor Healing Potion](exists)} 
    { 
    if ${Me.PctHPs}<25 && ${Target.PctHPs}>35 
       { 
       call UpdateHudStatus "Snarfing Minor Healing Potion" 
       Item[Minor Healing Potion]:Use 
       return 
       } 
    } 
} 

function Downtime()
{
	call UpdateStats
	
	#ifdef USE_BAND
	{
		if ${Me.PctHPs}<BAND_HP
			{
			call BandageMe
			}
	}
	#endif
	
	wait 10
	call RogueDebug "I ENTERED DOWNTIME... ${Me.PctHPs}<${MinHealthPct}"

	if ${Me.PctHPs}<${MinHealthPct}
	{
		call RogueDebug "Check Durability"
		call CheckDurability
		wait 10
		call RogueDebug "Begin While... ${Me.PctHPs}<99&&!${Me.InCombat}&&!${Me.Dead}&&!${Me.Ghost}"
		while ${Me.PctHPs}<90&&!${Me.InCombat}&&!${Me.Dead}&&!${Me.Ghost}
		{
			call RogueDebug "Eating yadda"
			if ${SitWhenRest} && !${Me.Sitting}
			{
				wowpress SITORSTAND
			}

			if ${Me.PctHPs}<${MinHealthPct} && !${Me.Buff[Food](exists)}
			{
				call Eat
				cast "Stealth"
				wait 40 ${Me.Buff[Food](exists)}
			}

			waitframe 
  		 }
	}

	if ${Me.Sitting}
		{
		wowpress SITORSTAND
		}
	
	#ifdef POISON_MAIN
	if !${Me.InCombat} && !${Me.Equip[mainhand].Enchantment[MAINHAND_POISON](exists)} && ${Item[MAINHAND_POISON](exists)}
	{
		wait 10
		Item[MAINHAND_POISON]:Use
		wait 20 ${WoWScript[SpellIsTargeting()]}

		; Check if the spell is awaiting a target and supply one if it is
		if ${WoWScript[SpellIsTargeting()]}
		{
			Object[${Me.Equip[mainhand]}]:PickUp
			wait 20 ${Me.Casting}
		}
		wait 50 !${Me.Casting}
	}
	#endif 
	
	#ifdef POISON_OFFHAND
   	; Check for poison on our off hand, if duel wielding
	if !${Me.InCombat} && ${Me.Equip[offhand](exists)} && !${Me.Equip[offhand].Enchantment[OFFHAND_POISON](exists)} && ${Item[OFFHAND_POISON](exists)}
	{
		wait 10
		Item[OFFHAND_POISON]:Use
		wait 20 ${WoWScript[SpellIsTargeting()]}

		; Check if the spell is awaiting a target and supply one if it is
		if ${WoWScript[SpellIsTargeting()]}
		{
			Object[${Me.Equip[offhand]}]:PickUp
			;Object[OFFHAND]:Pickup
			;type /use 17
			;press enter
			wait 20 ${Me.Casting}
		}
		wait 50 !${Me.Casting}
	}	
	#endif
	
	call check_for_lootable_containers
	
	#ifdef PATROL_STEALTH
	if !${Me.Buff[Stealth](exists)} && !${Spell[Stealth].Cooldown}
	cast "Stealth"
	#endif
	; Reset downtime flag
	DoDowntime:Set[FALSE]
}

function BandageMe()
{
if !${Me.Buff[Recently Bandaged](exists)} && ${Item[-inventory,BANDAGE_NAME](exists)} && ${Item[-inventory,BANDAGE_NAME].Usable}
	{
	declare FormerTarget string ${Me.Target}
	target ${Me.GUID}
	{
	Item[BANDAGE_NAME]:Use
	wait 20 ${Me.Casting}
	}
	wait 100 !${Me.Casting}
	target ${FormerTarget}
	}
}

function GougeBackstab()
{
        MainHandWeaponSubType:Set[${Me.Equip[16].SubType}]

        call CastSpell "Gouge" ${Target.GUID}
        wait 10 ${Me.Target.Buff[Gouge](exists)}
        if ${Me.Target.Buff[Gouge](exists)}
        {
                if !${MainHandWeaponSubType:Equal[Dagger]}
                {
                        echo "Switching to Dagger"
                        Me.Bag[0].Item[1]:Use
                        waitframe
                        call MoveBehind 1
                        wait 40 ${Me.CurrentEnergy}>=60
                        if ${Me.CurrentEnergy}>=60
                        {
                                echo "Casting Backstab 03"
                                call CastSpell "Backstab" ${Target.GUID}
                                echo "Backstab 03 Complete"
                        }
                        echo "Switching to Normal"
                        Me.Bag[0].Item[1]:Use
                        wait 10
                }
                else
                {
                        call MoveBehind 1
                        wait 40 ${Me.CurrentEnergy}>=60
                        if ${Me.CurrentEnergy}>=60
                        {
                                echo "Casting Backstab 04"
                                call CastSpell "Backstab" ${Target.GUID}
                                echo "Backstab 04 Complete"
                                wait 10
                        }
                }
        }
}

function MoveBehind(float Precision)
{
   declare PointX float local
   declare PointY float local
   declare degrees float local
   declare SavX float local ${X}
   declare SavY float local ${Y}
   ;set BailOut timer (4 minutes)
   declare BailOut int local ${Math.Calc[${LavishScript.RunningTime}+(1000*240)]}
   
   call UpdateHudStatus "Attempting to move behind target."
   ;Check that we are not already there!
   if "${Math.Distance[${Me.X},${Me.Y},${PointX},${PointY}]}>${Precision}"
   {
      echo "Moving Behind Target"
      Do
      {   
         echo "Moving Behind Target 02"
         degrees:Set[${Target.Heading.DegreesCCW}+180]
         ;The number below, the Precision, and the movement of the mob will determine the distance
         PointX:Set[${Math.Calc[2*${Math.Cos[${degrees}].Milli}+${Target.X}]}]
         PointY:Set[${Math.Calc[2*${Math.Sin[${degrees}].Milli}+${Target.Y}]}]
         
         ;press and hold the forward button
         ;wowpress -hold moveforward
         move forward
         
         ;ensure we are still facing our target loc
         Face -fast  ${PointX} ${PointY}
         ;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 ${Me.X}==${SavX}&&${Me.Y}==${SavY}
         {
            call Obstacle
         }
         ;store our current location for future checking
         SavX:Set[${Me.X}]
         SavY:Set[${Me.Y}]
      }
      while "(${Math.Distance[${Me.X},${Me.Y},${PointX},${PointY}]}>${Precision})&&(!${Me.Dead})&&(!${Me.InCombat})&&(${LavishScript.RunningTime}<${BailOut})"

      ;Made it to our target loc
      move -stop
      waitframe
      face -fast ${Target.X} ${Target.Y}
      echo "Movement Completed"
   }
}

function Dismount()
{
if ${Me.Mount(exists)}
      {
         if ${MountSpell}
         {
            Me.Buff["${MyMount}"]:Remove
         }
         else
         {
            Item["${MyMount}"]:Use
         }
         wait 30 !${Me.Mount(exists)}
      }    
}

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

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


function check_for_lootable_containers() 
{ 
   while ${Item["Big-mouth Clam"].Slot(exists)} && ${Item["Big-mouth Clam"].Bag.Number(exists)} 
   { 
      call lootContainer "Big-mouth Clam" 
   } 
   
      while ${Item["Scum Covered Bag"].Slot(exists)} && ${Item["Scum Covered Bag"].Bag.Number(exists)} 
      { 
         call lootContainer "Scum Covered Bag" 
      } 

   
   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" 
   } 
}