/* CrazyRogue for OpenBot v1.24 rogue routine by Oog */
objectdef oClass inherits oBase
{		
	;----------------------
	;--- Variables ---
	;----------------------
	
	variable int crazyWaitTimer = 0
	variable int restWaitTimer = 0   
	variable int lootWaitTimer = 0
	variable int buffWaitTimer = 0   
	variable int pullbuffWaitTimer = 0   
	variable int combatbuffWaitTimer = 0   
	variable int pullWaitTimer = 0   
	variable int attackWaitTimer = 0
	variable int kiteWaitTimer = 0
	variable int pullTimeOut = 0
	variable bool kiteCheck = FALSE
	variable bool startMoveBehind = FALSE
	variable bool backattackPause = FALSE
	variable int backattackWaitTimer = 0
	variable bool checkPockets = TRUE
	variable bool checkDistract = TRUE
	variable bool buffPause = FALSE
	variable string lastAttackTarget
	variable string OppositeFaction
	variable point3f backstabLoc
	variable bool moveBehind = FALSE
	variable int PersistentTarget = 0
	variable oLockpick Lockpick
        variable bool MakeBand = FALSE
	
	;----------------------
	;--- Init and Shutdown ---
	;----------------------
	
	method Initialize()
	{
		if ${Me.FactionGroup.Equal[Alliance]}
		{
			OppositeFaction:Set["Horde"]
		}
		if ${Me.FactionGroup.Equal[Horde]}
		{
			OppositeFaction:Set["Alliance"]
		}
		This.Lockpick:PickingStrings
		This:CreateUIErrorStrings		
		This:SetGUI
	}

	method Shutdown()
	{
		This:SaveGUI
	}	


	;------------------
	;--- 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
	}	
	
	;------------------
	;--- Party Mode ---
	;------------------
	
	member IsPartyLeader()
	{
		variable int i = 1
		; returns a check that determines if the bot is in party mode
		if ${Group.Members} > 0
		{
			if ${WoWScript[IsPartyLeader()]}
			{
				return TRUE
			}
			do
			{
				if ${Group.Member[${i}](exists)}
				{
					return FALSE
				}
			}
			while ${Group.Members} >= ${i:Inc}
		}
		return TRUE
	}		
	
	;------------------
	;--- Flee SetUp ---
	;------------------
	
	variable bool HookFlee = TRUE
	method FleePulse()
	{
		if ${Flee.Avoiding} && !${Mount.IsMounted}
		{
			if ${Me.InCombat} && ${Toon.canCast[Vanish]}
			{
				Toon:CastSpell[Vanish]
				return
			}
			if ${This.shouldStealth}
			{
				Toon:CastSpell[Stealth]
				return
			}
		}
		if ${Toon.canBuff[${Me.GUID},Sprint]}
		{
			Toon:CastSpell[Sprint]
			This:Output[SPRINT!!  We need to Flee!!]
			return
		}
		if ${Me.Attacking}
		{
			WoWScript AttackTarget()
			return
		}		
	}
	
	;------------------
	;--- Dead SetUp ---
	;------------------
	
	member NeedDead()
	{
		return FALSE
	}
	method DeadPulse()
	{
		; This is where you would do stuff while Dead before Release	
	}

	;------------------
	;--- Idle SetUp ---
	;------------------
	
	variable bool NeedCombatIdle = FALSE
	method CombatIdle()
	{
		; stuff to do while Idle in Combat		
	}	
	
	;------------------
	;--- Rest SetUp ---
	;------------------
	
	member NeedRest()
	{			
		/* If I'm in combat, I don't need rest */
		if ${Me.InCombat} || ${Targeting.realAgg}
		{
			return FALSE
		}
		
		/* If I have rez sickness, I should wait in rest */
		if ${Me.Buff[Resurrection Sickness](exists)} && !${This.IsAssistMode}
		{
			return TRUE
		}	
		
		/* skip rest to loot */
		if ${This.SkipToLoot}
		{
			return FALSE
		}		
		
		/* The red warrior is about to die! */
		if ${Me.PctHPs} < ${Config.GetSlider[sldRestHP]}
		{
			return TRUE
		}	
		
		/* I'm eating, stay stitting */
		if ${Me.PctHPs} < ${Config.GetSlider[sldStandHP]} && ${Toon.Sitting}
		{
			return TRUE
		}
		
		if ${This.lootWaitTimer} > ${LavishScript.RunningTime}
		{
			return FALSE
		}	
		
		if ${Config.GetCheckBox[chkPatrolInStealth]}&&${This.shouldStealth}&&${Me.PctHPs}>${Config.GetSlider[sldRestHP]}&&!${Toon.Sitting}
		{		
			if ${POI.Type.Equal[HOTSPOT]} && !${Mount.NeedMount}&& !${Mount.IsMounted} 
			{
				return TRUE
			}
		}
		
		/* I'm doing something in rest, so lets not jinx it */
		if ${This.restWaitTimer}>0
		{
			return TRUE
		}
		if ${Item[-inventory,"Bandage"].Count} <= 5
		{
			return TRUE
		}
		return FALSE
	}
	
	method RestPulse()
	{
		if ${Movement.Speed}
		{
			Toon:Stop
		}
		
		if (${This.restWaitTimer} < ${LavishScript.RunningTime})&&(${This.lootWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})
		{
			This:ClearWaitTimers
			This.pullTimeOut:Set[0]
			
			/* casting, return */
			if ${Me.Casting}&&!${WoWScript[SpellIsTargeting()]}
			{
				This:Output["Casting..."]
				This.restWaitTimer:Set[${This.InMilliseconds[25]}]
				return
			}
			


			/* bandage if you got em */
			if ${Me.PctHPs}<${Config.GetSlider[sldHealthForBandage]} && ${Toon.canBandage} && !${Toon.Sitting}
			{
				Toon:Bandage
				return
			}
			
			/* cannibalize */
			if ${Config.GetCheckBox[chkRacial]}&&${Me.Race.Equal["Undead"]} && !${Toon.Sitting}
			{
				if ${Me.PctHPs} < ${Config.GetSlider[sldStandHP]} && ${Toon.canCast[Cannibalize]} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)})
				{
					Toon:CastSpell["Cannibalize"]
					This:Output["Cannibalize"]
					This.restWaitTimer:Set[${This.InSeconds[7]}]
					return
				}
			}
			
			/* eat */
			if ${Consumable.HasFood} && ${Me.PctHPs} < ${Config.GetSlider[sldRestHP]} && !${Me.Buff[Food](exists)}
			{
				Consumable:useFood
				return
			}

			/* stupid rez sickness */
			if ${Me.Buff[Resurrection Sickness](exists)}
			{
				Toon:Sitdown
				if ${This.shouldStealth}
				{
					Toon:CastSpell["Stealth"]
				}
				return
			}
			
			/* stand up when we are done eating */
			if ${Me.PctHPs} >=  ${Config.GetSlider[sldStandHP]} && ${Toon.Sitting}
			{
				Toon:Standup
				return
			}
			
			/* stealth food. mmm */
			if (${Me.Buff[Food](exists)}||(!${Consumable.HasFood}&&${Toon.Sitting}))&&${This.shouldStealth}
			{
				Toon:CastSpell["Stealth"]
				This:Output["Stealth Food.  Mmmm."]
				return
			}			
					
			if !${Consumable.HasFood} && ${Me.PctHPs} < ${Config.GetSlider[sldStandHP]}
			{
				Toon:Sitdown
				return				
			}

			/* shadowmeld and make bandages if out */
			/* written by Jeebiss */
                        if ${Config.GetCheckbox[chkMakeBand]} && ${Item[-inventory,"Bandage"].Count} <= 5 && !${Me.Casting} 
                        {
				This:Output["Standing..."]
				if ${Me.Sitting}
                                {
                                        Toon:Standup
                                }
				This:Output["Shadowmelding..."]
				if ${Spell[Shadowmeld](exists)} && !${Me.Casting}
				{
					Toon:CastSpell["Shadowmeld"]
				}
				This:Output["Making da bandages..."]	
				Tradeskills:MakeBandage[${Config.GetCombo[cmbBandType]}, 5]
				This:Output["Making 5 ${Config.GetCombo[cmbBandType]} bandages..."]
				This:Output["Dooone..."]
                        }


			if ${Config.GetCheckBox[chkPatrolInStealth]}&&${This.shouldStealth}&&${Me.PctHPs}>${Config.GetSlider[sldRestHP]}&&!${Toon.Sitting}
			{		
				if ${POI.Type.Equal[HOTSPOT]} && !${Mount.NeedMount} && !${Mount.IsMounted} 
				{
					Toon:CastSpell["Stealth"]
					This:Output["Patrol in Stealth..."]
					return
				}
			}
		}
	}
	
	
	;------------------
	;--- Buff SetUp ---
	;------------------
	
	member NeedBuff()
	{
		variable string PoisonType = ${This.chooseBestPoison[${Config.GetCombo[cmbMainHandPoison]}]}
		
		if (!${POI.Type.Equal[HOTSPOT]} && !${This.IsAssistMode})  || ${Mount.NeedMount} || ${Mount.IsMounted}
		{
			return FALSE
		}
		
		/* skip buff to loot */
		if ${This.SkipToLoot}
		{
			return FALSE
		}
		
		if ${Config.GetCheckBox[chkPatrolInStealth]} && ${This.shouldStealth}
		{
			if ${POI.Type.Equal[HOTSPOT]} && !${Mount.NeedMount} && !${Mount.IsMounted} 
			{
				return TRUE
			}
		}
		
		if ${This.Lockpick.needPick}
		{
			return TRUE
		}
		
		if  !${Me.InCombat}&&${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${PoisonType}](exists)} && ${Item[${PoisonType}](exists)}
		{
			return TRUE
		}		
		
		PoisonType:Set[${This.chooseBestPoison[${Config.GetCombo[cmbOffHandPoison]}]}]
		if  !${Me.InCombat}&&${Me.Equip[offhand](exists)} && !${Me.Equip[offhand].Enchantment[${PoisonType}](exists)} && ${Item[${PoisonType}](exists)}
		{
			return TRUE
		}
		
		if ${Toon.canUseScroll}
		{
			return TRUE
		}	
		return FALSE
	}
	
	method BuffPulse()
	{
		variable string PoisonType = ${This.chooseBestPoison[${Config.GetCombo[cmbMainHandPoison]}]}

		if ${Movement.Speed}
		{
			Toon:Stop
			return
		}
		
		if ${Me.Casting}&&!${WoWScript[SpellIsTargeting()]}
		{
			This.buffWaitTimer:Set[${This.InMilliseconds[100]}]
		}
		
		if (${This.buffWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})
		{
			This:ClearWaitTimers
			This.pullTimeOut:Set[0]
			
			/* lets pause for 1 second before buffing - basically a lag wait so that we dont stealth prematurely*/
			if !${This.buffPause}&&!${WoWScript[SpellIsTargeting()]}
			{
				This.buffWaitTimer:Set[${This.InMilliseconds[100]}]
				This.buffPause:Set[TRUE]
				return
			}

			/* ok- we buffed. lets clear the pause check */ 
			This.buffPause:Set[FALSE]
			Toon:Standup
			
			if ${Toon.canUseScroll}
			{
				Toon:UseScroll
				return
			}
			
			if ${Config.GetCheckBox[chkPatrolInStealth]} && ${This.shouldStealth}
			{
				if ${POI.Type.Equal[HOTSPOT]} && !${Mount.NeedMount} && !${Mount.IsMounted} 
				{
					Toon:CastSpell["Stealth"]
					This:Output["Casting Stealth for Patrol"]
					return
				}
			}

			if ${This.Lockpick.needPick}
			{
				This.Lockpick:Pulse
				return
			}
			
			if  !${Me.InCombat}&&${Me.Equip[mainhand](exists)} && !${Me.Equip[mainhand].Enchantment[${PoisonType}](exists)} && ${Item[${PoisonType}](exists)}
			{			
				if ${WoWScript[SpellIsTargeting()]}
				{
					Me.Equip[mainhand]:PickUp
					This:Output["Mainhand Hand Poison: ${PoisonType}"]
					Bot.RandomPause:Set[24]
					This.buffWaitTimer:Set[${This.InMilliseconds[400]}]
					return
				}
				Item[${PoisonType}]:Use
				This.buffWaitTimer:Set[${This.InMilliseconds[25]}]
				return
			}		
			
			PoisonType:Set[${This.chooseBestPoison[${Config.GetCombo[cmbOffHandPoison]}]}]
			if  !${Me.InCombat}&&${Me.Equip[offhand](exists)} && !${Me.Equip[offhand].Enchantment[${PoisonType}](exists)} && ${Item[${PoisonType}](exists)}
			{
				if ${WoWScript[SpellIsTargeting()]}
				{
					Me.Equip[offhand]:PickUp
					This:Output["Off Hand Poison: ${PoisonType}"]
					Bot.RandomPause:Set[24]					
					This.buffWaitTimer:Set[${This.InMilliseconds[400]}]
					return
				}
				Item[${PoisonType}]:Use
				This.buffWaitTimer:Set[${This.InMilliseconds[25]}]
				return
			}
		}
	}
	
	member shouldStealth()
	{
		if !${Me.Buff[Stealth](exists)}&&${Spell[Stealth](exists)}
		{
			if !${Spell[Stealth].Cooldown} && !${Toon.IsDotted}
			{
			return TRUE
			}
		}
		return FALSE
	}

	
	;------------------
	;--- Pull Buff SetUp ---
	;------------------
	
	member NeedPullBuff()
	{
		return FALSE
	}

	method PullBuffPulse()
	{
		if (${This.pullbuffWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})
		{
			This:ClearWaitTimers
			This:BuffPulse
		}
	}
	

	;------------------------
	;--- CombatBuff SetUp	---
	;------------------------
	
	member NeedCombatBuff()
	{
		return FALSE
	}

	method CombatBuffPulse()
	{
		if (${This.combatbuffWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})
		{
			This:ClearWaitTimers
		}
	}
	
	
	;------------------
	;--- Pull SetUp ---
	;------------------
	
	method PullPulse()
	{	
		/* lets make sure we are standing */
		Toon:Standup
		
		if !${Toon.ValidTarget[${Target.GUID}]} && ${This.IsPartyLeader}
		{
			Toon:Stop
			This:Output["I need a target"]
			Toon:NeedTarget[1]			
			This.pullTimeOut:Set[0]			
			return
		}	
		if !${Toon.TargetIsBestTarget} && !${This.IsAssistMode} && ${This.IsPartyLeader}
		{
			Toon:Stop
			Toon:BestTarget
			This.pullTimeOut:Set[0]
			return
		}		

		/* target is elite, fuck that */
		if ${Target.Classification.Equal[Elite]} && !${This.IsAssistMode} && !${Party.IsPartyMode}
		{ 
			Toon:Stop
			This:Output["Target is elite. Blacklisting."]
			GlobalBlacklist:Insert[${Target.GUID},3600000]
			WoWScript ClearTarget()
			This.pullTimeOut:Set[0]
			return 
		} 
		
		/* stop moving if no reason to move */
		if ${Movement.Speed} && (${Target.Distance}<${Toon.MaxMelee} && ${Target.Distance}>${Toon.MinMelee})
		{
			Toon:Stop
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		}
					
		if (${This.pullWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})&&!${Me.InCombat}
		{
			This:ClearWaitTimers
			
			/* set the pull timeout - pull should not take more than 8 seconds*/
			if ${This.pullTimeOut}==0
			{
				This.pullTimeOut:Set[${This.InMilliseconds[${Config.GetSlider[sldPullBailOutTimer]}]}]
				return
			}
			
			if ${This.MeleePull}
			{
				/* stealth open */
				/* make sure we are in stealth */
				if ${This.shouldStealth}
				{
						Toon:Stop
						Toon:CastSpell["Stealth"]
						This:Output["Casting Stealth for Pull"]
						return
				}
				
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]

				/* switch to dagger if we are ambusing */
				if ${Spell[Ambush](exists)}&&${Config.GetCheckBox[chkUseAmbush]}
				{
					/* lets check if we should be switching */
					if !${Me.Equip[16].SubType.Equal["Dagger"]} && ${This.canWeaponSwap["Dagger"]}
					{
						/* and... make sure we can get behind the target */
						if (${Spell[Shadowstep](exists)} && !${Spell[Shadowstep].Cooldown})||(${Toon.isFacingAway[80]} && ${Target.Distance} < 10)
						{
							/* ok. switch and brief pause while our dagger is put in our mainhand */
							This:SwitchWeapon["Dagger"]
							return
						}
					}
				}

				/* switch to dagger if we are backstabbing */
				if !${Spell[Ambush](exists)}&&!${Spell[Cheap Shot](exists)}&&${Spell["Backstab"](exists)}
				{
					/* lets check if we should be switching */
					if !${Me.Equip[16].SubType.Equal["Dagger"]} && ${This.canWeaponSwap["Dagger"]}
					{
						/* and... make sure we can get behind the target */
						if ${Toon.isFacingAway[80]}
						{
							/* ok. switch and brief pause while our dagger is put in our mainhand */
							This:SwitchWeapon["Dagger"]
							return
						}
					}
				}	
				
				/* move into melee range */
				if !${Toon.withinMelee[TRUE]}
				{
					/* distract when in range */
					if ${Config.GetCheckBox[chkUseDistract]}&&${This.checkDistract}&&${Toon.canCast[Distract]}&&${Math.Distance[${Me.X},${Me.Y},${Target.X},${Target.Y}]}<25
					{
						Toon:CastSpell[Distract]
						ISXWoW:ClickTerrain[${Math.Calc[1*${Math.Cos[${Me.Heading.DegreesCCW}].Milli}+${Target.X}]}, ${Math.Calc[2*${Math.Sin[${Me.Heading.DegreesCCW}].Milli}+${Target.Y}]}, ${Target.Z}]
						checkDistract:Set[FALSE]
						return
					}
					/* shadowstep if I like to ambush */
					if ${Toon.canCast[Shadowstep]} && ${Me.Buff[Stealth](exists)}
					{
						if ${Config.GetCheckBox[chkUseAmbush]} && ${Target.Distance} < 20 && ${Me.Equip[16].SubType.Equal["Dagger"]}
						{
							Toon:CastSpell["Shadowstep"]
							return
						}
					}
					Toon:ToMelee
					return					
				}
				
				
				/* we are in range, use stealth open if not detected*/
				if ${Me.Buff[Stealth](exists)} && ${Toon.withinMelee}
				{
					/* shadowstep if I like Ambush and cant */
					if ${Toon.canCast[Shadowstep]}
					{
						if ${Config.GetCheckBox[chkUseAmbush]} &&${Toon.canCast[Ambush]}&&${Me.Equip[16].SubType.Equal["Dagger"]}
						{
							Toon:CastSpell["Shadowstep"]
							WoWScript SpellStopCasting()
						}
					}
					/* lets use premed first or pickpocket if type*/
					if ${Toon.canCast[Premeditation]}
					{
						Toon:CastSpell["Premeditation"]
						WoWScript SpellStopCasting()
					}
					if (${Target.CreatureType.Equal["Humanoid"]}||${Target.CreatureType.Equal["Demon"]}||${Target.CreatureType.Equal["Undead"]})&&${Toon.canCast["Pick Pocket"]}&&${Config.GetCheckBox[chkUsePickPocket]}&&${This.checkPockets}
					{
						Toon:CastSpell["Pick Pocket"]
						This.checkPockets:Set[FALSE]
						WoWScript SpellStopCasting()
					}
					/* garrote humanoid casters if toggle enabled */
					if ${Config.GetCheckBox[chkUseGarrote]}&&(${Target.CreatureType.Equal["Humanoid"]}||${Target.CreatureType.Equal["Demon"]})&&${Target.MaxMana}>0&&${Toon.canCast[Garrote]}
					{
						This.pullWaitTimer:Set[${This.InSeconds[10]}]	
						This:Output["Stealth Open: Garrote"]
						Toon:CastSpell["Garrote"]
						return
					}
					/* ambush target if dagger is equiped */
					if ${Toon.isFacingAway[80]}&&${Me.Equip[16].SubType.Equal["Dagger"]}&&${Toon.canCast[Ambush]}&&${Config.GetCheckBox[chkUseAmbush]}
					{
						This.pullWaitTimer:Set[${This.InSeconds[10]}]	
						This:Output["Stealth Open: Ambush"]
						Toon:CastSpell["Ambush"]
						return
					}			
					/* otherwise open with a cheap shot */
					if ${Toon.canCast[Cheap Shot]}
					{
						This.pullWaitTimer:Set[${This.InSeconds[10]}]	
						This:Output["Stealth Open: Cheapshot"]
						Toon:CastSpell["Cheap Shot"]
						return
					}
					/* hmm. we didnt use an opener. lets just try to backstab if target is facing away */
					if ${Toon.isFacingAway[80]}&&${Me.Equip[16].SubType.Equal["Dagger"]}&&${Spell["Backstab"](exists)}&&${Me.Action["Backstab"].Usable}
					{
						This.pullWaitTimer:Set[${This.InSeconds[10]}]	
						This:Output["Stealth Open: Backstab"]
						Toon:CastSpell["Backstab"]
						return		
					}						
				}
				/* or if none of those worked, just start hacking away */		
				if ${Toon.withinMelee}
				{
					if !${Me.Attacking}
					{
						This.pullWaitTimer:Set[${This.InSeconds[10]}]	
						This:Output["Melee Open: Sinister Strike"]
						Toon:CastSpell["Sinister Strike"]
						WoWScript AttackTarget()
						return
					}				
				}
				return
			}

			/* check pull timeout for range*/
			if (${Math.Calc[${This.pullTimeOut}+50000]} < ${LavishScript.RunningTime}&&(${Target.MaxMana}<=0||!${Target.MaxMana(exists)}))||((${This.pullTimeOut} < ${LavishScript.RunningTime})&&(${This.detectMobAdd}||${Config.GetCheckBox[chkShootToPull]}))
			{
				This:Output["Pull Timer Exceeded."]
				This.pullTimeOut:Set[0]
				GlobalBlacklist:Insert[${Target.GUID},3600000]
				WoWScript ClearTarget()
				Toon:Stop
				return
			}

			if !${Toon.haveAmmo}
			{
				This:Output["ERROR: Range Pull Failed"]
				return
			}					
			
			if !${Toon.withinRanged[TRUE]}
			{
				Toon:ToRanged
			}
			else
			{
				/* pull with ranged attack open */	
				if ${Toon.canShoot}
				{
					Toon:Shoot
					/* wait for target to come to us */
					This.crazyWaitTimer:Set[${This.InMilliseconds[${Math.Calc[(${Me.Equip[18].Delay}*100)+(10*${Target.Distance})]}]}]
					return
				}
				else
				{
					/* our range check failed and exceeded timer*/
					if ${This.pullTimeOut} < ${LavishScript.RunningTime}
					{
						This:Output["Pull Timer Exceeded. Range pull attempt failed."]
						This.pullTimeOut:Set[0]
						GlobalBlacklist:Insert[${Target.GUID},3600000]
						WoWScript ClearTarget()
						Toon:Stop
						return
					}
				}
			}
		}
	}
	
	member MeleePull()
	{
		if ${This.pullTimeOut} < ${LavishScript.RunningTime}
		{
			return FALSE
		}
		if (${Target.CreatureType.Equal["Humanoid"]} || ${Target.CreatureType.Equal["Demon"]}) && ${Target.MaxMana} > 0
		{
			return TRUE
		}
		if !${Toon.haveAmmo}
		{
			return TRUE
		}
		if ${Group.Members} > 0
		{
			return TRUE		
		}
		if ${This.detectMobAdd} || ${Config.GetCheckBox[chkShootToPull]}
		{
			return FALSE
		}
		if (${Target.Distance} < ${Toon.PullRange} || ${Target.Distance} < 40) && !${Me.IsPathObstructed[${Target.X},${Target.Y},${Target.Z}]}
		{
			return TRUE
		}
		if ${Navigator.AvailablePath[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]}
		{
			return TRUE
		}
		return FALSE
	}

	;--------------------
	;--- Combat SetUp ---
	;--------------------
	
	method AttackPulse()
	{
		variable string MyRogueAttack
		variable guidlist NextClosestAggro
		variable string PotionName
				
		/* lets make sure we are standing */
		Toon:Standup

		/* i must have vanished, lets get to a safe spot */
		if ${Me.Buff[Vanish](exists)}
		{
			return
		}
		
		if !${Toon.ValidTarget[${Target.GUID}]}
		{
			Toon:Stop
			This:Output["I need a target"]
			Toon:NeedTarget[1]			
			return
		}	
		
		/* move behind a target when appropriate*/
		if ${This.moveBehind}&&(${Target.Buff[Kidney Shot](exists)}||${Target.Buff[Gouge](exists)})
		{
			if ${Target.GUID.Equal[${This.lastAttackTarget}]}
			{
				/* we need a Dagger in our mainhand */
				if !${Me.Equip[16].SubType.Equal["Dagger"]} && ${This.canWeaponSwap["Dagger"]}
				{
					This:SwitchWeapon["Dagger"]
				}
				/* start moving behind */
				if ${This.startMoveBehind}
				{
					This:Output["Moving Behind: On the move."]
					Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
					move forward 1500
					This.startMoveBehind:Set[FALSE]
					This.backattackWaitTimer:Set[${This.InMilliseconds[75]}]
					This.attackWaitTimer:Set[${This.InMilliseconds[75]}]
					return
				}	
				/* if we have had enough time to move to the other side of the mob, do next */
				if ${This.backattackWaitTimer} < ${LavishScript.RunningTime}
				{

					Toon:Stop
					Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
					
					/* create a brief pause for lag and have value for isFacing */
					if ${This.backattackPause}
					{
						This.attackWaitTimer:Set[${This.InMilliseconds[50]}]
						This.backattackPause:Set[FALSE]
					}

					/* wait until we have 60 energy and can back attack */
					if ${Me.CurrentEnergy}<60
					{
						This:Output["Moving Behind: Waiting for 60 Energy."]
						return
					}
				}
			}
		}
		
		/* lets make sure we recognize target is gouged or kidney shotted */
		if ${This.moveBehind} && ${This.attackWaitTimer} > ${LavishScript.RunningTime}
		{
			This:Output["Moving Behind: Pausing for Lag."]
			return
		}
		
		/* stop moving if no reason to move */
		if ${Movement.Speed} && ${Target.Distance} < ${Toon.MaxMelee} && ${Target.Distance} > ${Toon.MinMelee}
		{
			Toon:Stop
			Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
		}
			
		/* make sure we are facing target */
		Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]		
		
		/* make sure my auto-attacks are on */
		if !${Me.Attacking} && !${Target.Buff[Gouge](exists)}
		{
			WoWScript AttackTarget()
		}
		
		if (${This.attackWaitTimer} < ${LavishScript.RunningTime})&&(${This.crazyWaitTimer} < ${LavishScript.RunningTime})
		{
			/* pre-attack stuff */
			This:ClearWaitTimers
			This.pullTimeOut:Set[0]
			This.backattackPause:Set[FALSE]
			This.moveBehind:Set[FALSE]
			This.startMoveBehind:Set[FALSE]
			
			if !${Toon.TargetIsBestTarget} && ${Object[${Toon.BestTarget}](exists)} && ${Toon.BestTarget.NotEqual[NULL]} && !${Party.IsPartyMode}
			{
				if ( ${Object[${Toon.BestTarget}].Distance} < ${Toon.MinRanged} || ${Object[${Toon.BestTarget}].PctHPs} > 20 ) && ${Math.Calc[${LavishScript.RunningTime}-${This.PersistentTarget}]} > 5000
				{
					Toon:BestTarget
					return
				}
			}	
			elseif ${This.IsPartyLeader} && ${Group.Members} > 0
			{
				Party:Tank
			}
			
			/* reset stuff if I have attacked a new target */
			if !${Target.GUID.Equal[${This.lastAttackTarget}]}
			{
				This.PersistentTarget:Set[${LavishScript.RunningTime}]				
				This.kiteCheck:Set[FALSE]
				This.kiteWaitTimer:Set[0]
				This.checkPockets:Set[TRUE]
				This.checkDistract:Set[TRUE]
				This.lastAttackTarget:Set[${Target.GUID}]
			}		
			
			/* make sure we are in melee range */
			if ${Target.Distance} > ${Toon.MaxMelee}
			{
				/* check to see if I am being kited by another player - pauses 5 seconds before moving after the target*/
				if (${Target.TappedByMe} && !${Target.Target.GUID.Equal[${Me.GUID}]} && ${Target.Target.GUID(exists)}) &&!${Target.Buff[Cheap Shot](exists)} && ${Group.Members} == 0
				{
					if ${This.kiteCheck}
					{
						/* blacklist mob - they can kill it*/
						This:Output["We are getting kited. Blacklisting ${Target.Name}"]
						GlobalBlacklist:Insert[${Target.GUID},3600000]
						return
					}
					if !${This.kiteCheck}
					{
						This:Output["Getting Kited?"]
						This.attackWaitTimer:Set[${This.InMilliseconds[500]}]
						This.kiteCheck:Set[TRUE]
						return
					}
				}
							
				/* if my target is another player, lets make sure we dont get kited */
				if ${Target.FactionGroup.Equal[${This.OppositeFaction}]} && ${Target.Type.Equal[Player]}
				{
					if ${This.kiteCheck}&&(${This.kiteWaitTimer} < ${LavishScript.RunningTime})
					{
						if ${Toon.canShoot}
						{
							Toon:Shoot
							This.crazyWaitTimer:Set[${This.InMilliseconds[${Math.Calc[(${Me.Equip[18].Delay}*100)+100]}]}]	
							return
						}
					}
					if !${This.kiteCheck}
					{
						This.kiteWaitTimer:Set[${This.InMilliseconds[2000]}]
						This.attackWaitTimer:Set[${This.InMilliseconds[200]}]
						This.kiteCheck:Set[TRUE]
					}
				}
							
				/* is he fleeing? */
				if ${Target.PctHPs} < 20
				{ 
					if ${Object[${Toon.NextBestTarget}](exists)} && ${Toon.NextBestTarget.NotEqual[NULL]}
					{
						if !${IF[${Spell[Deadly Throw](exists)} && ${Me.ComboPoints}>=1&&${Me.Equip[18].SubType.Equal["Thrown"]},TRUE,FALSE]}
						{
						This:Output["Current target is fleeing. Choosing a closer target."]
						Target ${Toon.NextBestTarget}
						This.attackWaitTimer:Set[${This.InMilliseconds[50]}]
						return
						}
					}
					
					/* if we dont chase runners or deadly throw exists and we have combo pts */
					if !${Config.GetCheckBox[chkChaseRunners]} || (${Me.ComboPoints}>=1 && ${Me.Equip[18].SubType.Equal["Thrown"]} && ${Spell[Deadly Throw](exists)})
					{
						/* target cannot be range attacked, lets wait for them to flee */
						if ${Target.Distance} < ${Toon.MinRanged} && ${Target.Distance} < ${Toon.MaxRanged}
						{
							This.attackWaitTimer:Set[${This.InMilliseconds[100]}]
							return
						}
						if ${Toon.canShoot}
						{
							Toon:Shoot
							This.crazyWaitTimer:Set[${This.InMilliseconds[${Math.Calc[(${Me.Equip[18].Delay}*100)+100]}]}]							
							return
						}
						This:Output["Ranged: Failed - Moving to Target"]
						Navigator:MoveToMob[${Target.GUID}]
						return
					}
				}
				
				/* ok. nothing special happening. lets move into range */
				Navigator:MoveToMob[${Target.GUID}]
				return
			}
			This.kiteCheck:Set[FALSE]
			
			/* backup into range */
			if ${Target.Distance} < ${Toon.MinMelee}
			{
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				Navigator:MoveBackward[500]
			}
			
			/* our target is fleeing - stun him*/
			if ${Target.PctHPs}<20 && ${Toon.isFacingAway[90]} && (!${Target.Buff[Crippling Poison](exists)} && !${Config.GetCheckBox[chkChaseRunners]})
			{
				/* we got combo pts, lets kidney shot */
				if ${Me.ComboPoints}>=1 && ${Toon.canCast["Kidney Shot"]}
				{	
					Toon:CastSpell["Kidney Shot"]
					This:Output["Casting Kidney Shot to stun Fleeing mob"]
					return
				}
			}
			
			/* pop an emergency potion if about fucked */
			if ${Item[-inventory,"Healing Potion"](exists)}&&${Me.PctHPs}<${Config.GetSlider[sldHealthForPotion]}
			{
				PotionName:Set[${Item[-inventory,"Healing Potion"].Name}]	
				if ${Item[${PotionName}].Usable}&&!${WoWScript["GetContainerItemCooldown(${Item[${PotionName}].Bag.Number}, ${Item[${PotionName}].Slot})", 2]}
				{
					Item[${PotionName}]:Use
					Bot.RandomPause:Set[24]
					return
				}
			}
							
			/* determine which attack will be used */	
			MyRogueAttack:Set[${This.chooseRogueAttack}]
			
			switch ${MyRogueAttack}
			{
				case trinketone
				{
					This:Output["In Melee: Using ${Me.Equip[13].Name}"]
					Me.Equip[13]:Use
					Bot.RandomPause:Set[24]
					return
				}
				case trinkettwo
				{
					This:Output["In Melee: Using ${Me.Equip[14].Name}"]
					Me.Equip[14]:Use
					Bot.RandomPause:Set[24]
					return
				}
				case gougetostab
				{
					Toon:CastSpell["Gouge"]
					This:Output["Casting Gouge to move behind target"]		
					This:setStabLoc
					This.moveBehind:Set[TRUE]
					This.backattackPause:Set[TRUE]
					This.startMoveBehind:Set[TRUE]
					This.attackWaitTimer:Set[${This.InMilliseconds[100]}]
					return
				}
				case kidneytostab
				{
					Toon:CastSpell["Kidney Shot"]
					This:Output["Casting Kidney Shot to move behind target"]
					This:setStabLoc
					This.moveBehind:Set[TRUE]
					This.backattackPause:Set[TRUE]
					This.startMoveBehind:Set[TRUE]
					This.attackWaitTimer:Set[${This.InMilliseconds[100]}]
					return				
				}
				case Vanish
				{
					Bot.RandomPause:Set[9]
					GlobalBlacklist:Insert[${Target.GUID},30000]					
					Toon:CastSpell[${MyRogueAttack}]
					WoWScript ClearTarget()
					return
				}
				case Gouge
				{	
					Target ${Toon.NextBestTarget}			
					Toon:CastSpell["Gouge"]
					This:Output["In Melee: Gouging ${Object[${Toon.NextBestTarget}].Name}"]
					Target ${This.lastAttackTarget}	
					Bot.RandomPause:Set[14]					
					return
				}
				case Blind
				{
					Target ${Toon.NextBestTarget}			
					Toon:CastSpell["Blind"]
					This:Output["In Melee: Blinding ${Object[${Toon.NextBestTarget}].Name}"]
					Target ${This.lastAttackTarget}		
					Bot.RandomPause:Set[14]					
					return					
				}
				default
				{
					/* output spam prevention */
					if ${Me.Action[${MyRogueAttack}].Usable}
					{
						This:Output["In Melee: Casting ${MyRogueAttack}"]
					}
					Toon:CastSpell[${MyRogueAttack}]
					Bot.RandomPause:Set[14]					
					return
				}
			}
		}
	}
	
	member chooseRogueAttack()
	{		
		variable string MyRogueAttack
		variable guidlist Aggros
		variable int MobAdds
		
		/* determine number of adds */
		Aggros:Search[-units, -nearest, -targetingme, -alive, -range 0-30]
		MobAdds:Set[(${Aggros.Count} - 1)]		
		Aggros:Clear
		
		/* set the default attack */
		MyRogueAttack:Set[${Config.GetCombo[cmbPrimaryAttack]}]
		
		/* vanish or flee */
		if (${Me.PctHPs}<=${Config.GetSlider[sldHealthForVanish]}||${MobAdds}>=${Config.GetSlider[sldAddsForVanish]})
		{
			
			if !${Spell[Vanish].Cooldown} && ${Spell[Vanish](exists)}
			{
				Toon:Flee
				MyRogueAttack:Set["Vanish"]
				return ${MyRogueAttack}
			}
			/* vanish is on cooldown, can i cast preparation? */
			if ${Spell[Preparation](exists)}&&!${Spell[Preparation].Cooldown}&&${Me.PctHPs}<=${Config.GetSlider[sldHealthForVanish]}
			{
				MyRogueAttack:Set["Preparation"]
				return ${MyRogueAttack}		
			}
			else
			{
				Toon:Flee
				return ${MyRogueAttack}					
			}
		}
				
		/* evasion */
		if (${Me.PctHPs}<=${Config.GetSlider[sldHealthForEvasion]}||${MobAdds}>=${Config.GetSlider[sldAddsForEvasion]})&&${Spell[Evasion](exists)}&&!${Me.Buff[Evasion](exists)}
		{
			if !${Spell[Evasion].Cooldown}
			{
					MyRogueAttack:Set["Evasion"]
					return ${MyRogueAttack}
			}
			/* evasion is on cooldown, can i cast preparation? */
			elseif ${Spell[Preparation](exists)}&&!${Spell[Preparation].Cooldown}&&${Me.PctHPs}<=${Math.Calc[${Config.GetSlider[sldHealthForEvasion]}/2]}
			{
				MyRogueAttack:Set["Preparation"]
				return ${MyRogueAttack}		
			}
		}
		
		/* blade flurry */
		if ((${Target.PctHPs}>50&&${MobAdds}>=${Config.GetSlider[sldAddsForBladeFlurry]})||(${MobAdds}>=(${Config.GetSlider[sldAddsForAdrenalineRush]} + 1)))&&!${Me.Buff[Blade Flurry](exists)}&&${Toon.canCast["Blade Flurry"]}
		{
				MyRogueAttack:Set["Blade Flurry"]
				return ${MyRogueAttack}
		}
		
		/* adrenaline rush */
		if ((${Target.PctHPs}>50&&${MobAdds}>=${Config.GetSlider[sldAddsForAdrenalineRush]})||(${MobAdds}>=(${Config.GetSlider[sldAddsForAdrenalineRush]} + 1)))&&${Spell[Adrenaline Rush](exists)}&&!${Me.Buff[Adrenaline Rush](exists)}
		{
			if !${Spell[Adrenaline Rush].Cooldown}
			{
					MyRogueAttack:Set["Adrenaline Rush"]
					return ${MyRogueAttack}
			}
			/* adrenaline rush is on cooldown, can i cast preparation? */
			elseif ${Spell[Preparation](exists)}&&!${Spell[Preparation].Cooldown}&&${Me.PctHPs}<=${Config.GetSlider[sldHealthForEvasion]}
			{
				MyRogueAttack:Set["Preparation"]
				return ${MyRogueAttack}		
			}			
		}

		/* dont you try to cast on me, motherfucker */
		if ${Config.GetCheckBox[chkRacial]}&&${Me.Race.Equal[Blood Elf]}
		{
			if ${Target.Casting(exists)}&&${Target.MaxMana}>0&&${Spell[Arcane Torrent](exists)}&&${Me.Buff[Mana Tap](exists)}&&!${Spell[Arcane Torrent].Cooldown}
			{
				MyRogueAttack:Set["Arcane Torrent"]
				return ${MyRogueAttack}		
			}
		}
		
		if ${Target.Casting(exists)}&&${Target.MaxMana}>0&&${Config.GetCheckBox[chkUseKick]}&&${Toon.canCast[Kick]}
		{
			MyRogueAttack:Set["Kick"]
			return ${MyRogueAttack}		
		}

		if ${Target.PctHPs}>25&&${MobAdds}>=1
		{
			if ${Object[${Toon.NextBestTarget}](exists)}&& ${Toon.NextBestTarget.NotEqual[NULL]}
			{
				/* if facing away returns true, the target is likely behind me */
				if !${Toon.isFacingAway[100,${Toon.NextBestTarget}]}
				{
					if !${Object[${Toon.NextBestTarget}].Buff["Blind"](exists)}&&!${Object[${Toon.NextBestTarget}].Buff["Gouge"](exists)}&&!${Me.Buff[Blade Flurry](exists)}
					{
						if ${Object[${Toon.NextBestTarget}].Distance}<=${Toon.MaxMelee}&&${Me.Action[Gouge].Usable}&&${Toon.canCast[Gouge]}&&${Config.GetCheckBox[chkUseGougeOnAdds]}
						{
							return "Gouge"
						}
						if ${Object[${Toon.NextBestTarget}].Distance}<=10&&${Me.Action[Blind].Usable}&&${Toon.canCast[Blind]}&&${Config.GetCheckBox[chkUseBlindOnAdds]}
						{
							return "Blind"
						}
					}
				}
			}
		}
		
		/* is our back attack usable, do it now */
		if ${Config.GetCheckBox[chkUseBackAttack]}&&${Toon.isFacingAway[80]}&&${Me.Equip[16].SubType.Equal["Dagger"]}&&${Spell[${Config.GetCombo[cmbPrimaryBackAttack]}](exists)}&&${Me.Action[${Config.GetCombo[cmbPrimaryBackAttack]}].Usable}
		{
			MyRogueAttack:Set[${Config.GetCombo[cmbPrimaryBackAttack]}]
			return ${MyRogueAttack}				
		}
		
		/* we got combo pts, time for a finisher? */
		if ${Me.ComboPoints}>=1&&${Target.PctHPs}>0
		{
			if ${Config.GetCheckBox[chkUseBackAttack]}&&(${Me.Equip[16].SubType.Equal["Dagger"]} || ${This.canWeaponSwap["Dagger"]})&&${Me.ComboPoints}==5&&${Toon.canCast["Kidney Shot"]}&&(${Target.PctHPs}>35&&${MobAdds}<1)
			{
				if !${Target.Buff[Gouge](exists)}&&!${Target.Buff[Cheap Shot](exists)}
				{
					MyRogueAttack:Set["kidneytostab"]
					return ${MyRogueAttack}
				}
			}
			if ${Target.PctHPs}>=${Config.GetSlider[sldHealthForRupture]}&&${Config.GetCheckBox[chkUseRupture]}&&${Me.ComboPoints}==5&&${Spell[Rupture](exists)}&&!${Target.Buff[Rupture](exists)}&&!${Me.Buff[Blade Flurry](exists)}&&!${Target.CreatureType.Equal["Elemental"]}&&!${Target.CreatureType.Equal["Mechanical"]}
			{
				MyRogueAttack:Set["Rupture"]
				return ${MyRogueAttack}	
			}
			if ((${Target.Casting(exists)}&&${Me.ComboPoints}>3)||(${Target.PctHPs}>=${Config.GetSlider[sldHealthForKidneyShot]}&&${Target.PctHPs}<${Config.GetSlider[sldHealthForRupture]}&&${Me.ComboPoints}==4)||(${Target.PctHPs}>=${Config.GetSlider[sldHealthForKidneyShot]}&&${Me.ComboPoints}==5))&&${Config.GetCheckBox[chkUseKidneyShot]}&&${Toon.canCast["Kidney Shot"]}&&!${Target.Buff[Cheap Shot](exists)}&&!${Me.Buff[Blade Flurry](exists)}
			{
				MyRogueAttack:Set["Kidney Shot"]
				return ${MyRogueAttack}	
			}
			if (${Target.PctHPs}>50||${MobAdds}>0)&&${Spell[Slice and Dice](exists)}&&${Me.ComboPoints}==1&&!${Me.Buff[Slice and Dice](exists)}&&${Config.GetCheckBox[chkUseSliceAndDice]}
			{
				MyRogueAttack:Set["Slice and Dice"]
				return ${MyRogueAttack}				
			}
			if (${Me.ComboPoints}==5||${Me.ComboPoints}*${Config.GetSlider[sldEviscerateMultiplier]}>=${Target.PctHPs})&&${Spell[Eviscerate](exists)}&&${Me.CurrentEnergy}>35
			{
				/* cast cold blood if available and target is more than 50 pct life */
				if ${Toon.canCast["Cold Blood"]}&&${Target.PctHPs}>50
				{
					MyRogueAttack:Set["Cold Blood"]
					return ${MyRogueAttack}	
				}
				MyRogueAttack:Set["Eviscerate"]
				return ${MyRogueAttack}			
			}
		}

		/* gouge target to backstab*/
		if ${Config.GetCheckBox[chkUseBackAttack]}&&(${Me.Equip[16].SubType.Equal["Dagger"]} || ${This.canWeaponSwap["Dagger"]})&&${Me.Action[Gouge].Usable}&&${Toon.canCast[Gouge]}&&${Target.PctHPs}>30&&${MobAdds}<1
		{		
			if !${Target.Buff[Cheap Shot](exists)}&&!${Target.Buff[Kidney Shot](exists)}&&!${Me.Buff[Blade Flurry](exists)}&&!${Me.Buff[Slice and Dice](exists)}
			{
				MyRogueAttack:Set["gougetostab"]
				return ${MyRogueAttack}	
			}
		}
		
		/* can we riposte? */
		if ${Toon.canCast[Riposte]}&&${Me.Action[Riposte].Usable}&&${Config.GetCheckBox[chkUseRiposte]} 
		{
			MyRogueAttack:Set["Riposte"]
			return ${MyRogueAttack}	
		}
		
		/* can we ghostly strike */
		if ${Toon.canCast["Ghostly Strike"]}&&${Config.GetCheckBox[chkUseGhostlyStrike]}&&!${Target.Buff[Cheap Shot](exists)}&&!${Target.Buff[Kidney Shot](exists)}
		{
			MyRogueAttack:Set["Ghostly Strike"]
			return ${MyRogueAttack}	
		}

		/* should we use a trinket? */
		if ${This.UseTrinket[13,${MobAdds}]}
		{
			MyWarriorAttack:Set["trinketone"]
			return ${MyWarriorAttack}				
		}
		if ${This.UseTrinket[14,${MobAdds}]}
		{
			MyWarriorAttack:Set["trinkettwo"]
			return ${MyWarriorAttack}				
		}	
		
		/* Racials  */
		/* lol. removed dranei and tauren when i realized they cant be rogues*/
		if ${Config.GetCheckBox[chkRacial]}
		{
			switch ${Me.Race}
			{
				case Troll
				{
					if ${Me.PctHPs} < 90 && ${Target.PctHPs} > 50 && ${Toon.canCast["Berserking"]}
					{
						MyRogueAttack:Set["Berserking"]
						return ${MyRogueAttack}	
					}
				}
				case Orc
				{
					if ${Me.PctHPs} > 90 && ${Target.PctHPs} > 50 && ${Toon.canCast["Blood Fury"]}
					{
						MyRogueAttack:Set["Blood Fury"]
						return ${MyRogueAttack}	
					}
				}
				case Undead
				{
					if ${Me.Buff[Feared](exists)} && ${Toon.canCast["Will of the Forsaken"]}
					{
						MyRogueAttack:Set["Will of the Forsaken"]
						return ${MyRogueAttack}	
					}
				}
				case Blood Elf
				{
					if ${Target.MaxMana}>0&&${Toon.canCast["Mana Tap"]}&&(${Me.Buff[Mana Tap].Application}<=2)
					{
						MyRogueAttack:Set["Mana Tap"]
						return ${MyRogueAttack}	
					}
				}
				case Dwarf
				{
					if (${Me.Buff[Poisoned](exists)}&&${Me.Buff[Diseased](exists)}&&${Me.Buff[Bleeding](exists)})&&${Toon.canCast[Stoneform]}
					{
						MyRogueAttack:Set["Stoneform"]
						return ${MyRogueAttack}	
					}
				}
				case Gnome
				{
					if (${Me.Buff[Immobilized](exists)}&&${Me.Buff[Slowed](exists)})&&${Toon.canCast["Escape Artist"]}
					{
						MyRogueAttack:Set["Escape Artist"]
						return ${MyRogueAttack}	
					}
				}
				default
				{
					/* do nothing */
				}
			}
		}
		
		/* if your main attack is shiv and your fighting a poison immune mob, use SS instead */
		if ${MyRogueAttack.Equal["Shiv"]}&&(${Target.CreatureType.Equal["Elemental"]}||${Target.CreatureType.Equal["Mechanical"]})
		{
			MyRogueAttack:Set["Sinister Strike"]
			return ${MyRogueAttack}	
		}
		
		/* if your main attack is hemo and the target already has the hemo debuff, use SS instead */
		if ${MyRogueAttack.Equal["Hemorrhage"]}&&${Target.Buff["Hemorrhage"](exists)}
		{
			MyRogueAttack:Set["Sinister Strike"]
			return ${MyRogueAttack}	
		}
		
		/* if your main rogue attack doesnt exist call an error and use SS*/
		if !${Spell[${MyRogueAttack}](exists)}
		{
			This:Output["The main rogue attack you selected doesn't exist. Using SS instead."]
			MyRogueAttack:Set["Sinister Strike"]
			return ${MyRogueAttack}
		}
		
		/* we need our Normal mainhand weapon */
		if ${Me.Equip[16].SubType.Equal["Dagger"]} && ${This.canWeaponSwap}
		{
			This:SwitchWeapon
			return
		}	
		
		return ${MyRogueAttack}	
	}

	;--------------------
	;--- Misc Functions ---
	;--------------------	

	/* used to test if should skip rest or buff state to loot */
	member SkipToLoot()
	{
		if !${Config.GetCheckBox[chkSkipToLoot]} || !${UIElement[chkLoot@Config@InvPages@Inventory@Pages@openbot].Checked}
		{
			return FALSE
		}
		if ${Me.PctHPs} < ${Config.GetSlider[sldHealthForBandage]} || ${Toon.Sitting} || ${Me.Casting} || ${This.restWaitTimer} > 0
		{
			return FALSE
		}	
		if ${Unit[-dead,-lootable,-range 0-4](exists)}
		{
			return TRUE
		}
		if ${Toon.HasSkill[Skinning]}
		{
			if ${Unit[-dead,-skinnable,-range 0-4](exists)} && ${Item[-inventory,"Skinning Knife"](exists)}
			{
				return TRUE
			}
		}
		if ${LavishScript.RunningTime} <= ${State.LOOTState_Loot_Wait_Until}
		{
			return TRUE
		}
		return FALSE
	}
	
	/* by default, first slot in your backpack */
	/* only switches if the weapon is a dagger, sword, mace or fist weapon */
	method SwitchWeapon(int bagNum=0, int slotNum=1)
	{ 
		This:Output["Weapon Swap: ${Me.Bag[${bagNum}].Item[${slotNum}].Name} in Bag ${bagNum}, Slot ${slotNum}"]
		Me.Bag[${bagNum}].Item[${slotNum}]:Use
		return
	}	
	
	/* checks to see if it should be swapping weapons */
	member canWeaponSwap(string requireDagger = "NO", int bagNum=0, int slotNum=1)
	{ 
		variable string itemSubType = ${Me.Bag[${bagNum}].Item[${slotNum}].SubType}
		if ${Config.GetCheckBox[chkWeaponSwap]}
		{		
			if ${requireDagger.Equal["Dagger"]}
			{
				if ${itemSubType.Equal["Dagger"]}
				{
					return TRUE
				}
				return FALSE
			}
			if ${itemSubType.Equal["Mace"]} || ${itemSubType.Equal["Sword"]} || ${itemSubType.Equal["Fist"]}
			{
				return TRUE
			}
			if !${itemSubType.Equal["Dagger"]}
			{
				This:Output["No Weapon found in Bag ${bagNum}, Slot ${slotNum}"]
			}
			return FALSE
		}
		return FALSE
	}		

	member UseTrinket(int trinket, int adds)
	{
		variable int minAdds
		variable float trinketCooldown 
		variable bool check = FALSE
		variable string trinketGUI = "sldAddsForTrinketOne"
		
		if !${Me.Equip[${trinket}](exists)}
		{
			return FALSE
		}
		
		trinketCooldown:Set[${WoWScript[GetInventoryItemCooldown("player"\, ${trinket})]}]		
		if ${trinketCooldown} != 0
		{
			return FALSE
		}
		
		if ${trinket} == 14
		{
			trinketGUI:Set["sldAddsForTrinketTwo"]
		}		
		minAdds:Set[${Config.GetSlider[${trinketGUI}]}]			
		
		if ${adds} > 0 && ${adds} >= ${minAdds}
		{
			return TRUE
		}
		elseif ${adds} == 1000
		{
			return TRUE
		}
		return FALSE
	}
	
	member chooseBestPoison(string PoisonType)
	{
		variable int i = 1
		variable index:string PoisonName
		PoisonName:Insert["${PoisonType} Poison VIII"]
		PoisonName:Insert["${PoisonType} Poison VII"]
		PoisonName:Insert["${PoisonType} Poison VI"]
		PoisonName:Insert["${PoisonType} Poison V"]
		PoisonName:Insert["${PoisonType} Poison IV"]
		PoisonName:Insert["${PoisonType} Poison III"]
		PoisonName:Insert["${PoisonType} Poison II"]
		PoisonName:Insert["${PoisonType} Poison"]
		do
			{
			if ${Item[${PoisonName.Get[${i}]}](exists)}
			{
			return "${PoisonName.Get[${i}]}"
			}
		}
		while ${PoisonName.Get[${i:Inc}](exists)}
		return "NONE"
	}
		
	member detectMobAdd()
	{
		if ${Config.GetCheckBox[chkRangePullOnDetectAdds]}
		{
			if ${Toon.DetectAdds[${Target.GUID}, 1, ${Config.GetSlider[sldRangePullOnDetectAddsRadius]}]}
			{
				return TRUE
			}
		}
		return FALSE
	}
	
	method ClearWaitTimers()
	{
		This.crazyWaitTimer:Set[0]
		This.restWaitTimer:Set[0]  
		This.buffWaitTimer:Set[0]
		This.pullbuffWaitTimer:Set[0]   
		This.combatbuffWaitTimer:Set[0]   
		This.pullWaitTimer:Set[0]
		This.attackWaitTimer:Set[0]	
		This.backattackWaitTimer:Set[0]
		This.lootWaitTimer:Set[0]	
	}


	;----------------------
	;--- Event Hooking ---
	;----------------------

	variable collection:string UIErrorMsgStrings	
	method CreateUIErrorStrings()
	{
		This.UIErrorMsgStrings:Set["You are facing the wrong way!","backward"]
		This.UIErrorMsgStrings:Set["Target too close","backward"]
		This.UIErrorMsgStrings:Set["You are too far away!","forward"]		
		This.UIErrorMsgStrings:Set["Out of range.","forward"]			
	}

	variable bool needUIHook = TRUE
	method UIErrorMessage(string Id, string Msg)
	{
		if ${State.ManualOverride}
		{
			return
		}
		
		if ${This.UIErrorMsgStrings.Element[${Msg}](exists)} && !${Bot.PauseFlag} && ${This.crazyWaitTimer} < ${LavishScript.RunningTime}
		{
			if ${Msg.Equal["Target too close"]} || (${Target.Distance} < 5 && ${Me.InCombat}) || ${This.UIErrorMsgStrings.Element[${Msg}].Equal["forward"]}
			{
				This:Debug[${Msg}]
				This:Output["Moving ${This.UIErrorMsgStrings.Element[${Msg}]} - UI Error: ${Msg}"]
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				This.attackWaitTimer:Set[${This.InMilliseconds[25]}]
				This.pullWaitTimer:Set[${This.InMilliseconds[25]}]
				move ${This.UIErrorMsgStrings.Element[${Msg}]} 800
				return				
			}
		}
	}	

	variable bool needCombatHook = FALSE
	method CombatEvent(string unitID, string unitAction, string isCrit, string amtDamage, string damageType)
	{
	}	
	
	;--------------------
	;--- ROGUE GUI ---
	;--------------------
	
	method SetGUI()
	{
		variable string uniqueToon = "${Me.Name}:${Me.Class}:${ISXWoW.RealmName.Replace[',REMOVE,.,REMOVE]}"
		Config:SetCheckBox[${uniqueToon},"chkSkipToLoot","chkSkipToLoot@Core@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkShootToPull","chkShootToPull@Core@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkChaseRunners","chkChaseRunners@Core@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseBackAttack","chkUseBackAttack@Core@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkWeaponSwap","chkWeaponSwap@Core@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkUseSliceAndDice","chkUseSliceAndDice@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseRupture","chkUseRupture@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseGarrote","chkUseGarrote@Ability@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkUseKidneyShot","chkUseKidneyShot@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseAmbush","chkUseAmbush@Ability@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkUseRiposte","chkUseRiposte@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseGhostlyStrike","chkUseGhostlyStrike@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseKick","chkUseKick@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseDistract","chkUseDistract@Ability@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkRangePullOnDetectAdds","chkRangePullOnDetectAdds@Aggro@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkPatrolInStealth","chkPatrolInStealth@Misc@Pages@ClassGUI",FALSE]
		Config:SetCheckBox[${uniqueToon},"chkRacial","chkRacial@Misc@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUsePickPocket","chkUsePickPocket@Misc@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseGougeOnAdds","chkUseGougeOnAdds@Aggro@Pages@ClassGUI",TRUE]
		Config:SetCheckBox[${uniqueToon},"chkUseBlindOnAdds","chkUseBlindOnAdds@Aggro@Pages@ClassGUI",TRUE]
		Config:SetCombo[${uniqueToon},"cmbPrimaryAttack","cmbPrimaryAttack@Core@Pages@ClassGUI"]
		Config:SetCombo[${uniqueToon},"cmbPrimaryBackAttack","cmbPrimaryBackAttack@Core@Pages@ClassGUI"]
		Config:SetCombo[${uniqueToon},"cmbMainHandPoison","cmbMainHandPoison@Misc@Pages@ClassGUI"]
		Config:SetCombo[${uniqueToon},"cmbOffHandPoison","cmbOffHandPoison@Misc@Pages@ClassGUI"]
		Config:SetSlider[${uniqueToon},"sldRestHP","sldRestHP@Core@Pages@ClassGUI",60]
		Config:SetSlider[${uniqueToon},"sldStandHP","sldStandHP@Core@Pages@ClassGUI",100]
		Config:SetSlider[${uniqueToon},"sldEviscerateMultiplier","sldEviscerateMultiplier@Ability@Pages@ClassGUI",10]
		Config:SetSlider[${uniqueToon},"sldAddsForBladeFlurry","sldAddsForBladeFlurry@Aggro@Pages@ClassGUI",1]
		Config:SetSlider[${uniqueToon},"sldAddsForAdrenalineRush","sldAddsForAdrenalineRush@Aggro@Pages@ClassGUI",1]
		Config:SetSlider[${uniqueToon},"sldAddsForVanish","sldAddsForVanish@Aggro@Pages@ClassGUI",3]
		Config:SetSlider[${uniqueToon},"sldAddsForEvasion","sldAddsForEvasion@Aggro@Pages@ClassGUI",2]
		Config:SetSlider[${uniqueToon},"sldAddsForTrinketOne","sldAddsForTrinketOne@Aggro@Pages@ClassGUI",0]
		Config:SetSlider[${uniqueToon},"sldAddsForTrinketTwo","sldAddsForTrinketTwo@Aggro@Pages@ClassGUI",0]
		Config:SetSlider[${uniqueToon},"sldHealthForEvasion","sldHealthForEvasion@Misc@Pages@ClassGUI",45]
		Config:SetSlider[${uniqueToon},"sldHealthForVanish","sldHealthForVanish@Misc@Pages@ClassGUI",12]
		Config:SetSlider[${uniqueToon},"sldHealthForBandage","sldHealthForBandage@Misc@Pages@ClassGUI",35]
		Config:SetSlider[${uniqueToon},"sldHealthForPotion","sldHealthForPotion@Misc@Pages@ClassGUI",20]
		Config:SetSlider[${uniqueToon},"sldRangePullOnDetectAddsRadius","sldRangePullOnDetectAddsRadius@Aggro@Pages@ClassGUI",25]
		Config:SetSlider[${uniqueToon},"sldHealthForRupture","sldHealthForRupture@Ability@Pages@ClassGUI",70]
		Config:SetSlider[${uniqueToon},"sldHealthForKidneyShot","sldHealthForKidneyShot@Ability@Pages@ClassGUI",50]
		Config:SetSlider[${uniqueToon},"sldPullBailOutTimer","sldPullBailOutTimer@Misc@Pages@ClassGUI",2200]
	}
	
	method SaveGUI()
	{
		variable string uniqueToon = "${Me.Name}:${Me.Class}:${ISXWoW.RealmName.Replace[',REMOVE,.,REMOVE]}"
		Config:SaveCheckBox[${uniqueToon},"chkSkipToLoot"]
		Config:SaveCheckBox[${uniqueToon},"chkShootToPull"]
		Config:SaveCheckBox[${uniqueToon},"chkChaseRunners"]
		Config:SaveCheckBox[${uniqueToon},"chkUseBackAttack"]
		Config:SaveCheckBox[${uniqueToon},"chkWeaponSwap"]
		Config:SaveCheckBox[${uniqueToon},"chkUseSliceAndDice"]
		Config:SaveCheckBox[${uniqueToon},"chkUseRupture"]
		Config:SaveCheckBox[${uniqueToon},"chkUseGarrote"]
		Config:SaveCheckBox[${uniqueToon},"chkUseKidneyShot"]
		Config:SaveCheckBox[${uniqueToon},"chkUseAmbush"]
		Config:SaveCheckBox[${uniqueToon},"chkUseRiposte"]
		Config:SaveCheckBox[${uniqueToon},"chkUseGhostlyStrike"]
		Config:SaveCheckBox[${uniqueToon},"chkUseKick"]
		Config:SaveCheckBox[${uniqueToon},"chkUseDistract"]
		Config:SaveCheckBox[${uniqueToon},"chkRangePullOnDetectAdds"]
		Config:SaveCheckBox[${uniqueToon},"chkPatrolInStealth"]
		Config:SaveCheckBox[${uniqueToon},"chkRacial"]
		Config:SaveCheckBox[${uniqueToon},"chkUsePickPocket"]
		Config:SaveCheckBox[${uniqueToon},"chkUseGougeOnAdds"]
		Config:SaveCheckBox[${uniqueToon},"chkUseBlindOnAdds"]
		Config:SaveCheckBox[${uniqueToon},"chkMakeBand"]
		Config:SaveCombo[${uniqueToon},"cmbPrimaryAttack"]
		Config:SaveCombo[${uniqueToon},"cmbPrimaryBackAttack"]
		Config:SaveCombo[${uniqueToon},"cmbMainHandPoison"]
		Config:SaveCombo[${uniqueToon},"cmbOffHandPoison"]
		Config:SaveCombo[${uniqueToon},"cmbBandType"]
		Config:SaveSlider[${uniqueToon},"sldRestHP"]
		Config:SaveSlider[${uniqueToon},"sldStandHP"]
		Config:SaveSlider[${uniqueToon},"sldEviscerateMultiplier"]
		Config:SaveSlider[${uniqueToon},"sldAddsForBladeFlurry"]
		Config:SaveSlider[${uniqueToon},"sldAddsForAdrenalineRush"]
		Config:SaveSlider[${uniqueToon},"sldAddsForVanish"]
		Config:SaveSlider[${uniqueToon},"sldAddsForEvasion"]
		Config:SaveSlider[${uniqueToon},"sldAddsForTrinketOne"]
		Config:SaveSlider[${uniqueToon},"sldAddsForTrinketTwo"]
		Config:SaveSlider[${uniqueToon},"sldHealthForEvasion"]
		Config:SaveSlider[${uniqueToon},"sldHealthForVanish"]
		Config:SaveSlider[${uniqueToon},"sldHealthForBandage"]
		Config:SaveSlider[${uniqueToon},"sldHealthForPotion"]
		Config:SaveSlider[${uniqueToon},"sldRangePullOnDetectAddsRadius"]
		Config:SaveSlider[${uniqueToon},"sldHealthForRupture"]
		Config:SaveSlider[${uniqueToon},"sldHealthForKidneyShot"]
		Config:SaveSlider[${uniqueToon},"sldPullBailOutTimer"]
	}
}

objectdef oLockpick inherits oBase
{
	variable collection:int PickingSkill
	variable string OpenedBox = NULL
	variable string LockedBox = NULL
	variable int LastScan = 0
	
	method Pulse()
	{
		if ${LootWindow(exists)}
		{
			if ${LootWindow.Count} > 0 
			{
				POI:LootAll
				Class.buffWaitTimer:Set[${This.InMilliseconds[100]}]						
				return
			}
			else
			{
				WoWScript CloseLoot()
				This.LockedBox:Set[NULL]
				This.OpenedBox:Set[NULL]
				Class.buffWaitTimer:Set[${This.InMilliseconds[100]}]						
				return
			}
		}
		if (${Object[${This.OpenedBox}](exists)} && ${This.OpenedBox.NotEqual[NULL]})
		{
			if ${WoWScript[SpellIsTargeting()]} 
			{
				Item[${This.OpenedBox}]:Use
				Class.buffWaitTimer:Set[${This.InMilliseconds[100]}]	
				return			
			}
			else
			{
				Item[${This.OpenedBox}]:Use
				This.OpenedBox:Set[NULL]				
				Class.buffWaitTimer:Set[${This.InMilliseconds[100]}]	
				return
			}				
		}
		if (${Object[${This.LockedBox}](exists)} && ${This.LockedBox.NotEqual[NULL]})
		{
			Toon:CastSpell[Pick Lock]
			This.OpenedBox:Set[${This.LockedBox}]
			Class.buffWaitTimer:Set[${This.InMilliseconds[100]}]					
			return	
		}
		else
		{
			This.LockedBox:Set[NULL]
			This.OpenedBox:Set[NULL]
			return
		}
	}
	
	member canPick(string box)
	{
		variable string theTestChest
		theTestChest:Set[${Item[-inventory,-usable,-locked,${box}].GUID}]
		if ${This.PickingSkill.Element[${Item[${theTestChest}].Name}](exists)} && ${This.PickingSkill.Element[${Item[${theTestChest}].Name}]} <= ${Me.Skill[Lockpicking]}
		{
			This.LockedBox:Set[${theTestChest}]
			return TRUE
		}
		return FALSE
	}

	member checkForLocks()
	{
		if ${Math.Calc[${LavishScript.RunningTime}-${This.LastScan}]} < 30000
		{
			return FALSE
		}
		if ${This.canPick[Chest]} 
		{
			return TRUE
		}
		if ${This.canPick[Junkbox]} 
		{
			return TRUE
		}
		if ${This.canPick[Lockbox]} 
		{
			return TRUE
		}
		This.LastScan:Set[${LavishScript.RunningTime}]
		return FALSE
	}

	member needPick()
	{
		if (${Object[${This.LockedBox}](exists)} && ${This.LockedBox.NotEqual[NULL]}) || (${Object[${This.OpenedBox}](exists)} && ${This.OpenedBox.NotEqual[NULL]})
		{
			return TRUE
		}
		This.LockedBox:Set[NULL]
		This.OpenedBox:Set[NULL]
		
		if ${This.checkForLocks}
		{
			if ${Inventory.FreeSlots} > 0
			{
				return TRUE
			}
		}
		return FALSE
	}

	method PickingStrings()
	{
			This:Output[Loading Lockpicking Data.]
			This.PickingSkill:Set["Battered Junkbox","1"]
			This.PickingSkill:Set["Small Locked Chest","5"]
			This.PickingSkill:Set["Ornate Bronze Lockbox","5"]
			This.PickingSkill:Set["Heavy Bronze Lockbox","25"]
			This.PickingSkill:Set["Sturdy Locked Chest","70"]
			This.PickingSkill:Set["Iron Lockbox","70"]
			This.PickingSkill:Set["Worn Junkbox","75"]
			This.PickingSkill:Set["Strong Iron Lockbox","125"]
			This.PickingSkill:Set["Sturdy Junkbox","175"]
			This.PickingSkill:Set["Ironbound Locked Chest","175"]
			This.PickingSkill:Set["Steel Lockbox","175"]
			This.PickingSkill:Set["Reinforced Steel Lockbox","225"]
			This.PickingSkill:Set["Mithril Lockbox","225"]
			This.PickingSkill:Set["Thorium Lockbox","225"]
			This.PickingSkill:Set["Eternium Lockbox","225"]
			This.PickingSkill:Set["Heavy Junkbox","250"]
			This.PickingSkill:Set["Reinforced Locked Chest","250"]
			This.PickingSkill:Set["Strong Junkbox","300"]
			This.PickingSkill:Set["Khorium Lockbox","325"]
	}	
}