;----- *** GLOBAL ***
#define OB_IDLE 0
#define OB_ASSIST_IDLE 2000
#define OB_PARTY_IDLE 3000


;----- *** MAIN ***
#define OB_DEAD 1001
#define OB_TOON 1002
#define OB_NPC 1003
#define OB_ITEM 1004
#define OB_LOOT 1005
#define OB_QUEST 1006
#define OB_BG 1007
#define OB_ROAM 1008

#define MAIN_STATE_START 1001
#define MAIN_STATE_END 1008

;----- *** ASSIST MODE ***
; no NPC or QUEST or ITEM, replace ROAM with ASSIST
#define OB_DEAD_ASSIST 2001
#define OB_TOON_ASSIST 2002
#define OB_LOOT_ASSIST 2003
#define OB_ASSIST 2004

#define ASSIST_STATE_START 2001
#define ASSIST_STATE_END 2004

;----- *** PARTY MODE ***
#define OB_DEAD_PARTY 3001
#define OB_TOON_PARTY 3002
#define OB_NPC_PARTY 3003
#define OB_ITEM_PARTY 3004
#define OB_LOOT_PARTY 3005
#define OB_QUEST_PARTY 3006
#define OB_ROAM_PARTY 3007

#define OB_PARTY_REST 3100
#define OB_FOLLOW_LEADER 3102
#define OB_PARTYHEAL 3103
#define OB_PARTYBUFF 3104
#define OB_PARTYREZ 3105
#define OB_PARTYCURE 3106
#define OB_CROWDCONTROL 3107

#define PARTY_STATE_START 3001
#define PARTY_STATE_END 3007

;----- DEAD
#define OB_RELEASE 101
#define OB_DEADMOVE 102
#define OB_USE_SPIRITHEALER 103
#define OB_SPIRITHEALER 104
#define OB_SAFE_RES 105
#define OB_REVIVE_CORPSE 106
#define OB_DEAD_WAIT 107
#define OB_DEAD_FUCKED 108
#define OB_DEAD_MOREGOSSIP 109
#define OB_CLASS_DEAD 110

;----- TOON
#define OB_COMBAT_BUFF 201
#define OB_COMBAT 202
#define OB_COMBAT_IDLE 203
#define OB_BUFF 204
#define OB_REST 205
#define OB_MOVETO_PULL 206
#define OB_PULL_BUFF 207
#define OB_PULL 208
#define OB_PULL_WAIT 209
#define OB_CASTING 210
#define OB_CASTING_WAIT 211
#define OB_ACT_HUMAN 212
#define OB_COMBAT_CLASS_IDLE 213
#define OB_FLEE 214
#define OB_FLEE_WAIT 215
#define OB_TOON_WAIT 216

;----- NPC Sub State Name
#define OB_USE_NPC 301
#define OB_MOREGOSSIP 302
#define OB_TAKE_FLIGHT 303
#define OB_REPAIR 304
#define OB_SELL 305
#define OB_TRAINER 306
#define OB_AUCTION 307
#define OB_NPC_WAIT 308
#define OB_NPC_MOVE 309
#define OB_LOGOUT 310
#define OB_START_HEARTH 311
#define OB_HEARTHING 312
#define OB_RESTOCK 313
#define OB_MULE 314
#define OB_NPC_GETTING_READY 315
#define OB_HEARTH_GETTING_READY 316
#define OB_LEARN_FLIGHT 317

;----- TRADESKILL (in NPC and takes place b4 SELL)
#define OB_TRADESKILL_MAKE 320
#define OB_TRADESKILL_BUY 321
#define OB_TRADESKILL_MOVE 322
#define OB_TRADESKILL_WAIT 323

;----- LOOT
#define OB_USE_LOOT 401
#define OB_SKIN_CORPSE 402
#define OB_LOOT_CORPSE 403
#define OB_LOOT_HERB 404
#define OB_LOOT_ORE 405
#define OB_LOOTALL 406
#define OB_CLOSE_LOOT 407
#define OB_LOOT_WAIT 408
#define OB_LOOT_MOVE 409
#define OB_LOOT_GETTING_READY 410
#define OB_OPENING 411
#define OB_FISHING 412


;----- ITEM
#define OB_EQUIP_BAG 501
#define OB_EQUIP_GEAR 502
#define OB_EQUIP_WAIT 503
#define OB_ITEM_DESTROY 504
#define OB_ITEM_OPEN 505
#define OB_ITEM_MOTE 506

;----- QUEST
#define OB_QUEST_REWARD 510
#define OB_QUEST_NEEDGOSSIP 511
#define OB_QUEST_GOSSIP 512
#define OB_QUEST_CLOSEGOSSIP 513
#define OB_QUEST_NEEDNPC 514
#define OB_ITEM_BEGINSQUEST 515
#define OB_QUEST_NEEDOBJECT 516
#define OB_QUEST_HARVEST 517
#define OB_QUEST_WAIT 518

;----- ROAM
#define OB_MOUNT 601
#define OB_DISMOUNT 602
#define OB_LEVELUP 603
#define OB_NEED_PULL 604
#define OB_NEED_VENDOR 605
#define OB_NEED_TRAINER 606
#define OB_NEED_MAILBOX 607
#define OB_NEED_BANK 608
#define OB_NEED_AH 609
#define OB_NEED_FP 530
#define OB_MOVETO_MOB 610
#define OB_ROAMING 611
#define OB_ROAM_TO_NODE 612
#define OB_ROAM_COMPLETE 613
#define OB_ROAM_EXPLORE 614
#define OB_ROAM_EVENT 615

;----- BG
#define OB_BGWAITINGQ 701
#define OB_BGWAITSTART 702
#define OB_BGPREBUFF 703
#define OB_INBG 704
#define OB_BGNEEDQUEUE 705
#define OB_LEAVEBG 706
#define OB_BG_GAURDING 707
#define OB_BG_STUCK 708
#define OB_BG_CLASSGUARD 709



#define OB_FISHING_EXTENSION Autofish
#define OB_FISHING_POLE Fishing Pole


objectdef oState inherits oBase
{
	variable int CurrentState = OB_IDLE
	variable int CurrentSubState = OB_IDLE

	variable string MovingToLoc = "FALSE"
	variable int JustRes = ${LavishScript.RunningTime}
	variable int FindSpot = ${LavishScript.RunningTime}

	variable int LagTime = 10000

	; logout settings
	variable bool LogoutOnTimer = FALSE
	variable int LogOutIn = 0
	variable int LogOutInMS = 0
	variable bool LogOutOnLevel = FALSE
	variable int LogOutLevel = 0
	variable int LastLogoutChange = 0

	; ends hotspot iteration by iterating to next valid location
	variable int Location_Failed_Count = 0
	variable int Location_Failed_Timer = 0

	;Mail
	variable int MailClickable = ${LavishScript.RunningTime}

	variable int DEADState_Wait_Until = 0
	variable int DEADState_Release_Wait_Until_Timeout = 10
	variable int DEADState_Interact_Wait_Until_Timeout = 4

	variable int ITEMState_Equip_Wait_Until = 0
	variable int ITEMState_Equip_Wait_Until_Timeout = 2

	variable int TOONState_Pull_Wait_Until = 0
	variable int TOONState_Pull_Wait_Until_Timeout = 4
	variable int TOONState_Casting_Wait_Until = 0
	variable int TOONState_Casting_Until_Timeout = 2

	variable int TOONState_General_Wait_Until = 0
	variable int TOONState_General_Until_Timeout = 5

	variable int LOOTState_Loot_Wait_Until = 0
	variable int LOOTState_Loot_Wait_Until_Timeout = 1
	variable int LOOTState_Loot_Wait_After_Until_Timeout = 2

	variable int LOOTState_Skip_Scans = 0
	variable int LOOTState_Skip_Scans_Timeout = 10

	variable int TOONState_Flee_Wait_Until = 0
	variable int TOONState_Last_Flee_Time = 0

	variable int LOOTState_Loot_Fishing_Until = 0
	variable int LOOTState_Loot_Fishing_Timeout = 30
	variable string MainHandBeforeFishing = NULL
	variable string OffHandBeforeFishing = NULL


	variable int NPCState_NPC_Wait_Until = 0
	variable int NPCState_Hearthstone_Wait_Until_Timeout = 10
	variable int NPCState_Use_Wait_Until_Timeout = 10
	variable int NPCState_Interact_Wait_Until_Timeout = 2

	variable int QUESTstate_Wait_Until = 0
	variable int QUESTstate_Wait_Until_Timeout = 4
	variable int QUESTstate_Harvest_Wait_Until_Timeout = 10
	
	variable int WaitForLoot = ${LavishScript.RunningTime}


	method Initialize()
	{

	}

	method ShutDown()
	{

	}

	member StateName(int StateNumber)
	{
		switch ${StateNumber}
		{
			;----- GLOBAL State Name
			case OB_IDLE
			return "IDLE"
			case OB_ASSIST_IDLE
			return "ASSIST IDLE"

			;----- MAIN State Name
			case OB_DEAD
			return "DEAD"
			case OB_TOON
			return "TOON"
			case OB_NPC
			return "NPC"
			case OB_BG
			return "BG"
			case OB_ITEM
			return "ITEM"
			case OB_LOOT
			return "LOOT"
			case OB_QUEST
			return "QUEST"
			case OB_ROAM
			return "ROAM"
			case OB_DEAD_WAIT
			return "DEAD WAITING"
			case OB_DEAD_MOREGOSSIP
			return "MOREGOSSIP"

			;----- ASSIST State Name
			case OB_DEAD_ASSIST
			return "DEAD"
			case OB_TOON_ASSIST
			return "TOON"
			case OB_LOOT_ASSIST
			return "LOOT_ASSIST"
			case OB_ASSIST
			return "ASSIST"

			;----- PARTY State Name
			case OB_DEAD_PARTY
			return "DEAD_PARTY"
			case OB_TOON_PARTY
			return "TOON_PARTY"
			case OB_NPC_PARTY
			return "NPC_PARTY"
			case OB_ITEM_PARTY
			return "ITEM_PARTY"
			case OB_LOOT_PARTY
			return "LOOT_PARTY"
			case OB_QUEST_PARTY
			return "QUEST_PARTY"
			case OB_ROAM_PARTY
			return "ROAM_PARTY"
			case OB_PARTYHEAL
			return "HEALING GROUP"
			case OB_PARTYBUFF
			return "BUFFING GROUP"
			case OB_PARTY_REST
			return "PARTY REST"
			case  OB_FOLLOW_LEADER
			return "FOLLOW_LEADER"
			case OB_PARTYREZ
			return "RESSURECT"
			case OB_PARTYCURE
			return "THE CURE"
			case OB_CROWDCONTROL
			return "CROWD CONTROL"
			case OB_PARTY_IDLE
			return "IDLE"

			;----- DEAD Sub State Name
			case OB_RELEASE
			return "RELEASE"
			case OB_DEADMOVE
			return "MOVING"
			case OB_SPIRITHEALER
			return "SPIRIT HEALER"
			case OB_SAFE_RES
			return "SAFE RES"
			case OB_REVIVE_CORPSE
			return "REVIVE CORPSE"
			case OB_DEAD_FUCKED
			return "MISSING PATH WE ARE FUCKED"
			case OB_CLASS_DEAD
			return "ROUTINE OVERRIDE"

			;----- ROAM Sub State Name
			case OB_LEVELUP
			return "LEVEL UP"
			case OB_NEED_VENDOR
			return "VENDOR"
			case OB_NEED_TRAINER
			return "TRAINER"
			case OB_NEED_MAILBOX
			return "MAILBOX"
			case OB_NEED_BANK
			return "BANK"
			case OB_NEED_AH
			return "AH"
			case OB_NEED_FP
			return "FLIGHT PATH"
			case OB_MOUNT
			return "MOUNT"
			case OB_DISMOUNT
			return "DISMOUNT"
			case OB_MOVETO_MOB
			return "MOVETO_MOB"
			case OB_ROAMING
			return "ROAMING"
			case OB_NEED_INNKEEPER
			return "INNKEEPER"
			case OB_MULE
			return "MAIL MULE"
			case OB_NPC_GETTING_READY
			return "GETTING READY"
			case OB_ROAM_TO_NODE
			return "ROAM TO NODE"
			case OB_ROAM_COMPLETE
			return "ROAM COMPLETE"
			case OB_ROAM_EXPLORE
			return "ROAM EXPLORE"
			case OB_ROAM_EVENT
			return "ROAM EVENT"

			;----- TOON Sub State Name
			case OB_COMBAT_BUFF
			return "COMBAT BUFF"
			case OB_COMBAT
			return "COMBAT"
			case OB_COMBAT_IDLE
			return "COMBAT_IDLE"
			case OB_COMBAT_CLASS_IDLE
			return "CLASS_IDLE"
			case OB_BUFF
			return "BUFF"
			case OB_REST
			return "REST"
			case OB_MOVETO_PULL
			return "MOVETO_PULL"
			case OB_PULL_BUFF
			return "PULL BUFF"
			case OB_PULL
			return "PULL"
			case OB_PULL_WAIT
			return "PULL WAIT"
			case OB_CASTING
			return "CASTING"
			case OB_CASTING_WAIT
			return "CASTING WAIT"
			case OB_ACT_HUMAN
			return "ACT HUMAN"
			case OB_FLEE
			return "RUN LIKE A GIRL"
			case OB_FLEE_WAIT
			return "POST FLEE WAIT"
			case OB_TOON_WAIT
			return "GENERAL WAIT"

			;----- LOOT Sub State Name
			case OB_SKIN_CORPSE
			return "SKINNING"
			case OB_LOOT_CORPSE
			return "LOOTING"
			case OB_LOOT_HERB
			return "HERBING"
			case OB_LOOT_ORE
			return "MINING"
			case OB_USE_LOOT
			return "USE"
			case OB_LOOTALL
			return "LOOT ALL"
			case OB_CLOSE_LOOT
			return "CLOSING LOOT"
			case OB_LOOT_WAIT
			return "WAIT FOR LOOT"
			case OB_LOOT_MOVE
			return "MOVE TO LOOT"
			case OB_LOOT_GETTING_READY
			return "GETTING READY"
			case OB_OPENING
			return "OPENING"
			case OB_FISHING
			return "FISHING"

			;----- NPC Sub State Name
			case OB_MOREGOSSIP
			return "TALK TO NPC"
			case OB_TAKE_FLIGHT
			return "FLIGHT MASTER"
			case OB_LEARN_FLIGHT
			return "LEARN FLIGHT"
			case OB_REPAIR
			return "REPAIR"
			case OB_SELL
			return "SELL"
			case OB_TRAINER
			return "TRAINER"
			case OB_AUCTION
			return "AUCTION"
			case OB_NPC_WAIT
			return "NPC WAIT"
			case OB_NPC_MOVE
			return "NPC MOVE"
			case OB_START_HEARTH
			return "Invoke Hearthstone"
			case OB_HEARTHING
			return "Hearthing"
			case OB_RESTOCK
			return "RESTOCK FOOD"
			case OB_HEARTH_GETTING_READY
			return "HEARTH GETTING READY"

			;----- TRADESKILL
			case OB_TRADESKILL_MAKE
			return "TRADESKILL_MAKE"
			case OB_TRADESKILL_BUY
			return "TRADESKILL_BUY"
			case OB_TRADESKILL_MOVE
			return "TRADESKILL_MOVE"
			case OB_TRADESKILL_WAIT
			return "TRADESKILL_WAIT"

			;----- ITEM Sub State Name
			case OB_EQUIP_BAG
			return "Equip Bag"
			case OB_EQUIP_GEAR
			return "Equip Gear"
			case OB_EQUIP_WAIT
			return "Equip Wait"
			case OB_ITEM_DESTROY
			return "Destroying"
			case OB_ITEM_OPEN
			return "Opening"
			case OB_ITEM_MOTE
			return "Stacking Motes"

			;----- QUEST Sub State Name
			case OB_QUEST_NEEDOBJECT
			return "QUEST_OBJECT"
			case OB_QUEST_HARVEST
			return "QUEST_HARVEST"
			case OB_QUEST_NEEDGOSSIP
			return "NEED_QUEST"
			case OB_QUEST_GOSSIP
			return "QUEST_GOSSIP"
			case OB_QUEST_CLOSEGOSSIP
			return "CLOSE_QUESTS"
			case OB_QUEST_NEEDNPC
			return "MOVETO_QUESTGIVER"
			case OB_ITEM_BEGINSQUEST
			return "ITEM_STARTQUEST"
			case OB_QUEST_REWARD
			return "QUEST_REWARD"
			case OB_QUEST_WAIT
			return "QUEST_WAIT"

			;----- BG State
			case OB_BGWAITINGQ
			return "BG Queued"
			case OB_BGWAITSTART
			return "Wait BG Start"
			case OB_BGPREBUFF
			return "BG Buff Prep"
			case OB_INBG
			return "In BG"
			case OB_BGNEEDQUEUE
			return "BG:Need Queue"
			case OB_LEAVEBG
			return "Leave BG"
			case OB_BG_GAURDING
			return "GAURDING"
			case OB_BG_STUCK
			return "BG STUCK"
		}
		return "UNKNOWN:" ${StateNumber}
	}

	/* we branch which states get tested based on Mode */
	/* assist and party have there own set of states that can hook the others as needed */
	method Pulse()
	{
		variable int TempState
		variable int i

		if !${UIElement[chkAssistMode@Overview@Pages@openbot].Checked} && !${UIElement[chkPartyMode@Overview@Pages@openbot].Checked}
		{
			for (i:Set[MAIN_STATE_START];${i}<= MAIN_STATE_END;i:Inc)
			{
				TempState:Set[${This.${This.StateName[${i}]}State}]
				if ${TempState} != OB_IDLE
				{
					This.CurrentState:Set[${i}]
					This.CurrentSubState:Set[${TempState}]
					;This:Debug[${This.StateName[${This.CurrentState}]} ${This.StateName[${This.CurrentSubState}]}]
					This:${This.StateName[${This.CurrentState}]}Pulse
					return
				}
			}
		}
		elseif ${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
		{
			if ${State.ManualOverride}
			{
				This.CurrentState:Set[OB_ASSIST]
				This.CurrentSubState:Set[OB_ASSIST_IDLE]
				This:Output[User Control Detected.]
				This:${This.StateName[${This.CurrentState}]}Pulse
				return
			}
			for (i:Set[ASSIST_STATE_START];${i}<= ASSIST_STATE_END;i:Inc)
			{
				TempState:Set[${This.${This.StateName[${i}]}State}]
				if ${TempState} != OB_IDLE
				{
					This.CurrentState:Set[${i}]
					This.CurrentSubState:Set[${TempState}]
					;This:Debug[${This.StateName[${This.CurrentState}]} ${This.StateName[${This.CurrentSubState}]}]
					This:${This.StateName[${This.CurrentState}]}Pulse
					return
				}
			}
		}
		else
		{
			for (i:Set[PARTY_STATE_START];${i}<= PARTY_STATE_END;i:Inc)
			{
				TempState:Set[${This.${This.StateName[${i}]}State}]
				if ${TempState} != OB_IDLE
				{
					This.CurrentState:Set[${i}]
					This.CurrentSubState:Set[${TempState}]
					;This:Debug[${This.StateName[${This.CurrentState}]} ${This.StateName[${This.CurrentSubState}]}]
					This:${This.StateName[${This.CurrentState}]}Pulse
					return
				}
			}
		}
	}

	;----------
	;----- DEAD Sub State
	;----------

	member DEADState()
	{
		/* wait for death lag */
		if ${LavishScript.RunningTime} <= ${DEADState_Wait_Until}
		{
			return OB_DEAD_WAIT
		}

		/* when we are dead, but not yet a ghost -- allow for routine hooking here */
		if ${Me.Dead}
		{
			if ${Class.NeedDead}
			{
				return OB_CLASS_DEAD
			}
			This.DEADState_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.DEADState_Release_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_RELEASE
		}

		/* ok -- we died and releaseed -- now what? (No BG Spirit Healer Nearby) */
		if ${Me.Ghost} && !${BG.InBG}
		{
			if ${Math.Calc[${LavishScript.RunningTime} - ${This.JustRes}]} >= ${LagTime}
			{
				/* check corpse before Spirit Healer */
				if ${POI.Type.Equal[CORPSE]}
				{
					if ${Navigator.SafeToRes}
					{
						return OB_REVIVE_CORPSE
					}
					else
					{
						if ${Math.Distance[${Me.Location},${Me.Corpse}]} < 40
						{
							return OB_SAFE_RES
						}
						else
						{
							return OB_DEADMOVE
						}
					}
				}
				elseif !${POI.NeedSpiritHealer}
				{
					/* only set corpse if we dont need Spirit Healer */
					/* and only need Spirit Healer based on corpse counter */
					if ${POI.Set[${Me.Corpse.X}:${Me.Corpse.Y}:${Me.Corpse.Z}:-1:"Corpse of ${Me.Name}":CORPSE:${Me.FactionGroup.Upper}:${Me.Level}]}
					{
						return OB_DEADMOVE
					}
				}

				if ${POI.Type.Equal[SPIRITHEALER]} && !${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
				{
					if ${POI.InUseRange}
					{
						if ${WoWScript[StaticPopup1:IsVisible()]}
						{
							This.DEADState_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.DEADState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_SPIRITHEALER
						}
						else
						{
							if ${WoWScript[GetGossipOptions()](exists)}
							{
								return OB_DEAD_MOREGOSSIP
							}
							else
							{
								This.DEADState_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.DEADState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_USE_SPIRITHEALER
							}
						}
					}
					else
					{
						return OB_DEADMOVE
					}
				}
				else
				{
					if ${POI.SetNearestPOI[SPIRITHEALER]} && !${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
					{
						return OB_DEADMOVE
					}
					elseif ${POI.Set[${Me.Corpse.X}:${Me.Corpse.Y}:${Me.Corpse.Z}:-1:"Corpse of ${Me.Name}":CORPSE:${Me.FactionGroup.Upper}:${Me.Level}]}
					{
						return OB_DEADMOVE
					}
					else
					{
						This:Output[No way to Corpse and to Spirithealer. Not enough Mapping data.]
						return OB_DEAD_FUCKED
					}
				}
			}
			else
			{
				return OB_DEAD_WAIT
			}
		}
		if ${Me.Ghost} && ${BG.InBG}
		{
			Toon:Stop
			return OB_DEAD_WAIT
		}
		return OB_IDLE
	}

	method DEADPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_CLASS_DEAD
			Class:DeadPulse
			break

			case OB_RELEASE
			if ${UIElement[chkDeathSoundOn@Config@Pages@openbot].Checked}
			{
				This:PlaySound["Inform"]
			}
			Navigator:ClearPath
			move -stop
			This.JustRes:Set[${LavishScript.RunningTime}]
			WoWScript RepopMe()
			if ${LavishScript.RunningTime} <= ${Math.Calc[${POI.LastRetrieveCorpseTime} + ${POI.CorpseCampTimeout}]} && !${UIElement[chkAssistMode@Overview@Pages@openbot].Checked} && !${BG.BGMode}
			{
				POI.CorpseCampCount:Inc
				This:Output[Corpse Camp Counter ${POI.CorpseCampCount} of ${Config.GetSlider[sldCorpseCamped]}]
				if ${POI.CorpseCampCount} >= ${Config.GetSlider[sldCorpseCamped]} && !${BG.InBG}
				{
					This:Output[Corpse Camped -> Try Spritithealer]
					This:Output[Trying luck at next Grind Spot]
					Grind:NextHotspot
					POI.NeedSpiritHealer:Set[TRUE]
					POI.CorpseCampCount:Set[0]
				}
			}
			else
			{
				POI.CorpseCampCount:Set[0]
			}
			Grind.RepopCount:Inc
			break

			case OB_DEAD_MOREGOSSIP
			WoWScript SelectGossipOption(1)
			break

			case OB_SPIRITHEALER
			WoWScript "AcceptXPLoss()"
			break

			case OB_USE_SPIRITHEALER
			Navigator:ClearPath
			move -stop
			POI:Use
			break

			case OB_DEADMOVE
			MovingToLoc:Set["TRUE"]
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_SAFE_RES
			Navigator:ClearPath
			FindSpot:Set[${LavishScript.RunningTime}]
			MovingToLoc:Set["TRUE"]
			Navigator:MoveToLoc[${Navigator.FindSafeSpot}]
			break

			case OB_REVIVE_CORPSE
			Navigator:ClearPath
			Navigator.ForceRes:Set[FALSE]
			Navigator.ResSpot:Set[0]
			WoWScript RetrieveCorpse()
			MovingToLoc:Set["TRUE"]
			MovingToLoc:Set["FALSE"]
			POI.LastRetrieveCorpseTime:Set[${LavishScript.RunningTime}]
			break
		}
	}

	;----------
	;----- TOON Sub State
	;----------
	member TOONState()
	{

		if ${LavishScript.RunningTime} <= ${This.TOONState_General_Wait_Until}
		{
			return OB_TOON_WAIT
		}

		if ${Me.Flying}
		{
			This.TOONState_General_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.TOONState_General_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_TOON_WAIT
		}

		if ${Flee.NeedToRun}
		{
			return OB_FLEE
		}

		if ${Me.InCombat} && !${Mount.IsMounted}
		{
			/* first lets deal with our POI and Target */
			if ${Toon.ValidTarget[${Target.GUID}]} && ${Target.PctHPs} > 0
			{
				if ${POI.GUID.NotEqual[${Target.GUID}]}
				{
					if !${POI.Set[${Target.X}:${Target.Y}:${Target.Z}:${Target.GUID}:${Target.Name}:MOB:FACTION_NEUTRAL:${Target.Level},TRUE]}
					{
						This:Debug[Error: Can not set POI to Target]
					}
				}
			}
			elseif ${Me.InCombat} && ${Toon.ValidTarget[${Targeting.TargetCollection.Get[1]}]} && ${Object[${Targeting.TargetCollection.Get[1]}].PctHPs} > 0
			{
				Toon:NeedTarget
				if !${POI.Set[${Object[${Targeting.TargetCollection.Get[1]}].X}:${Object[${Targeting.TargetCollection.Get[1]}].Y}:${Object[${Targeting.TargetCollection.Get[1]}].Z}:${Object[${Targeting.TargetCollection.Get[1]}].GUID}:${Object[${Targeting.TargetCollection.Get[1]}].Name}:MOB:FACTION_NEUTRAL:${Object[${Targeting.TargetCollection.Get[1]}].Level},TRUE]}
				{
					This:Debug[Error: Can not set POI to AGGRO Target]
					Toon:NeedTarget
				}
			}

			/* darkfriend add this */
			if ${BG.BGMode}
			{
				if (${Target(exists)} && ${Target.Type.Equal["Player"]}) || (${Target.Distance} < ${Toon.PullRange} && ${Target.LineOfSight} && (!${Mount.IsMounted} || !${Movement.Speed} && ${Mount.IsMounted}))
				{
					if ${Class.NeedCombatBuff}
					{
						return OB_COMBAT_BUFF
					}
					else
					{
						return OB_COMBAT
					}
				}
				elseif !${Target(exists)} && !${Mount.IsMounted}
				{
					/* we have no target, so lets idle */
					if ${Class.NeedCombatIdle}
					{
						return OB_COMBAT_CLASS_IDLE
					}
				}
			}
			else
			{
				if ${Target(exists)}
				{
					if ${Class.NeedCombatBuff}
					{
						return OB_COMBAT_BUFF
					}
					else
					{
						return OB_COMBAT
					}
				}
				else
				{
					/* we have no target, so lets idle */
					if ${Class.NeedCombatIdle}
					{
						return OB_COMBAT_CLASS_IDLE
					}
					return OB_COMBAT_IDLE
				}
			}
		}

		if ${Class.NeedRest}
		{
			return OB_REST
		}

		if ${Class.NeedBuff} &&  (0 < ${Toon.SafeSpotRange}) && ${WoWScript[GetBattlefieldInstanceExpiration()]} == 0
		{
			if !${Mount.IsMounted} && 0 < ${Toon.SafeSpotRange}
			{
				return OB_BUFF
			}
		}

		if ${Toon.PullableTarget} && (!${Mount.IsMounted} || ${BG.BGMode})
		{
			if ${POI.Set[${Object[${Targeting.TargetCollection.Get[1]}].X}:${Object[${Targeting.TargetCollection.Get[1]}].Y}:${Object[${Targeting.TargetCollection.Get[1]}].Z}:${Object[${Targeting.TargetCollection.Get[1]}].GUID}:${Object[${Targeting.TargetCollection.Get[1]}].Name}:MOB:FACTION_NEUTRAL:${Object[${Targeting.TargetCollection.Get[1]}].Level},FALSE]}
			{
				if ${Object[${Targeting.TargetCollection.Get[1]}].Distance} > ${Toon.PullRange} && !${Me.Casting}
				{
					return OB_MOVETO_PULL
				}
				else
				{
					if ${Class.NeedPullBuff}
					{
						return OB_PULL_BUFF
					}
					else
					{
						return OB_PULL
					}
				}
			}
			else
			{
				This:Output["Error: Can not set POI to PULL Target"]
			}
		}

		/* catch all casting check - takes place after combat and pull so it wont interfere with combat casting */
		/* we have waits already defined for skinning and such in LOOT */
		if ${Toon.Casting}
		{
			return OB_CASTING
		}

		if ${LavishScript.RunningTime} <= ${This.TOONState_Casting_Wait_Until}
		{
			return OB_CASTING_WAIT
		}

		if ${Human.NeedAction} && ${Human.ActionDelay} < ${LavishScript.RunningTime} && !${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
		{
			return OB_ACT_HUMAN
		}

		if ${LavishScript.RunningTime} <= ${This.TOONState_Flee_Wait_Until} || ${Math.Calc[${LavishScript.RunningTime}-${This.TOONState_Last_Flee_Time}]} < 1500
		{
			return OB_FLEE_WAIT
		}
		return OB_IDLE
	}

	method TOONPulse()
	{
		if ${Script[OB_FISHING_EXTENSION](exists)}
		{
			This:EndFishing
		}

		switch ${This.CurrentSubState}
		{
			case OB_TOON_WAIT
			/* do nothing, just wait and see */
			break
			case OB_FLEE
			if ${Class.HookFlee}
			{
				Class:FleePulse
			}
			Flee:MoveToFlee
			This.TOONState_Last_Flee_Time:Set[${LavishScript.RunningTime}]
			break

			case OB_FLEE_WAIT
			if ${Math.Calc[${LavishScript.RunningTime}-${This.TOONState_Last_Flee_Time}]} < 1500
			{
				Flee:MoveToFlee
				This.TOONState_Flee_Wait_Until:Set[${This.InMilliseconds[${Math.Rand[450]}]}]
				This:Output["Should be safe, but getting a bit farther away."]
				return
			}
			if ${Movement.Speed}
			{
				Navigator:MoveToLoc[${Me.X},${Me.Y},${Me.Z}]
				move -stop
			}
			This:Output["Waiting a moment after FLEE."]
			break

			case OB_COMBAT_BUFF
			Mount:Dismount
			Class:CombatBuffPulse
			break

			case OB_COMBAT
			Mount:Dismount
			Navigator:ClearPath
			Class:AttackPulse
			break

			case OB_COMBAT_IDLE
			move -stop
			This:Output["Idle in combat."]
			break

			case OB_COMBAT_CLASS_IDLE
			Class:CombatIdle
			break

			case OB_BUFF
			Mount:Dismount
			Navigator:ClearPath
			Class:BuffPulse
			break

			case OB_REST
			Mount:Dismount
			Navigator:ClearPath
			Class:RestPulse
			break

			case OB_MOVETO_PULL
			Mount:Dismount
			Toon:NeedTarget
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_PULL_BUFF
			Mount:Dismount
			Navigator:ClearPath
			Class:PullBuffPulse
			break

			case OB_PULL
			Navigator:ClearPath
			Toon:NeedTarget
			Class:PullPulse
			break

			case OB_CASTING
			This.TOONState_Casting_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.TOONState_Casting_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			if ${Toon.spellCastTime}
			{
				move -stop
			}
			break

			case OB_CASTING_WAIT
			move -stop
			break

			case OB_ACT_HUMAN
			Human:Pulse
			break
		}
	}


	;----------
	;----- LOOT Sub State
	;----------
	member LOOTState()
	{
		variable guidlist list
		variable int Index
		variable bool Found = FALSE
		variable int bltimer

		if ${BG.BGLootMode} && ${BG.BGMode} && ${BG.InBG}
		{
			return OB_IDLE
		}

		if ${Script[OB_FISHING_EXTENSION](exists)} && ${LavishScript.RunningTime} <= ${This.LOOTState_Loot_Fishing_Until} && (${Item[-inventory,"OB_FISHING_POLE"](exists)} || ${Me.Equip[16].Name.Equal["OB_FISHING_POLE"]})
		{
			This:StartFishing
			return OB_FISHING
		}
		else
		{
			This:EndFishing
		}

		if ${Me(unit).Casting.Name.Token[1," "].Equal[Skinning]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_SKIN_CORPSE
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Herbalism]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_LOOT_HERB
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Mining]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_LOOT_ORE
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Opening]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_OPENING
		}

		if ${LavishScript.RunningTime} <= ${This.LOOTState_Loot_Wait_Until}
		{
			return OB_LOOT_WAIT
		}

		if ${LootWindow(exists)}
		{
			if ${LootWindow.Count} > 0 && (${Inventory.FreeSlots} > 0)
			{
				This.LOOTState_Skip_Scans:Set[0]
				return OB_LOOTALL
			}
			else
			{
				This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_After_Until_Timeout} * ${Bot.GlobalCooldown})]}]
				This.LOOTState_Skip_Scans:Set[0]
				return OB_CLOSE_LOOT
			}
		}

		
			if (${Inventory.FreeSlots} > 0) && ${UIElement[chkLoot@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-units,-dead,-lootable,-nearest]
				Index:Set[0]
				if ${list.Count} > 0
				{
					while ${list.GUID[${Index:Inc}](exists)} && !${Found}
					{
						if ${Unit[${list.GUID[${Index}]}].Lootable}
						{
							if ${POI.Set[${Unit[${list.GUID[${Index}]}].X}:${Unit[${list.GUID[${Index}]}].Y}:${Unit[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Unit[${list.GUID[${Index}]}].Name}:LOOT:FACTION_NEUTRAL:${Unit[${list.GUID[${Index}]}].Level}]}
							{
								Found:Set[TRUE]
							}
						}
						if ${Unit[${list.GUID[${Index}]}].Skinnable}
						{
							if ${Toon.CanSkinMob[${list.GUID[${Index}]}]}
							{
								if ${POI.Set[${Unit[${list.GUID[${Index}]}].X}:${Unit[${list.GUID[${Index}]}].Y}:${Unit[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Unit[${list.GUID[${Index}]}].Name}:SKILL_SKINNING:FACTION_NEUTRAL:${Unit[${list.GUID[${Index}]}].Level}]}
								{
									Found:Set[TRUE]
								}
							}
						}
					}
				}
			}
			
			if ${LavishScript.RunningTime} >= ${LOOTState_Skip_Scans} || ${UIElement[chkAssistMode@Overview@Pages@openbot].Checked}
		{
			This.LOOTState_Skip_Scans:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Skip_Scans_Timeout} * ${Bot.GlobalCooldown})]}]


			if !${Found} && ${Toon.HasSkill[SKILL_HERBALISM]} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkGather@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects,-herb,-usable,-unlocked,-nearest]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${Toon.SkillLevel[Herbalism]} >= ${OBDB.GetLevel[${Object[${list.GUID[${Index}]}].Name}]}
					{
						if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:SKILL_HERBALISM:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
						{
							Found:Set[TRUE]
						}
					}
					else
					{
						This:Output[do Not want ${Object[${list.GUID[${Index}]}].Name} level to high.]
					}
				}
			}
			if !${Found} && ${Toon.HasSkill[SKILL_MINING]} && ${Item[-inventory,"Mining Pick"](exists)} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkGather@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects,-mine,-usable,-unlocked,-nearest]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${Toon.SkillLevel[Mining]} >= ${OBDB.GetLevel[${Object[${list.GUID[${Index}]}].Name}]}
					{
						if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:SKILL_MINING:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
						{
							Found:Set[TRUE]
						}
					}
					else
					{
						This:Output[do Not want ${Object[${list.GUID[${Index}]}].Name} level to high.]
					}
				}
			}
			/* quest objects */
			if !${Found} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkHarvestQuests@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects, -nearest, -chest, -unlocked, -usable]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:QUESTOBJECT:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
					{
						Found:Set[TRUE]
					}
				}
			}
		}


		if ${POI.Type.Equal[LOOT]} || ${POI.Type.Equal[Skinning]}
		{
			/*
			if ${Toon.DetectAdds[${POI.GUID}]}
			{
				This:Output[Detected too many adds next to ${POI.Name}. Blacklisting it with GUID for 1 Hour.]
				GlobalBlacklist:Insert[${POI.GUID},3600000]
				POI:Clear
				This.LOOTState_Skip_Scans:Set[0]
				return OB_LOOT_WAIT
			}
			else
			{
				*/
				if ${POI.IsBlacklisted} || !${Object[${POI.GUID}](exists)}
				{
					POI:Clear
					This.LOOTState_Skip_Scans:Set[0]
					return OB_LOOT_WAIT
				}
				else
				{
					if ${POI.InUseRange}
					{
						if (${POI.Type.Equal[LOOT]} && !${Unit[${POI.GUID}].CanLoot})
						{
							POI:Clear
							This.LOOTState_Skip_Scans:Set[0]
							return OB_LOOT_WAIT
						}
						if ${Movement.Speed} || ${Toon.Sitting}
						{
							return OB_LOOT_GETTING_READY
						}
						else
						{
							if ${WaitForLoot} <= ${LavishScript.RunningTime}
							{
							return OB_USE_LOOT
							}
						}
					}
					else
					{
						return OB_LOOT_MOVE
					}
				}
			/*	
			}
			*/
		}
		return OB_IDLE
	}

	method LOOTPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_LOOT_MOVE
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_LOOT_GETTING_READY
			Toon:Standup
			if ${Movement.Speed}
			{
				Navigator:ClearPath
				move -stop
			}
			break

			case OB_USE_LOOT
			POI:Use
			break

			case OB_SKIN_CORPSE
			This:Output["OOOO a skinable corpse, gimmie!!"]
			POI.LastUse:Set[${LavishScript.RunningTime}]
			break

			case OB_LOOT_HERB
			This:Output["OOOO a Herb, gimmie!!"]
			POI.LastUse:Set[${LavishScript.RunningTime}]
			break

			case OB_LOOT_ORE
			This:Output["OOOO an ore deposit, gimmie!!!"]
			POI.LastUse:Set[${LavishScript.RunningTime}]
			break

			case OB_OPENING
			This:Output["OOOO something to open, gimmie!!!"]
			POI.LastUse:Set[${LavishScript.RunningTime}]
			break


			case OB_LOOTALL
			Mount:Dismount
			Navigator:ClearPath
			move -stop
			Toon:Standup
			WaitForLoot:Set[${Math.Calc[${LavishScript.RunningTime} + 800]}]
			POI:LootAll
			Grind.LootCount:Inc
			break

			case OB_CLOSE_LOOT
			WaitForLoot:Set[${Math.Calc[${LavishScript.RunningTime} + 800]}]
			WoWScript CloseLoot()
			POI:Clear
			break
		}
	}

	;----------
	;----- NPC Sub State
	;----------
	member NPCState()
	{
		if ${Me(unit).Casting.Name.Token[1," "].Equal["Hearthstone"]}
		{
			This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Hearthstone_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_HEARTHING
		}

		if ${LavishScript.RunningTime} <= ${NPCState_NPC_Wait_Until}
		{
			return OB_NPC_WAIT
		}

		if ${POI.NeedLogout} || (${UIElement[chkLogOutOnLevel@Logout@Pages@OpenBot].Checked} && ${UIElement[sldLogOutLevel@Logout@Pages@OpenBot].Value(exists)} && ${Me.Level} >= ${UIElement[sldLogOutLevel@Logout@Pages@OpenBot].Value}) || (${UIElement[chkLogoutOnTimer@Logout@Pages@OpenBot].Checked} && ${UIElement[sldLogOutIn@Logout@Pages@OpenBot].Value(exists)} && ${Bot.LogOutIn} <= ${LavishScript.RunningTime}
		{
			if ${Item[Hearthstone](exists)} && ${Me.Action[Hearthstone].Usable}
			{
				if ${Movement.Speed} || ${Toon.Sitting}
				{
					return OB_HEARTH_GETTING_READY
				}
				else
				{
					This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Hearthstone_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
					return OB_START_HEARTH
				}
			}

			if ${POI.Type.Equal[INNKEEPER]} && !${POI.IsBlacklisted}
			{
				if ${POI.InUseRange}
				{
					return OB_LOGOUT
				}
				else
				{
					return OB_NPC_MOVE
				}
			}
			else
			{
				if ${POI.SetNearestPOI[INNKEEPER]}
				{
					return OB_NPC_MOVE
				}
				else
				{
					This:Output[Not enough mapping data to get to an Innkeeper, logging out here!]
					return OB_LOGOUT
				}
			}
		}

		if ${POI.Type.Equal[FLIGHTMASTER]} && !${POI.IsBlacklisted}
		{
			if ${POI.InUseRange}
			{
				if ${WoWScript[TaxiFrame:IsVisible()]}
				{
					This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
					return OB_TAKE_FLIGHT
				}
				else
				{
					if ${WoWScript[GetGossipOptions()](exists)}
					{
						This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
						return OB_MOREGOSSIP
					}
					if ${Movement.Speed} || ${Toon.Sitting}
					{
						return OB_NPC_GETTING_READY
					}
					else
					{
						This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
						return OB_USE_NPC
					}
				}
			}
			else
			{
				return OB_NPC_MOVE
			}
		}
		else
		{
			if ${FlightPlan.TakeFlightMaster}
			{
				if ${FlightPlan.SetFlightPOI}
				{
					return OB_NPC_MOVE
				}
				else
				{
					FlightPlan.NeedFlight:Set[FALSE]
				}
			}
		}

		if ${FlightPlan.LearnFlightMaster}
		{
			if !${Config.GetCheckbox[chkLearnFM]}
			{
				FlightPlan.LearnFlightMaster:Set[FALSE]
				FlightPlan.LearnFM:Set["0:0:0:0:0:0:0:0"]
			}
			elseif ${POI.Type.Equal[FLIGHTMASTER]} && !${POI.IsBlacklisted}
			{
				if ${POI.InUseRange}
				{
					if ${WoWScript[TaxiFrame:IsVisible()]}
					{
						return OB_LEARN_FLIGHT
					}
					else
					{
						if ${WoWScript[GetGossipOptions()](exists)}
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_MOREGOSSIP
						}
						if ${Movement.Speed} || ${Toon.Sitting}
						{
							return OB_NPC_GETTING_READY
						}
						else
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_USE_NPC
						}
					}
				}
				return OB_NPC_MOVE
			}
			elseif ${POI.Set[${FlightPlan.LearnFM}]}
			{
				return OB_LEARN_FLIGHT
			}
		}

		if ${POI.NeedRepair}
		{
			if ${POI.Type.Equal[REPAIR]} && !${POI.IsBlacklisted}
			{
				if ${POI.InUseRange}
				{
					if ${WoWScript[MerchantFrame:IsVisible()]}
					{
						This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
						return OB_REPAIR
					}
					else
					{
						if ${WoWScript[GetGossipOptions()](exists)}
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_MOREGOSSIP
						}
						else
						{
							if ${Movement.Speed} || ${Toon.Sitting}
							{
								return OB_NPC_GETTING_READY
							}
							else
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_USE_NPC
							}
						}
					}
				}
				else
				{
					return OB_NPC_MOVE
				}
			}
			else
			{
				if ${POI.SetNearestPOI[REPAIR]}
				{
					return OB_NPC_MOVE
				}
				else
				{
					This:Output[Not enough mapping data to REPAIR POI !]
					;no return here try other NPC
				}
			}
		}

		if !${BG.BGMode}
		{
			if ${POI.NeedTradeSkill}
			{
				/* Tradeskills.NeedTradeSkill should determine when tradeskills should start and stop */
				if ${Tradeskills.NeedTradeSkill}
				{
					if ${Tradeskills.NeedMake}
					{
						return OB_TRADESKILL_MAKE
					}
					elseif ${Tradeskills.NeedBuy}
					{
						return OB_TRADESKILL_BUY
					}
					elseif ${Tradeskills.NeedTradePOI}
					{
						/* set POI here */
						return OB_TRADESKILL_MOVE
					}
					elseif ${Tradeskills.NeedWait}
					{
						return OB_TRADESKILL_WAIT
					}
				}
				POI.NeedTradeSkill:Set[FALSE]
			}

			if ${POI.NeedSell}
			{
				if ${POI.Type.Equal[SELL]} && !${POI.IsBlacklisted}
				{
					if ${WoWScript[MerchantFrame:IsVisible()]}
					{
						This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
						return OB_SELL
					}
					else
					{
						if ${POI.InUseRange}
						{
							if ${WoWScript[GetGossipOptions()](exists)}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_MOREGOSSIP
							}
							else
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_USE_NPC
							}
						}
						else
						{
							return OB_NPC_MOVE
						}
					}
				}
				else
				{
					if ${POI.SetNearestPOI[SELL]}
					{
						return OB_NPC_MOVE
					}
					else
					{
						This:Output[Not enough mapping data to SELL POI !]
						;no return here try other NPC
					}
				}
			}

			if ${POI.NeedRestock}
			{
				if ${Inventory.FreeSlots} > 0
				{
					if (${POI.Name.Equal[${Inventory.FoodMerch}]} || ${POI.Name.Equal[${Inventory.DrinkMerch}]} || ${POI.Name.Equal[${Inventory.AmmoMerch}]}) &&  !${POI.IsBlacklisted}
					{
						if ${POI.InUseRange}
						{
							if ${WoWScript[MerchantFrame:IsVisible()]}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_RESTOCK
							}
							else
							{
								if ${WoWScript[GetGossipOptions()](exists)}
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_MOREGOSSIP
								}
								else
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_USE_NPC
								}
							}
						}
						else
						{
							return OB_NPC_MOVE
						}
					}
					else
					{
						if ${Inventory.NeedRestock[1].Equal[Food]} && ${Inventory.FoodMerch.NotEqual[""]} && ${POI.SetPOINamed[${Inventory.FoodMerch}]}
						{
							return OB_NPC_MOVE
						}
						if ${Inventory.NeedRestock[1].Equal[Water]} && ${Inventory.DrinkMerch.NotEqual[""]} && ${POI.SetPOINamed[${Inventory.DrinkMerch}]}
						{
							return OB_NPC_MOVE
						}
						if (${Inventory.NeedRestock[1].Equal[Ammo]} || ${Inventory.NeedRestock[1].Equal[Arrow]}) && ${Inventory.AmmoMerch.NotEqual[""]} && ${POI.SetPOINamed[${Inventory.AmmoMerch}]}
						{
							return OB_NPC_MOVE
						}
						This:Output[Not enough mapping data to RESTOCK POI !]
						;no return here try other NPC
					}
				}
				else
				{
					POI.NeedRestock:Set[FALSE]
				}
			}

			if ${POI.NeedMailbox}
			{
				if ${POI.Type.Equal[MAILBOX]} && !${POI.IsBlacklisted}
				{
					if ${POI.InUseRange}
					{
						if ${WoWScript[MailFrame:IsVisible()]}
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_MULE
						}
						else
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_USE_NPC
						}
					}
					else
					{
						return OB_NPC_MOVE
					}
				}
				else
				{
					if ${POI.SetNearestPOI[MAILBOX]}
					{
						return OB_NPC_MOVE
					}
					else
					{
						This:Output[Not enough mapping data to MAILBOX POI !]
						;no return here try other NPC
						POI.NeedMailbox:Set[FALSE]
					}
				}
			}

			if ${POI.NeedClassTrainer}
			{
				if ${POI.Type.Equal[${Me.Class}_TRAINER]} && !${POI.IsBlacklisted}
				{
					if ${POI.InUseRange}
					{
						if ${This.VisibleFrame[ClassTrainerFrame]}
						{
							This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_TRAINER
						}
						else
						{
							if ${WoWScript[GetGossipOptions()](exists)}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_MOREGOSSIP
							}
							else
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_USE_NPC
							}
						}
					}
					else
					{
						if !${WoWScript["GetContainerItemCooldown(${Item[Hearthstone].Bag.Number}, ${Item[Hearthstone].Slot})", 2]}
					{
					Move -stop
					Item[Hearthstone]:Use
					Bot.ForcedStateWait:Set[${This.InTenths[120]}]
					}
					return OB_NPC_MOVE
					}
				}
				else
				{
					if ${POI.SetNearestPOI[${Me.Class}_TRAINER]}
					{
						return OB_NPC_MOVE
					}
					else
					{
						This:Output[Not enough mapping data to CLASSTRAINER, aborting trainer run !]
						;no return here try other NPC
						POI.NeedClassTrainer:Set[FALSE]
					}
				}
			}


			;THIS IS A SOURCE OF ROAM LAG - ATTEMPTED REWRITE
			if !${POI.IgnoreSkinningTrainer} && ${Toon.HasSkill[SKILL_SKINNING]}
			{
				if (${Toon.SkillLevel[SKILL_SKINNING]}==${Toon.SkillMaxLevel[SKILL_SKINNING]}) && (${Toon.SkillLevel[SKILL_SKINNING]}<${Bot.SkillLvlCap})
				{
					if ${POI.Type.Equal["Skinning_TRAINER"]} && !${POI.IsBlacklisted}
					{
						if ${POI.InUseRange}
						{
							if ${This.VisibleFrame[ClassTrainerFrame]}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_TRAINER
							}
							else
							{
								if ${WoWScript[GetGossipOptions()](exists)}
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_MOREGOSSIP
								}
								else
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_USE_NPC
								}
							}
						}
						else
						{
							return OB_NPC_MOVE
						}
					}
					else
					{
						if !${POI.Type.Equal["FLIGHTMASTER"]}
						{
							if ${POI.SetNearestPOI["Skinning_TRAINER",${Math.Calc[1 + ${Toon.SkillLevel[SKILL_SKINNING]}]}]}
							{
								return OB_NPC_MOVE
							}
							else
							{
								This:Output[Not enough mapping data to Skinning Trainer that can train me, aborting trainer run !]
								POI.IgnoreSkinningTrainer:Set[TRUE]
								;no return here try other NPC
							}
						}
					}
				}
			}

			if !${POI.IgnoreHerbalismTrainer} && ${Toon.HasSkill[SKILL_HERBALISM]}
			{
				if (${Toon.SkillLevel[SKILL_HERBALISM]}==${Toon.SkillMaxLevel[SKILL_HERBALISM]}) && (${Toon.SkillLevel[SKILL_HERBALISM]}<${Bot.SkillLvlCap})
				{
					if ${POI.Type.Equal["Herbalism_TRAINER"]} && !${POI.IsBlacklisted}
					{
						if ${POI.InUseRange}
						{
							if ${This.VisibleFrame[ClassTrainerFrame]}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_TRAINER
							}
							else
							{
								if ${WoWScript[GetGossipOptions()](exists)}
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_MOREGOSSIP
								}
								else
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_USE_NPC
								}
							}
						}
						else
						{
							return OB_NPC_MOVE
						}
					}
					else
					{
						if !${POI.Type.Equal["FLIGHTMASTER"]}
						{
							if ${POI.SetNearestPOI["Herbalism_TRAINER",${Math.Calc[1 + ${Toon.SkillLevel[SKILL_HERBALISM]}]}]}
							{
								return OB_NPC_MOVE
							}
							else
							{
								This:Output[Not enough mapping data to Herbalism Trainer that can train me, aborting trainer run !]
								POI.IgnoreHerbalismTrainer:Set[TRUE]
								;no return here try other NPC
							}
						}
					}
				}
			}

			if !${POI.IgnoreMiningTrainer} && ${Toon.HasSkill[SKILL_MINING]}
			{
				if (${Toon.SkillLevel[SKILL_MINING]}==${Toon.SkillMaxLevel[SKILL_MINING]}) && (${Toon.SkillLevel[SKILL_MINING]}<${Bot.SkillLvlCap})
				{
					if ${POI.Type.Equal["Mining_TRAINER"]} && !${POI.IsBlacklisted}
					{
						if ${POI.InUseRange}
						{
							if ${This.VisibleFrame[ClassTrainerFrame]}
							{
								This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
								return OB_TRAINER
							}
							else
							{
								if ${WoWScript[GetGossipOptions()](exists)}
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_MOREGOSSIP
								}
								else
								{
									This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
									return OB_USE_NPC
								}
							}
						}
						else
						{
							return OB_NPC_MOVE
						}
					}
					else
					{
						if !${POI.Type.Equal["FLIGHTMASTER"]}
						{
							if ${POI.SetNearestPOI["Mining_TRAINER",${Math.Calc[1 + ${Toon.SkillLevel[SKILL_MINING]}]}]}
							{
								return OB_NPC_MOVE
							}
							else
							{
								This:Output[Not enough mapping data to Mining Trainer that can train me, aborting trainer run !]
								POI.IgnoreMiningTrainer:Set[TRUE]
								;no return here try other NPC
							}
						}
					}
				}
			}
		}
		return OB_IDLE
	}

	method NPCPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_NPC_GETTING_READY
			Toon:Standup
			if ${Movement.Speed}
			{
				Navigator:ClearPath
				move -stop
			}
			break

			case OB_RESTOCK
			variable iterator iter
			Inventory.RestockList:GetIterator[iter]
			iter:First

			This:Debug["RESTOCK?: ${Inventory.NeedRestock}"]
			if !${Inventory.NeedRestock} || !${POI.Name.Equal[${Inventory.${Inventory.NeedRestock[1]}Merch}]}
			{
				WoWScript CloseMerchant()
				This:Output["Done Restocking here."]
				POI:Clear
				POI.NeedRestock:Set[FALSE]
				break
			}
			while ${iter.IsValid}
			{
				This:Debug["MAX: ${iter.Value.Max} STACK: ${Inventory.StackCount[${iter.Key}]} DIS: ${iter.Value.Disabled}"]
				if ${iter.Value.Max} > ${Inventory.StackCount[${iter.Key}]} && !${iter.Value.Disabled}
				{
					if ${Inventory.BuyItem[${iter.Key}]}
					{
						This:Debug["Buying ${iter.Key}"]
						This.NPCState_NPC_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.NPCState_Interact_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
						break
					}
					elseif ${LNavGroup[${iter.Value.myType}].Contains[${POI.Name}]}
					{
						iter.Value.Disable:Set[TRUE]
					}
				}
				iter:Next
			}
			break


			case OB_HEARTH_GETTING_READY
			Toon:Standup
			if ${Movement.Speed}
			{
				Navigator:ClearPath
				move -stop
			}
			break

			case OB_START_HEARTH
			Item[Hearthstone]:Use
			break

			case OB_NPC_MOVE
			Human.StopOnFollow_Override:Set[${This.InSeconds[300]}]
			if ${Mount.NeedMount}
			{
				Grind.CurrentGrind.CurrentHotspot:Set[1]
				Mount:Mount
				return
			}
			if ${POI.Distance} <= ${Mount.DismountDistance} && ${Mount.IsMounted}
			{
				Mount:Dismount
			}
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_TAKE_FLIGHT
			This:Output["Taking Flightpath to ${FlightPlan.FlightNode[${FlightPlan.DestinationFM}]}"]
			if ${WoWScript[TaxiFrame:IsVisible()]}
			{
				if ${FlightPlan.NeedRefresh}
				{
					FlightPlan:Refresh
					FlightPlan.NeedRefresh:Set[FALSE]
					return
				}
				if ${FlightPlan.NeedFlight}
				{
					if ${FlightPlan.GetNodeSlot[${FlightPlan.DestinationFM}]} > 0
					{
						WoWScript TakeTaxiNode(${FlightPlan.GetNodeSlot[${FlightPlan.DestinationFM}]})
						FlightPlan.NeedFlight:Set[FALSE]
						FlightPlan.DestinationFM:Set[NULL]
						FlightPlan.LastFlight:Set[${LavishScript.RunningTime}]
						return
					}
				}
			}
			break

			case OB_LEARN_FLIGHT
			if ${WoWScript[TaxiFrame:IsVisible()]}
			{
				if ${FlightPlan.NeedRefresh}
				{
					FlightPlan:Refresh
					FlightPlan.NeedRefresh:Set[FALSE]
					FlightPlan.LearnFlightMaster:Set[FALSE]
					FlightPlan.LearnFM:Set["0:0:0:0:0:0:0:0"]
					return
				}
			}
			break

			case OB_USE_NPC
			Mount:Dismount
			Toon:Standup
			Navigator:ClearPath
			move -stop
			POI:Use
			break

			case OB_LOGOUT
			if ${UIElement[chkErrorSoundOn@Config@Pages@openbot].Checked}
			{
				This:PlaySound["Stop"]
			}
			This:Debug["OB_LOGOUT, Have a good day"]
			Navigator:ClearPath
			move -stop
			WoWScript Logout()
			endscript openbot
			break

			case OB_MOREGOSSIP
			;TODO: use event GOSSIP_SHOW and title1, gossip1 = GetGossipOptions()
			;see http://www.wowwiki.com/API_GetGossipOptions
			variable int gcheck=1
			variable int copt=0
			while ${WoWScript[GetGossipOptions(),${gcheck}](exists)}
			{
				;This:Output[${WoWScript[GetGossipOptions(),${gcheck}]}]
				if ${WoWScript[GetGossipOptions(),${gcheck}].NotEqual["binder"]} && ${WoWScript[GetGossipOptions(),${gcheck}].NotEqual["gossip"]}
				{
					copt:Inc
				}
				if ${WoWScript[GetGossipOptions(),${gcheck}].Find["browse your goods"]}!=NULL || ${WoWScript[GetGossipOptions(),${gcheck}].Find["have for sale"]}!=NULL
				{
					This:Output["Selecting: ${gcheck} ${WoWScript[GetGossipOptions(),${gcheck}]}"]
					WoWScript SelectGossipOption(${copt})
					break
				}
				gcheck:Inc
			}
			WoWScript SelectGossipOption(1)
			break

			case OB_REPAIR
			WoWScript RepairAllItems()
			POI.NeedRepair:Set[FALSE]
			if ${Object[${Inventory.GetSlot[Sell]}](exists)}
			{
				POI.NeedSell:Set[TRUE]
			}
			break

			case OB_SELL
			if ${Object[${Inventory.GetSlot[Sell]}](exists)}
			{
				Object[${Inventory.GetSlot[Sell]}]:Use
			}
			else
			{
				WoWScript CloseMerchant()
				This:Output["Done Selling."]
				POI.NeedSell:Set[FALSE]
				if ${Object[${Inventory.GetSlot[Mule]}](exists)} && ${Me.Coinage} >= 30
				{
					POI.NeedMailbox:Set[TRUE]
				}
			}
			break

			case OB_TRAINER
			WoWScript SetTrainerServiceTypeFilter("available",1)
			WoWScript SetTrainerServiceTypeFilter("unavailable",0)
			WoWScript SetTrainerServiceTypeFilter("used",0)

			if ${WoWScript[GetNumTrainerServices()]}>0
			{
				if ${WoWScript[GetTrainerServiceCost(${WoWScript[GetTrainerSelectionIndex()]})]} <= ${Me.Coinage}
				{
					WoWScript BuyTrainerService(${WoWScript[GetTrainerSelectionIndex()]})
				}
				else
				{
					if ${POI.Type.Equal[${Me.Class}_TRAINER]}
					{
						POI.NeedClassTrainer:Set[FALSE]
						This:Output[Not enough money for ${Me.Class} Trainer, skipping Training !]
					}
					if ${POI.Type.Equal["Skinning_TRAINER"]}
					{
						POI.IgnoreSkinningTrainer:Set[TRUE]
						This:Output[Not enough money for Skinning Trainer, skipping Training !]
					}
					if ${POI.Type.Equal["Herbalism_TRAINER"]}
					{
						POI.IgnoreHerbalismTrainer:Set[TRUE]
						This:Output[Not enough money for Herbalism Trainer, skipping Training !]
					}
					if ${POI.Type.Equal["Mining_TRAINER"]}
					{
						POI.IgnoreMiningTrainer:Set[TRUE]
						This:Output[Not enough money for Mining Trainer, skipping Training !]
					}
				}
			}
			else
			{
				if ${POI.Type.Equal[${Me.Class}_TRAINER]}
				{
					POI.NeedClassTrainer:Set[FALSE]
				}
			}
			break

			case OB_MULE
			/*
			MultiMail posted in #openbot Author cubed
			 */
			if ${Object[${Inventory.GetSlot[Mule,"-notsoulbound"]}](exists)} && ${Me.Coinage} >= 30
			{
				variable index:string ItemIndex
				variable int i = 1
				variable guidlist itemList
				itemList:Search[-items,-inventory,-notsoulbound]
				for(i:Set[1];${i} <= ${itemList.Count};i:Inc)
				{
					if ${Inventory.isItem[Mule,${itemList.Object[${i}].Name}]}
					{
						ItemIndex:Insert[${itemList.GUID[${i}]}]
					}
				}

				variable int inThisMail = 0
				while ${ItemIndex.Get[1](exists)}
				{
					for(i:Set[1];${i} <= 12;i:Inc)
					{
						Item[${ItemIndex.Get[1]}]:PickUp
						WoWScript ClickSendMailItemButton(${i})
						if ${ItemIndex.Get[1](exists)}
						{
							inThisMail:Inc
						}
						ItemIndex:Remove[1]
						ItemIndex:Collapse
					}

					if ${Me.Coinage} >= ${Math.Calc[${inThisMail} * 30]}
					{
						WoWScript SendMail(\"${UIElement[tenMuleChar@Config@InvPages@Inventory@Pages@OpenBot].Text}\"\, \"Multiple Items\"\, \"\")
						inThisMail:Set[0]
					}
					else
					{
						This:Output["Error: Not enough money to automule the desired items!"]
						POI.NeedMailbox:Set[FALSE]
						return
					}
				}
			}
			else
			{
				POI.NeedMailbox:Set[FALSE]
			}
			break

			case OB_TRADESKILL_MAKE
			Tradeskills:MakeTradeSkill
			break

			case OB_TRADESKILL_BUY
			Tradeskills:BuyTradeSkill
			break

			case OB_TRADESKILL_MOVE
			Tradeskills:NeedTradePOI
			break

			case OB_TRADESKILL_WAIT
			This:Debug[Waiting in Tradeskill]
			break
		}
	}

	;----------
	;----- ITEM Sub State
	;----------
	member ITEMState()
	{
		if ${Inventory.NeedStackMotes}
		{
			return OB_ITEM_MOTE
		}
		if ${Inventory.NeedDestroy}
		{
			return OB_ITEM_DESTROY
		}
		if ${Inventory.NeedOpen}
		{
			This:Echo["We Need to open something"]
			return OB_ITEM_OPEN
		}
		if ${LavishScript.RunningTime} <= ${This.ITEMState_Equip_Wait_Until}
		{
			return OB_EQUIP_WAIT
		}
		if ${Autoequip.DismissBindPopUp}
		{
			This.ITEMState_Equip_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.ITEMState_Equip_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_EQUIP_WAIT
		}
		if ${Autoequip.NeedEQ} && !${Me.Equip[16].Name.Equal["OB_FISHING_POLE"]}
		{
			if ${Autoequip.EquipGear}
			{
				This.ITEMState_Equip_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.ITEMState_Equip_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
				return OB_EQUIP_WAIT
			}
			elseif ${Autoequip.EquipBag}
			{
				This.ITEMState_Equip_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.ITEMState_Equip_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
				return OB_EQUIP_WAIT
			}
			else
			{
				Autoequip.NeedEQ:Set[FALSE]
			}
		}
		return OB_IDLE
	}

	method ITEMPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_ITEM_DESTROY
			Inventory:Destroy
			break
			case OB_ITEM_OPEN
			This:Echo["we are trying to open"]
			Inventory:Open
			break
			case OB_ITEM_MOTE
			Inventory:StackMotes
			break
			case OB_EQUIP_WAIT
			break
		}
	}


	;----------
	;----- QUEST Sub State
	;----
	member QUESTState()
	{
		/* wait between brief wait between quest states */
		if ${LavishScript.RunningTime} <= ${This.QUESTstate_Wait_Until}
		{
			return OB_QUEST_WAIT
		}
		/* if not waiting, do */
		if ${Questgiver.ChooseReward}
		{
			This.QUESTstate_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.QUESTstate_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_QUEST_REWARD
		}
		/* need questgiver */
		if ${Questgiver.SetQuestGiverPOI}
		{
			Questgiver:ClearMerchantFrames
			if ${POI.InUseRange}
			{
				if !${Questgiver.GossipVisible}
				{
					This.QUESTstate_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.QUESTstate_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
					return OB_QUEST_NEEDGOSSIP
				}
				if ${Questgiver.NeedGossip}
				{
					This.QUESTstate_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.QUESTstate_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
					return OB_QUEST_GOSSIP
				}
				return OB_QUEST_CLOSEGOSSIP
			}
			else
			{
				return OB_QUEST_NEEDNPC
			}
		}
		/* an item begins a quest */
		if ${Questgiver.ItemStartQuest}
		{
			This.QUESTstate_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.QUESTstate_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_ITEM_BEGINSQUEST
		}
		return OB_IDLE
	}


	method QUESTPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_QUEST_WAIT
			break
			case OB_QUEST_REWARD
			Questgiver:GetReward
			break

			case OB_QUEST_NEEDOBJECT
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break
			case OB_QUEST_HARVEST
			POI:Use
			break
			case OB_QUEST_NEEDGOSSIP
			Target ${POI.GUID}
			POI:Use
			break
			case OB_QUEST_GOSSIP
			Questgiver:GossipPulse
			break
			case OB_QUEST_CLOSEGOSSIP
			if ${WoWScript[QuestFrame:IsVisible()]}
			{
				WoWScript "QuestFrame:Hide()"
			}
			break
			case OB_QUEST_NEEDNPC
			Target ${POI.GUID}
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break
			case OB_ITEM_BEGINSQUEST
			Questgiver:BeginItemQuest
			break
		}
	}


	;----------
	;----- ROAM Sub State
	;----------
	member ROAMState()
	{
		if !${Me.Dead} && !${Me.Ghost} && ${Mount.NeedMount}
		{
			return OB_MOUNT
		}

		if !${Me.Dead} && !${Me.Ghost} && ${POI.Distance} <= ${Mount.DismountDistance} && ${Mount.IsMounted}
		{
			return OB_DISMOUNT
		}

		if ${Me.Level} != ${Toon.Level}
		{
			return OB_LEVELUP
		}
		if ${UIElement[chkEnableQuest@Quest@HumanPages@Human@Pages@openbot].Checked}
		{
			if ${Quest.Complete}
			{
				return OB_ROAM_COMPLETE
			}

			if ${Quest.HasEvent}
			{
				return OB_ROAM_EVENT
			}
		}

		/* conditionals for moving to mob should be defined in Toon.MoveToMob */
		if ${Toon.MoveToMob} && !${Mount.IsMounted}
		{
			if ${POI.Type.Equal[MOB]} && ${POI.GUID.Equal[${Targeting.TargetCollection.Get[1]}]}
			{
				return OB_MOVETO_MOB
			}
			elseif ${POI.Set[${Object[${Targeting.TargetCollection.Get[1]}].X}:${Object[${Targeting.TargetCollection.Get[1]}].Y}:${Object[${Targeting.TargetCollection.Get[1]}].Z}:${Object[${Targeting.TargetCollection.Get[1]}].GUID}:${Object[${Targeting.TargetCollection.Get[1]}].Name}:MOB:FACTION_NEUTRAL:${Object[${Targeting.TargetCollection.Get[1]}].Level},FALSE]}
			{
				return OB_MOVETO_MOB
			}
		}

		;REWRITTEN TO REDUCE ROAM LAG
		variable bool canMine = FALSE
		variable bool canHerb = FALSE
		if ${Toon.HasSkill[Herbalism]} || ${Toon.HasSkill[Mining]}
		{
			if ${Toon.HasSkill[Herbalism]} && ${UIElement[chkRoamHerb@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				canHerb:Set[TRUE]
			}

			if ${Item[-inventory,"Mining Pick"](exists)} && ${Toon.HasSkill[Mining]} && ${UIElement[chkRoamMine@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				canMine:Set[TRUE]
			}
			if ${canHerb} && ${canMine}
			{
				if ${POI.SetNearestPOI[MINING,1,${Toon.SkillLevel[Mining]}]}
				{
					;If there is a Herb Node Nearer or same Distance then we prefer to roam there
					if ${POI.SetNearestPOI[HERBALISM,1,${Toon.SkillLevel[Herbalism]},${POI.Distance}]}
					{
						return OB_ROAM_TO_NODE
					}
					return OB_ROAM_TO_NODE
				}
				else
				{
					if ${POI.SetNearestPOI[HERBALISM,1,${Toon.SkillLevel[Herbalism]}]}
					{
						return OB_ROAM_TO_NODE
					}
				}
			}
			elseif ${canMine}
			{
				if ${POI.SetNearestPOI[MINING,1,${Toon.SkillLevel[Mining]}]}
				{
					return OB_ROAM_TO_NODE
				}
			}
			elseif ${canHerb}
			{
				if ${POI.SetNearestPOI[HERBALISM,1,${Toon.SkillLevel[Herbalism]}]}
				{
					return OB_ROAM_TO_NODE
				}
			}
		}
		if ${UIElement[chkEnableQuest@Quest@HumanPages@Human@Pages@openbot].Checked}
		{
			if ${Quest.ChangeLocation}
			{
				This:Debug[Changing Location for Questing]
			}

			if ${Quest.Explore}
			{
				return OB_ROAM_EXPLORE
			}
		}

		if ${Grind.ChangeLocation}
		{
			This:Debug[Changing Location]
		}

		/* only attempt to set a hotspot poi if poi is not current hotspot*/
		if ${POI.Name.NotEqual[${Grind.HotSpotName}]} || (${POI.X} != ${Grind.X} || ${POI.Y} != ${Grind.Y} || ${POI.Z} != ${Grind.Z})
		{
			This:Debug["Setting POI to ${Grind.HotSpotName}"]
			if !${POI.Set[${Grind.X}:${Grind.Y}:${Grind.Z}:${Grind.HotSpotName}:${Grind.HotSpotName}:HOTSPOT:FACTION_NEUTRAL:0]}
			{
				if ${Config.GetCheckbox[chkTakeFMToGrind]}
				{
					if ${FlightPlan.FlyToPoint[${Grind.X},${Grind.Y},${Grind.Z}]}
					{
						if ${FlightPlan.SetFlightPOI}
						{
							return OB_ROAMING
						}
					}
				}
				/* if we loop 25 times within 2 minutes, location is bad */
				if ${This.Location_Failed_Count:Inc} > 25 && ${This.Location_Failed_Timer} > ${LavishScript.RunningTime}
				{
					if ${UIElement[chkErrorSoundOn@Config@Pages@openbot].Checked}
					{
						This:PlaySound["Stop"]
					}
					This:Output["ERROR: LOCATION FAILED. NO CONNECTIONS TO ANY HOTSPOT. FORCING LOCATION CHANGE"]
					Grind:LoadBestLocationSet[TRUE]
					This.Location_Failed_Count:Set[0]
					This.Location_Failed_Timer:Set[0]
					return OB_IDLE
				}
				if ${This.Location_Failed_Timer} < ${LavishScript.RunningTime}
				{
					This.Location_Failed_Timer:Set[${This.Location_Failed_Timer}+120000]
				}
				/* first try iterating through hotspots */
				This:Output["Error: Not enough mapping data to ${Grind.HotSpotName}. Iterating to Next Hotspot"]
				Grind:NextHotspot
				return OB_IDLE
			}
		}

		if ${POI.Type.Equal[HOTSPOT]} && ${POI.Name.Token[1,"@"].Upper.Equal[FISHING]}
		{
			if ${Script[OB_FISHING_EXTENSION](exists)} &&  (${Item[-inventory,"OB_FISHING_POLE"](exists)} || ${Me.Equip[16].Name.Equal["OB_FISHING_POLE"]})
			{
				if ${POI.Distance} <= ${Navigator.GetPercision}
				{
					This:Output[Reached Fishing Hotspot start OB_FISHING_EXTENSION now.]
					This.LOOTState_Loot_Fishing_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Fishing_Timeout} * ${Bot.GlobalCooldown})]}]
				}
			}
			else
			{
				This:Output[Need OB_FISHING_EXTENSION loaded and OB_FISHING_POLE in Inventory to Fish ! Skipping Fishing Hotspot.]
				This:NextHotspot
			}
		}

		/* dont check POI distance for iterating Grind unless POI is Hotspot */
		if ${POI.Type.Equal[HOTSPOT]} && ${POI.Distance} <= ${Math.Calc[${Navigator.GetPercision}+${POI.RandomDistanceModifier}]} && ${POI.Name.Token[1,"@"].Upper.NotEqual[FISHING]}
		{
			This:Output[Reached Current Hotspot. Random switch distance was: ${POI.Distance}]
			This:NextHotspot
		}
		if ${POI.Type.Equal[HOTSPOT]}
		{
		return OB_ROAMING
		}
	}

	method ROAMPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_MOUNT
			Mount:Mount
			break

			case OB_DISMOUNT
			Mount:Dismount
			break

			case OB_LEVELUP
			This:Output[Gratz we Leveled up! New Level is ${Me.Level}.]
			This:Output[Checking Profile and doing Trainer run.]
			Toon.Level:Set[${Me.Level}]
			Targeting:MinMaxLvLs
			Grind:LoadBestLocationSet[FALSE]
			if ${Math.Calc[${Me.Level}%4]} == 0
			{
				POI.NeedClassTrainer:Set[TRUE]
			}
			break

			case OB_MOVETO_MOB
			Mount:Dismount
			Toon:NeedTarget
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_ROAMING
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break
		}
	}

	method NextHotspot()
	{
		if ${Grind.RandomizeHotSpots}
		{
			Grind:RandomHotSpot
			This:Output[Next Random HotSpot is ${Grind.HotSpotName}.]
		}
		else
		{
			Grind:NextHotspot
			This:Output[Next HotSpot is ${Grind.HotSpotName}.]
		}
		POI.RandomDistanceModifier:Set[${Math.Rand[10]}]
		This:Output[Next Distance Modifier is: ${POI.RandomDistanceModifier}]
	}

	method EndFishing()
	{
		if !${Script[OB_FISHING_EXTENSION].Paused}
		{
			Script[OB_FISHING_EXTENSION]:Pause
		}
		if ${Me.Equip[16].Name.Equal["OB_FISHING_POLE"]}
		{
			if ${Item[-inventory,"${MainHandBeforeFishing}"](exists)}
			{
				Item[-inventory,"${MainHandBeforeFishing}"]:Use
				MainHandBeforeFishing:Set[NULL]
			}
			if ${Item[-inventory,"${OffHandBeforeFishing}"](exists)}
			{
				Item[-inventory,"${OffHandBeforeFishing}"]:Use
				MainHandBeforeFishing:Set[NULL]
			}
		}
	}

	method StartFishing()
	{
		Navigator:FaceHeading[${Grind.Hd}]
		if !${Me.Equip[16].Name.Equal["OB_FISHING_POLE"]}
		{
			MainHandBeforeFishing:Set[${Me.Equip[16].Name}]
			OffHandBeforeFishing:Set[${Me.Equip[17].Name}]
			Item[-inventory,"OB_FISHING_POLE"]:Use
		}
		if ${Script[OB_FISHING_EXTENSION].Paused}
		{
			Script[OB_FISHING_EXTENSION]:Resume
		}
	}

	; ------ ASSIST MODE
	member ASSISTState()
	{
		if ${State.NeedAssist[${Target.GUID}]}
		{
			if ${State.HaveAssistPath[${Target.GUID}]}
			{
				if ${Target.Distance} < ${Toon.PullRange}
				{
					if ${Class.NeedPullBuff}
					{
						return OB_PULL_BUFF
					}
					else
					{
						return OB_PULL
					}
				}
				else
				{
					return OB_MOVETO_MOB
				}
			}
			else
			{
				This:Output[Need Path to Mob.]
			}
		}
		return OB_ASSIST_IDLE
	}

	method ASSISTPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_PULL
			Class:PullPulse
			break

			case OB_PULL_BUFF
			Class:PullBuffPulse
			break

			case OB_ASSIST_IDLE
			POI.myobjectstring:Set["0:0:0:0:0:0:0:0:0"]
			Navigator:ClearPath
			break

			case OB_MOVETO_MOB
			Navigator:MoveToMob[${Target.GUID}]
			break
		}
	}

	member NeedAssist(string MobGUID)
	{
		variable objectref TargetMob
		TargetMob:Set[${MobGUID}]

		if ${Mount.IsMounted}
		{
			return FALSE
		}

		if !${TargetMob(exists)} || ${TargetMob.Name.Equal[NULL]}
		{
			return FALSE
		}

		if (${MobGUID.Equal[${Me.GUID}]} || ${TargetMob.Dead})
		{
			return FALSE
		}
		if !${TargetMob.Attackable}
		{
			return FALSE
		}
		return TRUE
	}

	member HaveAssistPath(string GUID)
	{
		variable float mobDistance
		variable objectref theMob = ${GUID}
		variable int moveDirectly = ${Toon.PullRange}

		mobDistance:Set[${Math.Distance[${Me.X},${Me.Y},${Me.Z},${theMob.X},${theMob.Y},${theMob.Z}]}]
		if ${moveDirectly} < 40
		{
			moveDirectly:Set[40]
		}
		if ${mobDistance} < ${moveDirectly} && !${Me.IsPathObstructed[${theMob.X},${theMob.Y},${Math.Calc[${theMob.Z}+0.6]}]}
		{
			return TRUE
		}
		elseif ${Navigator.AvailablePath[${theMob.X},${theMob.Y},${theMob.Z}]}
		{
			return TRUE
		}
		return FALSE
	}

	member LOOT_ASSISTState()
	{
		if (${State.NeedAssist[${Target.GUID}]} && ${State.HaveAssistPath[${Target.GUID}]}) || ${Mount.IsMounted}
		{
			return OB_IDLE
		}
		return ${This.LOOTState}
	}

	method LOOT_ASSISTPulse()
	{
		This:LOOTPulse
	}

	member ManualOverride()
	{
		if ${WoWScript[IsMouseButtonDown("LeftButton")]} && ${WoWScript[IsMouseButtonDown("RightButton")]}
		{
			return TRUE
		}
		return FALSE
	}


	; ------ PARTY MODE
	; This is where we hook our party stuff to the normal OB states or rewrite the state for Party Mode if needed

	/* when we are dead -- no mechanics change -- it's all about getting back to our body baybe */
	member DEAD_PARTYState()
	{
		return ${This.DEADState}
	}
	method DEAD_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
		}
		This:DEADPulse
	}

	/* major changes to how this operates -- most party decisions regarding combat are made in this state */
	/* the basic principle is that flags are set based on group member weights in Party:Update */
	/* in combat -- these updates occur every state pulse -- out of combat, the occur in periodic CPU saving pulses */
	variable int LastPartySwitch = 0
	member TOON_PARTYState()
	{
		variable objectref theMob
		variable bool IsLead = ${Party.IsPartyLeader}
		variable bool IsAlone = ${Party.Alone}
		variable bool FightBack = FALSE

		Autoequip:NeedOrGreed
		if ${LavishScript.RunningTime} <= ${This.TOONState_General_Wait_Until}
		{
			return OB_TOON_WAIT
		}

		if ${Flee.NeedToRun} && ${IsAlone}
		{
			return OB_FLEE
		}

		if ${Me.InCombat} || (!${Party.KillTarget.Equal[NULL]} && ${Object[${Party.KillTarget}].Target(exists)})
		{
			Party:Update
			if !${IsAlone}
			{
				FightBack:Set[TRUE]
			}
			elseif !${Mount.IsMounted}
			{
				FightBack:Set[TRUE]
			}
			if (${Party.NeedHeal} || ${Party.NeedCure}) && ${Me.PctHPs} > 35
			{
				/* we need to make sure I stay alive first */
				FightBack:Set[FALSE]
			}
			if ${Party.NeedCrowdControl}
			{
				FightBack:Set[FALSE]
			}
		}

		if ${FightBack}
		{
			if !${Party.KillTarget.Equal[NULL]} && ${Object[${Party.KillTarget}].PctHPs} > 0 && (!${Toon.ValidTarget[${Target.GUID}]} || ${Math.Calc[${LavishScript.RunningTime}-${This.LastPartySwitch}]} > 5000)
			{
				if ${POI.GUID.NotEqual[${Object[${Party.KillTarget}].GUID}]}
				{
					Target ${Party.KillTarget}
					This.LastPartySwitch:Set[${LavishScript.RunningTime}]

					if !${POI.Set[${Object[${Party.KillTarget}].X}:${Object[${Party.KillTarget}].Y}:${Object[${Party.KillTarget}].Z}:${Object[${Party.KillTarget}].GUID}:${Object[${Party.KillTarget}].Name}:MOB:FACTION_NEUTRAL:${Object[${Party.KillTarget}].Level},TRUE]}
					{
						This:Debug[Error: Can not set POI to Target]
					}
				}
			}
			elseif ${Toon.ValidTarget[${Target.GUID}]} && ${Target.PctHPs} > 0
			{
				if ${POI.GUID.NotEqual[${Target.GUID}]}
				{
					if !${POI.Set[${Target.X}:${Target.Y}:${Target.Z}:${Target.GUID}:${Target.Name}:MOB:FACTION_NEUTRAL:${Target.Level},TRUE]}
					{
						This:Debug[Error: Can not set POI to Target]
					}
				}
			}
			elseif ${Me.InCombat} && ${Toon.ValidTarget[${Targeting.TargetCollection.Get[1]}]} && ${Object[${Targeting.TargetCollection.Get[1]}].PctHPs} > 0
			{
				Toon:NeedTarget
				if !${POI.Set[${Object[${Targeting.TargetCollection.Get[1]}].X}:${Object[${Targeting.TargetCollection.Get[1]}].Y}:${Object[${Targeting.TargetCollection.Get[1]}].Z}:${Object[${Targeting.TargetCollection.Get[1]}].GUID}:${Object[${Targeting.TargetCollection.Get[1]}].Name}:MOB:FACTION_NEUTRAL:${Object[${Targeting.TargetCollection.Get[1]}].Level},TRUE]}
				{
					This:Debug[Error: Can not set POI to AGGRO Target]
					Toon:NeedTarget
				}
			}

			/* then if we have a target, lets do combat */
			if ${Target(exists)}
			{
				if ${Class.NeedCombatBuff}
				{
					return OB_COMBAT_BUFF
				}
				else
				{
					return OB_COMBAT
				}
			}
			else
			{
				/* we have no target, so lets idle */
				if ${Class.NeedCombatIdle}
				{
					return OB_COMBAT_CLASS_IDLE
				}
				return OB_COMBAT_IDLE
			}
		}

		if ${Party.NeedHeal}
		{
			return OB_PARTYHEAL
		}

		if ${Party.NeedCrowdControl}
		{
			return OB_CROWDCONTROL
		}

		if ${Party.NeedCure}
		{
			return OB_PARTYCURE
		}

		if ${Class.NeedRest}
		{
			return OB_REST
		}

		if ${Party.NeedRez}
		{
			return OB_PARTYREZ
		}

		if ${Class.NeedBuff}
		{
			if !${Mount.IsMounted} && 0 < ${Toon.SafeSpotRange}
			{
				return OB_BUFF
			}
		}

		if ${Party.NeedBuff} && !${Mount.IsMounted}
		{
			return OB_PARTYBUFF
		}

		if ${IsAlone} && !${Mount.IsMounted}
		{
			if ${This.PullMobExists[1]} && ${Toon.SafeSpotRange} < 0
			{
				theMob:Set[${Targeting.TargetCollection.Get[1]}]
			}
		}
		elseif !${Party.KillTarget.Equal[NULL]}
		{
			theMob:Set[${Party.KillTarget}]
		}
		elseif ${IsLead} && !${Mount.IsMounted}
		{
			if ${Toon.PullableTarget}
			{
				theMob:Set[${Targeting.TargetCollection.Get[1]}]
			}
		}

		if ${theMob.GUID(exists)}
		{
			if ${POI.Set[${theMob.X}:${theMob.Y}:${theMob.Z}:${theMob.GUID}:${theMob.Name}:MOB:FACTION_NEUTRAL:${theMob.Level},FALSE]}
			{
				if ${theMob.Distance} > ${Toon.PullRange} && !${Me.Casting}
				{
					return OB_MOVETO_PULL
				}
				else
				{
					if ${Class.NeedPullBuff}
					{
						return OB_PULL_BUFF
					}
					else
					{
						return OB_PULL
					}
				}
			}
			else
			{
				This:Output["Error: Can not set POI to PULL Target"]
			}
		}
		if ${Toon.Casting}
		{
			return OB_CASTING
		}
		if ${LavishScript.RunningTime} <= ${This.TOONState_Casting_Wait_Until}
		{
			return OB_CASTING_WAIT
		}
		if ${LavishScript.RunningTime} <= ${This.TOONState_Flee_Wait_Until} || ${Math.Calc[${LavishScript.RunningTime}-${This.TOONState_Last_Flee_Time}]} < 1500
		{
			return OB_FLEE_WAIT
		}
		return OB_IDLE
	}

	/* just hooking the ones that are different */
	method TOON_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_PARTYHEAL
			Mount:Dismount
			Target ${Group.Member[${Party.HealUnit}].GUID}
			if !${Party.InRange[${Party.HealUnit},25]}
			{
				This:Output[HealUnit -- Moving within 25 yards.]
				Party:NavToUnit[${Party.HealUnit}]
				break
			}
			This:Output[Party Heal - ${Group.Member[${Party.HealUnit}].Name}]
			Toon:Stop
			Class:PartyHealPulse
			break
			case OB_PARTYCURE
			Mount:Dismount
			Target ${Group.Member[${Party.CureUnit}].GUID}
			if !${Party.InRange[${Party.CureUnit},25]}
			{
				This:Output[CureUnit -- Moving within 25 yards.]
				Party:NavToUnit[${Party.CureUnit}]
				break
			}
			This:Output[Party Cure - ${Group.Member[${Party.CureUnit}].Name}]
			Toon:Stop
			Class:PartyCurePulse
			break
			case OB_PARTYREZ
			Mount:Dismount
			Target ${Group.Member[${Party.RezUnit}].GUID}
			if !${Party.InRange[${Party.RezUnit},25]}
			{
				This:Output[RezUnit -- Moving within 25 yards.]
				Party:NavToUnit[${Party.RezUnit}]
				break
			}
			This:Output[Party Rez - ${Group.Member[${Party.RezUnit}].Name}]
			Toon:Stop
			Class:PartyRezPulse
			break
			case OB_PARTYBUFF
			Mount:Dismount
			Target ${Group.Member[${Party.BuffUnit}].GUID}
			if !${Party.InRange[${Party.BuffUnit},25]}
			{
				This:Output[BuffUnit -- Moving within 25 yards.]
				Party:NavToUnit[${Party.BuffUnit}]
				break
			}
			This:Output[Party Buff - ${Group.Member[${Party.BuffUnit}].Name}]
			Toon:Stop
			Class:PartyBuffPulse
			break
			case OB_CROWDCONTROL
			Mount:Dismount
			Target ${Party.CrowdControl}
			if ${Math.Distance[${Me.Location},${Object[${Party.CrowdControl}].Location}]} > 25
			{
				This:Output[Crowd Control -- Moving within 25 yards.]
				Navigator:MoveToMob[${Party.CrowdControl}]
				break
			}
			This:Output[Crowd Control  - ${Object[${Party.CrowdControl}].Name}]
			Toon:Stop
			Class:CrowdControlPulse
			break
			case OB_MOVETO_PULL
			Mount:Dismount
			Party:NeedTarget
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break
			case OB_PULL
			Navigator:ClearPath
			Party:NeedTarget
			Class:PullPulse
			break
		}
		This:TOONPulse
	}

	/* mechanics of NPC remain unchanged -- decision to visit NPC is toon specific rather than party specific */
	/* this means the party member will go repair and then come back to group in ROAM */
	member NPC_PARTYState()
	{
		return ${This.NPCState}
	}
	method NPC_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
		}
		This:NPCPulse
	}

	/* mechanics of autoequip and such remain unchanged */
	member ITEM_PARTYState()
	{
		return ${This.ITEMState}
	}
	member method ITEM_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
		}
		This:ITEMPulse
	}

	/* the same old loot stuff with a couple of extra checks against my party members POI */
	/* includes a broadcast using Uplink of POI when you are preparing to loot to ensure POI is current */
	/* uses Party.IgnoreLoot -- the intent is to prevent two party members from going after the same loot */
	member LOOT_PARTYState()
	{
		variable guidlist list
		variable int Index
		variable bool Found = FALSE
		variable int bltimer

		Autoequip:NeedOrGreed

		if ${Me(unit).Casting.Name.Token[1," "].Equal[Skinning]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_SKIN_CORPSE
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Herbalism]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_LOOT_HERB
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Mining]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_LOOT_ORE
		}
		if ${Me(unit).Casting.Name.Token[1," "].Equal[Opening]}
		{
			This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
			return OB_OPENING
		}

		if ${LavishScript.RunningTime} <= ${This.LOOTState_Loot_Wait_Until}
		{
			return OB_LOOT_WAIT
		}

		if ${LootWindow(exists)}
		{
			if ${LootWindow.Count} > 0 && (${Inventory.FreeSlots} > 0)
			{
				This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_After_Until_Timeout} * ${Bot.GlobalCooldown})]}]
				This.LOOTState_Skip_Scans:Set[0]
				return OB_LOOTALL
			}
			else
			{
				This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_After_Until_Timeout} * ${Bot.GlobalCooldown})]}]
				This.LOOTState_Skip_Scans:Set[0]
				return OB_CLOSE_LOOT
			}
		}

		if ${LavishScript.RunningTime} >= ${LOOTState_Skip_Scans}
		{
			This.LOOTState_Skip_Scans:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Skip_Scans_Timeout} * ${Bot.GlobalCooldown})]}]
			 if (${Inventory.FreeSlots} > 0) && ${UIElement[chkLoot@Config@InvPages@Inventory@Pages@openbot].Checked}
         		{
            			list:Clear
            			list:Search[-units,-dead,-nearest]
            			Index:Set[0]
				if ${list.Count} > 0
				{
					while ${list.GUID[${Index:Inc}](exists)} && !${Found}
					{
						if ${Unit[${list.GUID[${Index}]}].Lootable}
						{
							if ${POI.Set[${Unit[${list.GUID[${Index}]}].X}:${Unit[${list.GUID[${Index}]}].Y}:${Unit[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Unit[${list.GUID[${Index}]}].Name}:LOOT:FACTION_NEUTRAL:${Unit[${list.GUID[${Index}]}].Level}]}
							{
								Found:Set[TRUE]
							}
						}
						if ${Unit[${list.GUID[${Index}]}].Skinnable}
						{
							if ${Toon.CanSkinMob[${list.GUID[${Index}]}]}
							{
								if ${POI.Set[${Unit[${list.GUID[${Index}]}].X}:${Unit[${list.GUID[${Index}]}].Y}:${Unit[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Unit[${list.GUID[${Index}]}].Name}:SKILL_SKINNING:FACTION_NEUTRAL:${Unit[${list.GUID[${Index}]}].Level}]}
								{
									Found:Set[TRUE]
								}
							}
						}
					}
				}
			}
			if !${Found} && ${Toon.HasSkill[SKILL_HERBALISM]} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkGather@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects,-herb,-usable,-unlocked,-nearest]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${Toon.SkillLevel[Herbalism]} >= ${OBDB.GetLevel[${Object[${list.GUID[${Index}]}].Name}]}
					{
						if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:SKILL_HERBALISM:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
						{
							Found:Set[TRUE]
						}
					}
					else
					{
						This:Output[do Not want ${Object[${list.GUID[${Index}]}].Name} level to high.]
					}
				}
			}
			if !${Found} && ${Toon.HasSkill[SKILL_MINING]} && ${Item[-inventory,"Mining Pick"](exists)} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkGather@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects,-mine,-usable,-unlocked,-nearest]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${Toon.SkillLevel[Mining]} >= ${OBDB.GetLevel[${Object[${list.GUID[${Index}]}].Name}]}
					{
						if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:SKILL_MINING:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
						{
							Found:Set[TRUE]
						}
					}
					else
					{
						This:Output[do Not want ${Object[${list.GUID[${Index}]}].Name} level to high.]
					}
				}
			}
			/* quest objects */
			if !${Found} && (${Inventory.FreeSlots} > 0) && ${UIElement[chkHarvestQuests@Config@InvPages@Inventory@Pages@openbot].Checked}
			{
				list:Clear
				list:Search[-gameobjects, -nearest, -chest, -unlocked, -usable]
				Index:Set[0]
				while ${list.GUID[${Index:Inc}](exists)} && !${Found}
				{
					if ${POI.Set[${Object[${list.GUID[${Index}]}].X}:${Object[${list.GUID[${Index}]}].Y}:${Object[${list.GUID[${Index}]}].Z}:${list.GUID[${Index}]}:${Object[${list.GUID[${Index}]}].Name}:QUESTOBJECT:FACTION_NEUTRAL:${Object[${list.GUID[${Index}]}].Level}]}
					{
						Found:Set[TRUE]
					}
				}
			}
		}

		if ${POI.Type.Equal[LOOT]} || ${POI.Type.Equal[Skinning]}
		{
			/*
			if ${Party.IgnoreLoot[${POI.GUID}]}
			{
				This:Output["Party Looted: Skipping ${POI.Type} for ${POI.Name}"]
				POI:Clear
				WoWScript ClearTarget()
				This.LOOTState_Skip_Scans:Set[0]
				return OB_LOOT_WAIT
			}
			else
			{
			*/
				if ${POI.IsBlacklisted} || !${Object[${POI.GUID}](exists)}
				{
					POI:Clear
					This.LOOTState_Skip_Scans:Set[0]
					return OB_LOOT_WAIT
				}
				else
				{
					if ${POI.InUseRange}
					{
						if (${POI.Type.Equal[LOOT]} && !${Unit[${POI.GUID}].CanLoot})
						{
							POI:Clear
							This.LOOTState_Skip_Scans:Set[0]
							return OB_LOOT_WAIT
						}
						if ${Movement.Speed} || ${Toon.Sitting}
						{
							return OB_LOOT_GETTING_READY
						}
						else
						{
							Party.Uplink:Broadcast[POI,${POI.Type}]
							This.LOOTState_Loot_Wait_Until:Set[${Math.Calc[${LavishScript.RunningTime}+(${This.LOOTState_Loot_Wait_Until_Timeout} * ${Bot.GlobalCooldown})]}]
							return OB_USE_LOOT
						}
					}
					else
					{
						Party.Uplink:Broadcast[POI,${POI.Type}]
						return OB_LOOT_MOVE
					}
				}
			/*
			}
			*/
		}
		return OB_IDLE
	}

	/* the mechanics of looting dont change -- so just hook existing */
	method LOOT_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
		}
		This:LOOTPulse
	}

	/* quest mechanics don't change */
	member QUEST_PARTYState()
	{
		return ${This.QUESTState}
	}
	method QUEST_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
		}
		This:QUESTPulse
	}

	/* if you are the party leader -- roam is pretty much like normal */
	/* if you are not the party leader, your POI is the party leader or his destination in ROAM */
	/* combat, rez and buff decisions are all handled in Toon at a higher priority over Looting, etc. */
	member ROAM_PARTYState()
	{
		if !${Me.Dead} && !${Me.Ghost} && ${Mount.NeedMount}
		{
			return OB_MOUNT
		}

		if !${Me.Dead} && !${Me.Ghost} && ${POI.Distance} <= ${Mount.DismountDistance} && ${Mount.IsMounted}
		{
			return OB_DISMOUNT
		}

		if ${Me.Level} != ${Toon.Level}
		{
			return OB_LEVELUP
		}

		if ${Party.NeedRest}
		{
			return OB_PARTY_IDLE
		}

		/* anyone who is not the leader needs to follow around -- all combat decisions are now made in TOON */
		if  !${WoWScript[IsPartyLeader()]}
		{
			if ${POI.Type.Equal[GROUP]} && !${Party.InRange[${WoWScript[GetPartyLeaderIndex()]},50]}
			{
				return OB_FOLLOW_LEADER
			}
			if ${Party.InRange[${WoWScript[GetPartyLeaderIndex()]},50]}
			{
				return OB_FOLLOW_LEADER
			}
			if ${Party.SetPOI_ToUnit[${WoWScript[GetPartyLeaderIndex()]}]}
			{
				return OB_FOLLOW_LEADER
			}
			if ${Party.SetPOI_ToDestination[${WoWScript[GetPartyLeaderIndex()]}]}
			{
				return OB_FOLLOW_LEADER
			}
			return OB_PARTY_IDLE
		}
		return ${This.ROAMState}
	}

	method ROAM_PARTYPulse()
	{
		switch ${This.CurrentSubState}
		{
			case OB_FOLLOW_LEADER
			{
				if ${Mount.NeedMount}
				{
					Grind.CurrentGrind.CurrentHotspot:Set[1]
					Mount:Mount
					return
				}
				if ${POI.Distance} <= ${Mount.DismountDistance} && ${Mount.IsMounted}
				{
					Mount:Dismount
				}
				if ${POI.Distance} < ${Navigator.GetPercision}
				{
					POI.myobjectstring:Set["0:0:0:0:0:0:0:0:0"]
					POI.Current:Set[${This.myobjectstring.Token[4,:]}]
					Navigator:ClearPath
					Toon:Stop
					return
				}
				if ${Party.InRange[${WoWScript[GetPartyLeaderIndex()]},12]}
				{
					Toon:Stop
					return
				}
				if ${Party.InRange[${WoWScript[GetPartyLeaderIndex()]},50]}
				{
					Party:NavToUnit[${WoWScript[GetPartyLeaderIndex()]}]
					return
				}
				if !${Navigator.IsMovingToCurrentPOI}
				{
					Navigator:MoveToCurrentPOI
					return
				}
			}
			case OB_PARTY_IDLE
			{
				if !${Party.NeedRest}
				{
					This:Output["Cant find a connection to Leader or Destination"]
				}
				else
				{
					This:Output["Waiting on resting party member."]
				}
				return
			}
		}
		This:ROAMPulse
	}


	; ------ BG MODE

	member BGState()
	{
		if ${BG.BGMode}
		{
			if ${BG.isINBG}
			{
				if ${BG.ShouldLeaveBG} || ${BG.BGOver}
				{
					return OB_LEAVEBG
				}

				if ${BG.GatesCheck}
				{
					; In Battleground and gates are open
					; Time to Fight
					if ${BG.NeedBGPulse}
					{
						return OB_INBG
					}
					else
					{
						; Most of the Time we want to use the roam Pulse
						return ${This.BG_ROAMState}
					}
				}

				; Were in a BG But Gates are not Open
				; O well Check for Prep Buffing and stuff
				if ${Class.HookBGPrebuff}
				{
					if ${Class.NeedBGPrebuff}
					{
						return OB_BGPREBUFF
					}
				}

				; Standard Wait for Start
				return OB_BGWAITSTART
			}

			if ${BG.NeedQue}
			{
				; Need to Queue
				return OB_BGNEEDQUEUE
			}

			; We arent in a BG and were are not queued. Must be waiting
			return OB_BGWAITINGQ
		}
		else
		{
			return OB_IDLE
		}
	}
	member BG_ROAMState()
	{
		variable bool	tmpGaurding		= ${BG.Gaurding}
		BG.Gaurding:Set[FALSE]

		if !${Me.Dead} && !${Me.Ghost} && ${Mount.NeedMount}
		{
			return OB_MOUNT
		}

		if !${Me.Dead} && !${Me.Ghost} && ${POI.Distance} <= ${Mount.DismountDistance} && ${Mount.IsMounted}
		{
			Mount:Dismount
		}
		/* conditionals for moving to mob should be defined in Toon.MoveToMob */
		if ${Toon.MoveToMob}
		{
			if ${POI.Type.Equal[MOB]} && ${POI.GUID.Equal[${Targeting.TargetCollection.Get[1]}]}
			{
				return OB_MOVETO_MOB
			}
			elseif ${POI.Set[${Object[${Targeting.TargetCollection.Get[1]}].X}:${Object[${Targeting.TargetCollection.Get[1]}].Y}:${Object[${Targeting.TargetCollection.Get[1]}].Z}:${Object[${Targeting.TargetCollection.Get[1]}].GUID}:${Object[${Targeting.TargetCollection.Get[1]}].Name}:MOB:FACTION_NEUTRAL:${Object[${Targeting.TargetCollection.Get[1]}].Level},FALSE]}
			{
				return OB_MOVETO_MOB
			}
		}

		/* only attempt to set a hotspot poi if poi is not current hotspot*/
		if ${POI.Name.NotEqual[${Grind.HotSpotName}]} || (${POI.X} != ${Grind.X} || ${POI.Y} != ${Grind.Y} || ${POI.Z} != ${Grind.Z})
		{
			This:Debug["Setting POI to ${Grind.HotSpotName}"]
			if !${POI.Set[${Grind.X}:${Grind.Y}:${Grind.Z}:${Grind.HotSpotName}:${Grind.HotSpotName}:HOTSPOT:FACTION_NEUTRAL:0]}
			{
				/* if we loop 25 times within 2 minutes, location is bad */
				if ${This.Location_Failed_Count:Inc} > 25 && ${This.Location_Failed_Timer} > ${LavishScript.RunningTime}
				{
					if ${UIElement[chkErrorSoundOn@Config@Pages@openbot].Checked}
					{
						This:PlaySound["Stop"]
					}
					This:Output["ERROR: LOCATION FAILED. NO CONNECTIONS TO ANY HOTSPOT. GAURDING"]
					This.Location_Failed_Count:Set[0]
					This.Location_Failed_Timer:Set[0]
					; Go back to being idle for now until we get a workaround
					;return OB_BG_STUCK
					return OB_IDLE
				}
				if ${This.Location_Failed_Timer} < ${LavishScript.RunningTime}
				{
					This.Location_Failed_Timer:Set[${This.Location_Failed_Timer}+120000]
				}
				/* first try iterating through hotspots */
				This:Output["Error: Not enough mapping data to ${Grind.HotSpotName}. FOOL. MAP MORE"]
				BG:MissingMapData

				return OB_ROAMING
			}
		}

		/* dont check POI distance for iterating Grind unless POI is Hotspot */
		if ${POI.Type.Equal[HOTSPOT]} && ${POI.Distance} <= ${Math.Calc[${Navigator.GetPercision}+${POI.RandomDistanceModifier}]} && ${POI.Name.Token[1,"@"].Upper.NotEqual[FISHING]}
		{
			BG.Guarding:Set[TRUE]
			; Set Gaurd here
			if ${tmpGaurding}
			{
				This:Output[Reached Current Hotspot. Gaurding]
			}
			if ${Class.HookBGGuard}
			{
				if ${Class.NeedBGGuard}
				{
					return OB_BG_CLASSGUARD
				}
			}
			return OB_BG_GAURDING
		}
		return OB_ROAMING
	}
	method BGPulse()
	{
		; Update our Very Powerfull Gui <-- HA!
		BG:UpdateGUI

		; Check if were leader. Dont want to be
		BG:ChkBGLeader

		; Check if we can join a higher priority BG while in another
		BG:CanJoinNextBG

		switch ${This.CurrentSubState}
		{
			case OB_LEAVEBG
			BG:LeaveBG
			break

			case OB_INBG
			BG:InBGPulse
			break

			case OB_BGNEEDQUEUE
			if !${Navigator.IsMovingToCurrentPOI}
			{
				BG:JoinBG
			}
			break

			case OB_BGPREBUFF
			Class:BGPrebuffPulse
			break

			case OB_BGWAITINGQ
			BG:QueueWait
			break

			case OB_BGWAITSTART
			BG:IdleTime
			break

			case OB_MOUNT
			Mount:Mount
			break

			case OB_MOVETO_MOB
			Mount:Dismount
			Toon:NeedTarget
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_ROAMING
			if !${Navigator.IsMovingToCurrentPOI}
			{
				Navigator:MoveToCurrentPOI
			}
			break

			case OB_BG_GAURDING
			BG:BGGaurd
			break

			case OB_BG_STUCK

			break

			case OB_BG_CLASSGUARD
			Class:BGGuardPulse
			break
		}
		return
	}
}