objectdef oElevator
{
	variable objectref Current
	variable string GUID
	variable string Name
	variable float X
	variable float Y 
	variable float TZ 
	variable float BZ 
	variable float TEX
	variable float TEY
	variable float TEZ
	variable float BEX
	variable float BEY
	variable float BEZ
	
	variable float PERCISION = 1.5

	variable float getoutZ = 0
	variable float relativespeed = 0
	variable float olddistance = 1000
	variable float currentdistance = 1000
	variable bool EntryNavigated = FALSE
	variable bool active = FALSE
	
	method Initialize(string GUID, string Name, float X, float Y, float TZ, float BZ, float TEX, float TEY, float TEZ, float BEX, float BEY, float BEZ)
	{
		This.Current:Set[${GUID}]
		This.GUID:Set[${GUID}]
		This.Name:Set[${Name}]
		This.X:Set[${X}]
		This.Y:Set[${Y}]
		This.TZ:Set[${TZ}]
		This.BZ:Set[${BZ}]
		This.TEX:Set[${TEX}]
		This.TEY:Set[${TEY}]
		This.TEZ:Set[${TEZ}]
		This.BEX:Set[${BEX}]
		This.BEY:Set[${BEY}]
		This.BEZ:Set[${BEZ}]
		This.getoutZ:Set[0]
		This:Update
	}
	
	member GetPercision()
	{
		return ${This.PERCISION}
	}
	
	member AlmostSame(float a, float b)
	{
		variable float d = ${Math.Calc[${a}- ${b}]}
		if ${d} < 0.1 && ${d} > -0.1
		{
			return TRUE
		}
		else
		{
			return FALSE
		}
	} 
	
	method Update()
	{
		This.currentdistance:Set[${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.X},${This.Y},${Me.Z}]}]
		if ${This.currentdistance} != ${This.olddistance}
		{
			This.relativespeed:Set[${Math.Calc[(${This.currentdistance} - ${This.olddistance}) * 0.5 + ${This.relativespeed} * 0.5]}]
			This.olddistance:Set[${This.currentdistance}]
		}
	}
	
	method Pulse()
	{
		This:Update
		This.active:Set[TRUE]
		if ${This.getoutZ} == 0
		{
			if ${Navigator.OpenNavPath.Get[1](exists)}
			{
				if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.BEX},${This.BEY},${This.BEZ}]} < 10 && ${This.relativespeed} < 0
				{
					if ${This.AlmostSame[${Current.Z}, ${This.BZ}]} && ${This.EntryNavigated}
					{
						if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.X},${This.Y},${Me.Z}]} > ${This.GetPercision}
						{
							ClickMoveToLoc ${This.X} ${This.Y} ${Me.Z}
							;Navigator:FaceXYZ[${This.X},${This.Y},${Me.Z}]
							;Navigator:MoveForward
							echo Running to Elevator Bottom Plattform
						}
						else
						{
							move -stop
							This.getoutZ:Set[${This.TZ}]
							echo Arrived at Elevator Bottom Plattform
						}
					}
					else
					{
						if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.BEX},${This.BEY},${This.BEZ}]} > ${This.GetPercision}
						{
							ClickMoveToLoc ${This.BEX} ${This.BEY} ${This.BEZ}
							;Navigator:FaceXYZ[${This.BEX},${This.BEY},${This.BEZ}]
							;Navigator:MoveForward
							echo Running to Elevator Bottom Entry
						}
						else
						{
							if !${This.AlmostSame[${Current.Z}, ${This.BZ}]}
							{
								move -stop
							}
							echo Arrived at Elevator Bottom Entry
							This.EntryNavigated:Set[TRUE]
						}
					}
				}
				else
				{
					if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.TEX},${This.TEY},${This.TEZ}]} < 10 && ${This.relativespeed} < 0
					{
						if ${This.AlmostSame[${Current.Z}, ${This.TZ}]} && ${This.EntryNavigated}
						{
							if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.X},${This.Y},${Me.Z}]} > ${This.GetPercision}
							{
								ClickMoveToLoc ${This.X} ${This.Y} ${Me.Z}
								;Navigator:FaceXYZ[${This.X},${This.Y},${Me.Z}]
								;Navigator:MoveForward
								echo Running to Elevator Top Plattform
							}
							else
							{
								move -stop
								This.getoutZ:Set[${This.BZ}]
								echo Arrived at Elevator Top Plattform
							}
						}
						else
						{
							if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.TEX},${This.TEY},${This.TEZ}]} > ${This.GetPercision}
							{
								ClickMoveToLoc ${This.TEX} ${This.TEY} ${This.TEZ}
								;Navigator:FaceXYZ[${This.TEX},${This.TEY},${This.TEZ}]
								;Navigator:MoveForward
								echo Running to Elevator Top Entry
							}
							else
							{
								if !${This.AlmostSame[${Current.Z}, ${This.TZ}]} 
								{
									move -stop
								}
								echo Arrived at Elevator Top Entry
								This.EntryNavigated:Set[TRUE]
							}
						}
					}
					else
					{
						This.active:Set[FALSE]
					}
				}						
			}
			else
			{
				This.active:Set[FALSE]
			}
		}
		else
		{
			if ${This.AlmostSame[${Current.Z}, ${This.getoutZ}]}
			{
				if ${This.AlmostSame[${Current.Z}, ${This.TZ}]}
				{
					if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.TEX},${This.TEY},${This.TEZ}]} > ${This.GetPercision}
					{
						ClickMoveToLoc ${This.TEX} ${This.TEY} ${This.TEZ}
						;Navigator:FaceXYZ[${This.TEX},${This.TEY},${This.TEZ}]
						;Navigator:MoveForward
						echo Running to Elevator Top Exit
					}
					else
					{
						Navigator:ClearPath
						echo Arrived at Elevator Top Exit
						This.active:Set[FALSE]
						This.getoutZ:Set[0]
						This.EntryNavigated:Set[FALSE]
					}
				}
				else
				{
					if ${This.AlmostSame[${Current.Z}, ${This.BZ}]} 
					{
						if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.BEX},${This.BEY},${This.BEZ}]} > ${This.GetPercision}
						{
							ClickMoveToLoc ${This.BEX} ${This.BEY} ${This.BEY}
							;Navigator:FaceXYZ[${This.BEX},${This.BEY},${This.BEY}]
							;Navigator:MoveForward
							echo Running to Elevator Top Exit
						}
						else
						{
							Navigator:ClearPath
							echo Arrived at Elevator Bottom Exit
							This.active:Set[FALSE]
							This.getoutZ:Set[0]
							This.EntryNavigated:Set[FALSE]
						}
					}
					else
					{
						move -stop
						echo The thing that should Not be, we are caged in the elevator
					}
				}
			}
			else
			{
				move -stop
				Navigator:ClearPath
				echo Driving in Elevator
			}
		}
	}
}

objectdef oOpenNavPath
{
	variable point3f Location
	variable int Method

	method Initialize(float X, float Y, float Z, int MoveType)
	{
		This.Location.X:Set[${X}]
		This.Location.Y:Set[${Y}]
		This.Location.Z:Set[${Z}]
		This.Method:Set[${MoveType}]
	}
}

objectdef oNavigator inherits oBase
{
	variable index:oOpenNavPath OpenNavPath
	variable index:oElevator Elevator
	variable point3f NavDestination
	variable int StuckTime = ${LavishScript.RunningTime}
	variable float PERCISION = 1.5
	variable bool StartMove = FALSE
	variable bool StuckJump = FALSE
	variable int TotalStuck = 0
	variable int IPOSTUCK = 0
	variable int SKIPNAV = 0
	variable bool ForceRes = FALSE
	variable int ResSpot = 0
	variable bool FRTimerStarted = FALSE
	variable int ForceResTimer = ${LavishScript.RunningTime}
	variable string vCurrentDestination = ""
	variable int degrees
	variable int yards
	variable point3f BestPoint
	variable float BestPointDistance
	variable string POIStr = ""
	variable oStuck GlobalStuck
	variable int SumStuck = 0
	variable point3f BestRezLoc = ${Me.Location}
	variable float BestRezLoc_SafetyMargin = 0
	
	variable int NAV_Wait_Until = 0
	variable int NAV_Wait_Until_Timeout = 10

	variable bool NeedDismount = FALSE
	
	member CurrentDestination = ${vCurrentDestination}

	method Initialize()
	{
		Navigator.NavDestination.X:Set[0]
		Navigator.NavDestination.Y:Set[0]
		Navigator.NavDestination.Z:Set[0]
		degrees:Set[15]
		yards:Set[10]
		
		LavishSettings:AddSet[Elevator]
		LavishSettings[Elevator]:Import["config/elevator.xml"]
		LavishSettings[Elevator]:AddSet[Elevator]
		LavishSettings[Elevator].FindSet[Elevator]:AddSetting[TEST,1]
	}

	method Shutdown()
	{
		LavishSettings[Elevator]:Export["config/elevator.xml"]
	}
	
	method TransportMapped(string GUID, float X, float Y, float TZ, float BZ, float TEX, float TEY, float TEZ, float BEX, float BEY, float BEZ)
	{
		variable objectref o=${GUID}
		
		LavishSettings[Elevator].FindSet[Elevator]:AddSet["${o.Name}@${X}~${Y}"]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[Name,${o.Name}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[X,${X}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[Y,${Y}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[TZ,${TZ}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[BZ,${BZ}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[TEX,${TEX}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[TEY,${TEY}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[TEZ,${TEZ}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[BEX,${BEX}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[BEY,${BEY}]
		LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${X}~${Y}"]:AddSetting[BEZ,${BEZ}]
						
		This:Output[Transport mapped and saved: ${o.Name}@${X}~${Y}]
		This:Output[X: ${X}]
		This:Output[Y: ${Y}]
		This:Output[TZ: ${TZ}]
		This:Output[BZ: ${BZ}]
		This:Output[TEX: ${TEX}]
		This:Output[TEY: ${TEY}]
		This:Output[TEZ: ${TEZ}]
		This:Output[BEX: ${BEX}]
		This:Output[BEY: ${BEY}]
		This:Output[BEZ: ${BEZ}]
	
		This:TransportAdded[${GUID}]
	}
	
	method TransportAdded(string GUID)
	{
		variable objectref o=${GUID}
		if ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[Name](exists)}
		{
			variable int Index = 0
			variable bool FOUND = FALSE
			while !${FOUND} && ${This.Elevator.Get[${Index:Inc}](exists)}
			{
				if ${This.Elevator.Get[${Index}].Name.Equal[${o.Name}]} && ${This.Elevator.Get[${Index}].X} == ${o.X} && ${This.Elevator.Get[${Index}].Y} == ${o.Y}
				{
					echo Outdated Transport removed: ${This.Elevator.Get[${Index}].Name} ${This.Elevator.Get[${Index}].GUID}
					Navigator.Elevator:Remove[${Index}]
					Navigator.Elevator:Collapse
					FOUND:Set[TRUE]
				}
			}
			echo Valid mapped Transport recognized and added: ${o.Name} ${o.GUID}
			This.Elevator:Insert[${o.GUID}, ${o.Name}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[X]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[Y]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[TZ]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[BZ]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[TEX]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[TEY]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[TEZ]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[BEX]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[BEY]}, ${LavishSettings[Elevator].FindSet[Elevator].FindSet["${o.Name}@${o.X}~${o.Y}"].FindSetting[BEZ]}]
		}
	}
	
	method SetPercision(int NUM)
	{
		This:Output["Setting Navigation Percision to ${NUM}"]
		PERCISION:Set[${NUM}]
	}

	member GetPercision()
	{
		return ${This.PERCISION}
	}
	method ClearPath()
	{
		Navigator.NavDestination.X:Set[0]
		Navigator.NavDestination.Y:Set[0]
		Navigator.NavDestination.Z:Set[0]
		OpenNavPath:Collapse
		if ${OpenNavPath.Get[1](exists)}
		{
			do
			{
				OpenNavPath:Remove[1]
				OpenNavPath:Collapse
			}
			while ${OpenNavPath.Get[1](exists)}
		}
		This.POIStr:Set[""]
		This.StartMove:Set[FALSE]
	}

	member AvailablePath(float X,float Y,float Z)
	{
		variable greynavpath PathHops
		variable int Index = 0
		
		if ${X}==0 && ${Y}==0 && ${Z}==0
		{
			return FALSE
		}
		
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${X},${Y},${Z}]} < 40 && !${Me.IsPathObstructed[${X},${Y},${Z}]}
		{
			if !${Mapper.Topography.IsSteep[${Me.X},${Me.Y},${Me.Z},${X},${Y},${Z}]}
			{
			return TRUE
			}
		}
		PathHops:Clear
		GreyNav:CalculatePath[${Map.ID}, ${Me.X}, ${Me.Y}, ${Me.Z}, ${X}, ${Y}, ${Z}, PathHops]
		if ${PathHops.Count} > 0
		{
			return TRUE
		}
		else
		{
			return FALSE
		}
	}

	/* used as part of flight path nav */
	member PointsConnect(float toX, float toY, float toZ, float fromX, float fromY, float fromZ)
	{
		variable astarpathfinder PathFinder
		variable lnavpath Path
		variable lnavregionref ToRegion
		variable lnavregionref ZoneRegion
		variable lnavregionref DestZoneRegion
		variable lnavregionref DestinationRegion
		
		if (${toX}==0 && ${toY}==0 && ${toZ}==0) || (${fromX}==0 && ${fromY}==0 && ${fromZ}==0) 
		{
			return FALSE
		}
		
		Path:Clear
		ZoneRegion:SetRegion[${LavishNav.FindRegion[${Navigator.BestZone[${toX},${toY},${Math.Calc[${toZ}+1]}]}].FQN}]
		DestZoneRegion:SetRegion[${LavishNav.FindRegion[${Navigator.BestZone[${fromX},${fromY},${Math.Calc[${fromZ}+1]}]}].FQN}]
		ToRegion:SetRegion[${DestZoneRegion.BestContainer[${toX},${toY},${Math.Calc[${toZ}+1]}].ID}]
		DestinationRegion:SetRegion[${DestZoneRegion.BestContainer[${fromX},${fromY},${Math.Calc[${fromZ}+1]}].ID}]
		PathFinder:SelectPath[${ToRegion.FQN},${DestinationRegion.FQN},Path]
		if ${Path.Hops}
		{
			return TRUE
		}
		else
		{
			return FALSE
		}
	}	
	
	method MoveTo(float X, float Y, float Z)
	{
		;why are we running somewhere if we are right there?
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${X},${Y},${Z}]} < ${This.GetPercision}
		{
			return
		}
	}

	method MoveToLocQ(float X, float Y, float Z,string DestName = "")
	{
		This.vCurrentDestination:Set[${DestName}]
		This:MoveToLoc[${X},${Y},${Z}]
	}

	method MoveToCurrentPOI()
	{
		POI:RefreshXYZ
		This:MoveToLoc[${POI.X},${POI.Y},${POI.Z}]
		This.POIStr:Set[${POI.Str}]
	}

	member IsMovingToCurrentPOI()
	{
		if ${This.POIStr.Equal[${POI.Str}]}
		{
			if ${Movement.Speed}
			{
				return TRUE
			}
		}
		return FALSE
	}

	/* we use MinMelee instead of percision - also allows for spamming the calls*/
	method MoveToMob(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}]}]		
		Navigator:FaceXYZ[${theMob.X},${theMob.Y},${theMob.Z}]

		if ${moveDirectly} < 40
		{
			moveDirectly:Set[40]
		}
		
		if ${mobDistance} < ${Toon.MinMelee}
		{
			Navigator:ClearPath
			if ${Movement.Speed}
			{
				move -stop
			}
			return
		}
			
		if ${mobDistance} < ${moveDirectly} && !${Me.IsPathObstructed[${theMob.X},${theMob.Y},${Math.Calc[${theMob.Z}+0.6]}]}
		{
			Navigator:MoveForward
			return
		}
		elseif !${Navigator.MovingToPoint[${theMob.X},${theMob.Y},${theMob.Z}]} 
		{
			Navigator:MoveToLoc[${theMob.X},${theMob.Y},${theMob.Z}]
		}		
	}
	
	/* useful for preventing excess MoveToLoc calls */
	member MovingToPoint(float X, float Y, float Z)
	{
		variable int count = 0
		if ${Movement.Speed}
		{
			if ${Navigator.OpenNavPath.Get[1](exists)}
			{		
				do
				{
					count:Inc
				}
				while ${Navigator.OpenNavPath.Get[${Math.Calc[${count}+1]}](exists)}			
				if ${Navigator.OpenNavPath.Get[${count}].Location.X}==${X} && ${Navigator.OpenNavPath.Get[${count}].Location.Y}==${Y} && ${Navigator.OpenNavPath.Get[${count}].Location.Z}==${Z}
				{
					return TRUE
				}
			}
		}
		return FALSE
	}	
	
	method MoveToLoc(float X, float Y, float Z, int OVERRIDE=0)
	{
		variable greynavpath PathHops
		variable int count = 0
		variable int Index = 0
		variable point3f RecoveryHop

		if ${X}==0 && ${Y}==0 && ${Z}==0
		{
			; No reason to run to NOTHING
			return
		}

		; If we are already Percision from it why bother moving?
		; Changed... Default Percision is slightly greater then USE distance
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${X},${Y},${Z}]}<${This.GetPercision} && ${POI.Type.Equal[HOTSPOT]}
		{
			This:Output["Already here: Not moving"]
			POI:RefreshXYZ
			Navigator:ClearPath
			move -stop
			Grind:NextHotspot
			return
		}
		; Added. Check for POIs that we are probably wanting to use
		; This is to help eliminate issues between client, server information disconnects. such as using an NPC
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${X},${Y},${Z}]}< 2
		{
			This:Output["Already here: Not moving"]
			POI:RefreshXYZ
			Navigator:ClearPath
			move -stop
			return
		}
		
		;Checks to see if it would be faster to teleport
		if ${Teleport.Closer[${X},${Y},${Z}]}
		{
			Teleport:PortToLoc
			return
		}
		
		;If we already have a Path make sure it is a new one
		if ${Navigator.OpenNavPath.Get[1](exists)}
		{		
			do
			{
				count:Inc
			}
			while ${Navigator.OpenNavPath.Get[${Math.Calc[${count}+1]}](exists)}
			
			if ${Math.Distance[${Navigator.OpenNavPath.Get[${count}].Location.X}, ${X}]} < 0.25 && ${Math.Distance[${Navigator.OpenNavPath.Get[${count}].Location.Y}, ${Y}]} < 0.25 && ${Math.Distance[${Navigator.OpenNavPath.Get[${count}].Location.Z}, ${Z}]} < 1.0
			{
				This:Output["ERROR: Calling again to same destination! Aborting"]
				return
			}
		}

		Navigator:ClearPath

		This.StartMove:Set[TRUE]
		This:Debug["Clearing #3"]
		This.StuckTime:Set[${LavishScript.RunningTime}]

		if ${OVERRIDE}!=0
		{
			This:Output["NAV OVERRIDING: Using PATH!"]
		}
		{
			PathHops:Clear

			GreyNav:CalculatePath[${Map.ID}, ${Me.X}, ${Me.Y}, ${Me.Z}, ${X}, ${Y}, ${Z}, PathHops]

			if ${PathHops.Count} > 0
			{
				do
				{
					;echo Adding ${PathHops.Hop[${Index}].X}, ${PathHops.Hop[${Index}].Y}, ${PathHops.Hop[${Index}].Z}
					This.OpenNavPath:Insert[${PathHops.Hop[${Index}].X}, ${PathHops.Hop[${Index}].Y}, ${PathHops.Hop[${Index}].Z}, 0]
				}
				while ${Index:Inc} < ${PathHops.Count}
				Navigator.NavDestination.X:Set[${X}]
				Navigator.NavDestination.Y:Set[${Y}]
				Navigator.NavDestination.Z:Set[${Z}]
			}
			else
			{
				; We didnt get a path run to the next closest point and try from there
				This:Output["Greynav failure, we have stepped outside the mesh!"]
				POI:Clear

				RecoveryHop.X:Set[0]
				RecoveryHop.Y:Set[0]
				RecoveryHop.Z:Set[0]
				GreyNav:GetNearestValidXYZ[${Map.ID}, ${Me.X}, ${Me.Y}, ${Me.Z}, RecoveryHop]

				if ${RecoveryHop.X} == 0 && ${RecoveryHop.Y} == 0 && ${RecoveryHop.Z} == 0
				{
					This:Output["Couldn't find nearest valid point, now we're really screwed!"]
					move -stop
				}
				elseif ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${RecoveryHop.X},${RecoveryHop.Y},${RecoveryHop.Z}]} > 40 || ${Me.IsPathObstructed[${RecoveryHop.X},${RecoveryHop.Y},${RecoveryHop.Z}]}
				{
					This:Output["Nearest valid point is obstructed, now we're really screwed!"]
					move -stop
				}
				else
				{
					This:Output["Attempting recovery hop to location: ${RecoveryHop}"]

					Navigator.NavDestination.X:Set[${RecoveryHop.X}]
					Navigator.NavDestination.Y:Set[${RecoveryHop.Y}]
					Navigator.NavDestination.Z:Set[${RecoveryHop.Z}]
				}

			
			}
		}
	}

	member BestZone(float X, float Y, float Z)
	{
		;${LavishNav.BestContainer[${Me.Location}].Type}
		variable string Continent
		variable int INDEX_Continent
		variable string Zone
		variable int INDEX_Zone
		variable lnavregionref ZoneRegion
		variable lnavregionref DestRegion

		;Add in a default Intance as a catch all for any zone we dont know about
		ZoneRegion:SetRegion[${LavishNav.FindRegion[Instance].FQN}]
		
		variable iterator InstanceIterator
		; Save Instance Files
		
		LavishSettings[Instances]:GetSettingIterator[InstanceIterator]
		if ${InstanceIterator:First(exists)}
		{
			do
			{
				if ${LavishNav.FindRegion[Instance].FindRegion[${InstanceIterator.Key}](exists)}
				{
					if !${LavishNav.FindRegion[Instance].FindRegion[${InstanceIterator.Key}].BestContainer[${X},${Y},${Z}].Type.Equal[Universe]}
					{
						return ${InstanceIterator.Key}
					}
				}	
				
			}
			while ${InstanceIterator:Next(exists)}
		}
		
		INDEX_Continent:Set[1]
		do
		{
			Continent:Set[${WoWScript[GetMapContinents(),${INDEX_Continent}]}]
			INDEX_Zone:Set[1]
			do
			{
				Zone:Set[${WoWScript[GetMapZones(${INDEX_Continent}),${INDEX_Zone}]}]
				ZoneRegion:SetRegion[${LavishNav.FindRegion[${Zone}].FQN}]
				if !${ZoneRegion.BestContainer[${X},${Y},${Z}].Type.Equal[Universe]}
				{
					return ${Zone}
				}
				INDEX_Zone:Inc
			}
			while ${WoWScript[GetMapZones(${INDEX_Continent}),${INDEX_Zone}](exists)}
			INDEX_Continent:Inc
		}
		while ${WoWScript[GetMapContinents(),${INDEX_Continent}](exists)}
		return "Instance"
	}

	;----------
	;----- Obstacle avoidance
	;----------	
	
	/* if we are moving and in the same spot for more than 4 seconds, then normal IPO and Stuck Check failed */
	variable int LastGlobalStuck = ${LavishScript.RunningTime}
	method GlobalUnstuck()
	{
		if ${Movement.Stuck_IgnoreJumps}
		{
			This.LastGlobalStuck:Set[${LavishScript.RunningTime}]
			if ${GlobalStuck.Elapsed} > 6.4
			{
				GlobalStuck:HouseOfPain
			}
		}
		elseif ${Math.Calc[${LavishScript.RunningTime}-${This.LastGlobalStuck}]} > 15000
		{
			POI.StuckCount:Set[0]	
			GlobalStuck:ResetStart
		}
	}		
	
	member IsStuck(int TEMP=1)
	{
		variable float Xstagea
		variable float Xstageb
		variable float Xstagec
		variable float Ystagea
		variable float Ystageb
		variable float Ystagec
		variable float X2stagea
		variable float X2stageb
		variable float X2stagec
		variable float Y2stagea
		variable float Y2stageb
		variable float Y2stagec
		variable float X3stagea
		variable float X3stageb
		variable float X3stagec
		variable float Y3stagea
		variable float Y3stageb
		variable float Y3stagec
		variable float HeadingTemp
		variable float HeadingTemp2
		variable int StuckCheck

		/* 5 yards */
		Xstagea:Set[]
		Xstageb:Set[]
		Xstagec:Set[${Math.Calc[${Me.X}+${Math.Calc[3*${Math.Cos[${Me.Heading}]}]}]}]

		Ystagea:Set[${Math.Sin[${Me.Heading}]}]
		Ystageb:Set[${Math.Calc[5*${Math.Sin[${Me.Heading}]}]}]
		Ystagec:Set[${Math.Calc[${Me.Y}-${Math.Calc[5*${Math.Sin[${Me.Heading}]}]}]}]

		/*      LEFT     */
		HeadingTemp2:Set[${Math.Calc[${Me.Heading}-90]}]
		if ${HeadingTemp2} < 0
		{
			HeadingTemp:Set[${Math.Calc[${HeadingTemp2} + 360]}]
		}
		else
		{
			HeadingTemp:Set[${HeadingTemp2}]
		}


		X2stagea:Set[${Math.Cos[${HeadingTemp}]}]
		X2stageb:Set[${Math.Calc[2*${X2stagea}]}]
		X2stagec:Set[${Math.Calc[${Xstagec}+${X2stageb}]}]

		Y2stagea:Set[${Math.Sin[${HeadingTemp}]}]
		Y2stageb:Set[${Math.Calc[2*${Y2stagea}]}]
		Y2stagec:Set[${Math.Calc[${Ystagec}-${Y2stageb}]}]

		/*       Right      */
		HeadingTemp2:Set[${Math.Calc[${Me.Heading}+90]}]
		if ${HeadingTemp2} > 360
		{
			HeadingTemp:Set[${Math.Calc[${HeadingTemp2} - 360]}]
		}
		else
		{
			HeadingTemp:Set[${HeadingTemp2}]
		}

		X3stagea:Set[${Math.Cos[${HeadingTemp}]}]
		X3stageb:Set[${Math.Calc[2*${X3stagea}]}]
		X3stagec:Set[${Math.Calc[${Xstagec}+${X3stageb}]}]

		Y3stagea:Set[${Math.Sin[${HeadingTemp}]}]
		Y3stageb:Set[${Math.Calc[2*${Y3stagea}]}]
		Y3stagec:Set[${Math.Calc[${Ystagec}-${Y3stageb}]}]



		StuckCheck:Set[0]
		if ${Me.IsPathObstructed[${Xstagec},${Ystagec},${Math.Calc[${Me.Z} + 1]},10]}
		{
			;Collision straight ahead of us
			StuckCheck:Inc
		}

		if ${Me.IsPathObstructed[${X2stagec},${Y2stagec},${Math.Calc[${Me.Z} + 1]},10,${Me.X},${Me.Y},${Math.Calc[${Me.Z} + 1]}]}
		{
			;Collision slightly to the left of us
			StuckCheck:Inc[2]
		}

		if ${Me.IsPathObstructed[${X3stagec},${Y3stagec},${Math.Calc[${Me.Z} + 1]},10,${Me.X},${Me.Y},${Math.Calc[${Me.Z} + 1]}]}
		{
			;Collision slightly to the right of us
			StuckCheck:Inc[4]
		}

		return ${StuckCheck}
	}

	method AvoidObstacle()
	{
		variable int count = 0
		
		This:Output["Stuck!"]
		This.TotalStuck:Inc
		This.SumStuck:Inc

		; If we are stuck lets try jumping first
		if !${This.StuckJump}
		{
			This.StuckJump:Set[TRUE]
			wowpress JUMP
			This.StartMove:Set[FALSE]
			return
		}
		else
		{
			This:Output["We should be doing some hoho magic shit here"]
			This:Output["STUCK: Adding Weight to next hop!"]
			;Recalculate path after reweighting
			do
			{
				count:Inc
			}
			while ${Navigator.OpenNavPath.Get[${Math.Calc[${count}+1]}](exists)}
			
			This:Output["STUCK: Recalculating Path to ${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}"]
			Navigator:ClearPath
			This:MoveToLoc[${Navigator.OpenNavPath.Get[${count}].Location.X},${Navigator.OpenNavPath.Get[${count}].Location.Y},${Navigator.OpenNavPath.Get[${count}].Location.Z},1]
			;Yaxa's hoho magic shit
			;This:FaceXYZ[${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}]
			;Move Forward 500
			;This:MoveTo[${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}]

		}
		; We tried jumping and are still stuck try something else
	}

	method AddWeight(float SrcX, float SrcY, float SrcZ, float DestX, float DestY, float DestZ, int Weight=10)
	{
		variable astarpathfinder PathFinder
		variable lnavpath Path
		variable lnavregionref CurrentRegion
		variable lnavregionref ZoneRegion
		variable lnavregionref DestZoneRegion
		variable lnavregionref DestinationRegion
		;variable index:lnavregionref SurroundingRegions

		if ${SrcX}==0 && ${SrcY}==0 && ${SrcZ}==0
		{
			This:Debug["Attempt to add weight to path SRC Invalid"]
			return
		}

		if ${DestX}==0 && ${DestY}==0 && ${DestZ}==0
		{
			This:Debug["Attempt to add weight to path DEST Invalid"]
			return
		}

		; Make sure we are starting with a fresh path
		Path:Clear

		ZoneRegion:SetRegion[${LNavRegion[${Mapper.ZoneText}].FQN}]
		DestZoneRegion:SetRegion[${LavishNav.FindRegion[${This.BestZone[${DestX},${DestY},${Math.Calc[${DestZ}+1]}]}].FQN}]

		CurrentRegion:SetRegion[${ZoneRegion.BestContainer[${SrcX},${SrcY},${SrcZ}].ID}]

		DestinationRegion:SetRegion[${DestZoneRegion.BestContainer[${DestX},${DestY},${Math.Calc[${DestZ}+1]}].ID}]

		if ${CurrentRegion.ID}==${DestinationRegion.ID}
		{
			This:Debug["ERROR: Attempt to weight path SRC/DEST Region are the same!"]
			return
		}

		PathFinder:SelectPath[${CurrentRegion.FQN},${DestinationRegion.FQN},Path]

		if ${Path.Hops}
		{
			Path.Connection[1]:SetDistance[${Math.Calc[${Path.Connection[1].Distance}+${Weight}]}]
			This:Output["Weighted ${Path.Connection[1]} to now be ${Path.Connection[1].Distance}"]
			return
		}
		else
		{
			; We didnt get a path run to the next closest point and try from there
			This:Output["ERROR: Cant not find path to weight, Not enough Mapping data! ${X},${Y},${Z}"]
			This:Debug["From: ${CurrentRegion.FQN} to ${DestinationRegion.FQN}"]
		}
	}

	method Pulse()
	{

		;Only do every nth frame (CPU Saver)
		if ${SKIPNAV} < 1
		{
			SKIPNAV:Inc
			return
		}
		SKIPNAV:Set[0]
		
		variable int Index = 0
		variable bool TempNeedDismount = FALSE
		while ${Navigator.Elevator.Get[${Index:Inc}](exists)}
		{
			if !${This.Elevator.Get[${Index}].Current.Name(exists)}
			{
				echo Removing invalid Transport: ${This.Elevator.Get[${Index}].Name} ${This.Elevator.Get[${Index}].GUID}
				Navigator.Elevator:Remove[${Index}]
				Navigator.Elevator:Collapse
			}
			else
			{
				Navigator.Elevator.Get[${Index}]:Pulse
				if ${Navigator.Elevator.Get[${Index}].currentdistance} < 50 
				{
					Mount:Dismount
					TempNeedDismount:Set[TRUE]
				}
				if ${Navigator.Elevator.Get[${Index}].active}
				{
					return
				}
			}
		}
		This.NeedDismount:Set[${TempNeedDismount}]

		if ${OpenNavPath.Get[1](exists)}
		{
			IPOSTUCK:Inc
			if ${IPOSTUCK}>5 && !${ISXWoW.Facing}
			{
				IPOSTUCK:Set[1]
				switch ${This.IsStuck}
				{
					case 0
						;This:Output["All Clear"]
					break
					case 1
						This:Output["Ahead"]
						wowpress JUMP
						if ${Math.Rand[100]}>50
						{
							move right 100
						}
						else
						{
							move left 100
						}
					break
					case 2
						This:Output["Left"]
						move right 100
					break
					case 3
						This:Output["Left and Ahead"]
						move right 100
					break
					case 4
						This:Output["Right"]
						move left 100
					break
					case 5
						This:Output["Ahead and Right"]
						move left 100
					break
					case 6
						This:Output["Left and Right"]
					break
					case 7
						This:Output["All Parts"]
					break
				}
			}					
			
			if ${Math.Calc[${LavishScript.RunningTime}-${This.StuckTime}]}>28000
			{
				This:AvoidObstacle
				This.StuckTime:Set[${LavishScript.RunningTime}]
			}
			
			if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}]} < ${This.GetPercision}
			{
				OpenNavPath:Remove[1]
				OpenNavPath:Collapse
				This.StartMove:Set[FALSE]
				
				if !${OpenNavPath.Get[1](exists)}
				{
					if ${Movement.Speed} 
					{
						move -stop
					}
					This.POIStr:Set[""]
					return
				}
	
				;If we have 2 hops and next hop is < 10 and we can get to the 2nd hop just go there
				if ${Navigator.OpenNavPath.Get[2](exists)} && ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}]} < 10
				{
					if !${Me.IsPathObstructed[${Navigator.OpenNavPath.Get[2].Location.X},${Navigator.OpenNavPath.Get[2].Location.Y},${Navigator.OpenNavPath.Get[2].Location.Z}]}
					{
						OpenNavPath:Remove[1]
						OpenNavPath:Collapse
					}
				}
			}

			if !${StartMove}
			{
				This.StartMove:Set[TRUE]
				This.StuckTime:Set[${LavishScript.RunningTime}]
			}
			This.TotalStuck:Set[0]
			ClickMoveToLoc ${Navigator.OpenNavPath.Get[1].Location.X} ${Navigator.OpenNavPath.Get[1].Location.Y} ${Navigator.OpenNavPath.Get[1].Location.Z}
			;This:FaceXYZ[${Navigator.OpenNavPath.Get[1].Location.X},${Navigator.OpenNavPath.Get[1].Location.Y},${Navigator.OpenNavPath.Get[1].Location.Z}]
			;This:MoveForward
			Bot:Update_Status["Running"]
		}
	}

	;----------
	;----- Safe Spot originated by Plecks
	;----------
	
	member SafeToRes()
	{
		if ${Math.Distance[${Me.Location},${Me.Corpse}]} > 40
		{
			return FALSE
		}
		if !${This.PointIsSafe[${Me.Location}]} && !${ForceRes}
		{
			if !${FRTimerStarted}
			{
				ForceResTimer:Set[${LavishScript.RunningTime}]
				FRTimerStarted:Set[TRUE]
			}
			if ${Math.Calc[${LavishScript.RunningTime} - ${ForceResTimer}]} > 30000
			{
				FRTimerStarted:Set[FALSE]
				ForceRes:Set[TRUE]
			}
 			This:Output[Cant res: bad guy too close.  Force Rez in ${Int[${Math.Calc[(30000-(${LavishScript.RunningTime} - ${ForceResTimer}))/1000]}]} seconds.]
			return FALSE
		}
		if ${ForceRes}
		{
			This:Output[KAMIKAZEE!!! RESURRECTION FORCED]
		}
		This:Output[We can res here]
		Navigator:ClearPath
		move -stop
		return TRUE
	}
	
	member FindSafeSpot()
	{	
		variable point3f point
		variable float MobDistance		
		variable int i
		variable int j
		
		if ${Math.Distance[${This.BestRezLoc.X},${This.BestRezLoc.Y},${This.BestRezLoc.Z},${Me.Corpse.X},${Me.Corpse.Y},${Me.Corpse.Z}]} < ${maxyds}
		{
			if ${Navigator.AvailablePath[${This.BestRezLoc}]} && ${This.PointIsSafe[${This.BestRezLoc}]}
			{
			return ${This.BestRezLoc}
			}
		}
		This.BestRezLoc:Set[${Me.Corpse}]
		This.BestRezLoc_SafetyMargin:Set[0]
		
		for (i:Set[0] ; ${i} < 360 ; i:Inc[${degrees}])
		{
			for (j:Set[0]; ${j} < 40 ; j:Inc[${yards}])
			{
				point:Set[${Math.Calc[${Me.Corpse.X} + (${j} * ${Math.Cos[${i}]})]},${Math.Calc[${Me.Corpse.Y} - (${j} * ${Math.Sin[${i}]})]},${Me.Corpse.Z}]
				MobDistance:Set[${Math.Distance[${point},${This.NearestMob[${point}]}]}]
				if ${MobDistance} > ${This.BestRezLoc_SafetyMargin} && !${Me.IsPathObstructed[${point}]}
				{
					This.BestRezLoc:Set[${point}]
					This.BestRezLoc_SafetyMargin:Set[${MobDistance}]
				}
			}
		}
		return ${This.BestRezLoc}
	}

	member PointIsSafe(float X, float Y, float Z)
	{	
		variable guidlist MobList
		variable int SearchRadius = 20
		if ${Targeting.TargetCollection.Get[1](exists)}
		{
			SearchRadius:Inc[${Object[${Targeting.TargetCollection.Get[1]}].Level} - ${Me.Level}]			
		}
		MobList:Search[-units, -nearest, -alive,-hostile, -range 0-${SearchRadius}, -origin,${X},${Y},${Z}]
		if ${MobList.Count} > 0
		{
			return FALSE
		}
		return TRUE
	}

	member NearestMob(float X, float Y, float Z)
	{
		variable objectref theMob
		variable guidlist MobList
		theMob:Set[${Unit[-nearest, -alive,-hostile, -origin,${X},${Y},${Z}].GUID}]
		
		if ${theMob.Location(exists)}
		{
			return ${theMob.Location}
		}
		return "0,0,0"
	}
	
	;----------
	;----- Movement Functions
	;----------

	method FaceXYZ(float X, float Y, float Z)
	{
		if ${X}==0 && ${Y}==0 && ${Z}==0
		{
			; No reason to face NOTHING
			This:Debug["Error in FaceXYZ: Call to 0,0,0"]
			return
		}
		if !${ISXWoW.Facing}
		{
			if ${Math.Abs[${Me.Heading}-${Me.HeadingTo[${X},${Y}]}]} > 10
			{
				This:Debug["FaceXYZ: Facing ${X},${Y},${Z}"]
				Face -fast ${X} ${Y}
			}
		}
	}

	/* used anywhere? */
	member NeedFace(int X, int Y, int Z)
	{
		if ${Math.Abs[${Me.Heading}-${Me.HeadingTo[${X},${Y}]}]} > 10
		{
			return TRUE
		}
		return FALSE
	}	
	
	/* replacement to DegreesCCW */
	member Flip(float theHeading)
	{
		theHeading:Dec[180]
		if ${theHeading} < 0
		{
			theHeading:Inc[360]
		}
		return ${theHeading}
	}	
	
	method FaceHeading(float hd)
	{
		if !${ISXWoW.Facing}
		{
			if ${Math.Abs[${Me.Heading}-${hd}]} > 10
			{
				This:Debug["FaceHeading: Facing ${hd}"]
				Face -heading ${hd}
			}
		}
	}
	
	method MoveStop()
	{
		if ${Movement.Speed}
		{
			move -stop
		}
	}
	
	/* ensures we move forward */
	method MoveForward()
	{
		if ${Movement.Backward}
		{
			move -stop backward
		}	
		if !${Movement.Speed} || !${Movement.Forward}
		{
			move -hold forward
		}	
	}
	
	/* ensures we move backward */
	method MoveBackward(int howLong=1000)
	{
		if ${Movement.Forward}
		{
			move -stop forward
		}	
		if !${Movement.Speed} || !${Movement.Backward}
		{
			move backward ${howLong}
		}		
	}	
	
	;----------
	;----- Intersecting Paths
	;----------
	
	/* returns true if I am facing the POI within maxDegrees degrees */
	member FacingPOI(float maxDegrees=45)
	{
		if ${This.IntersectsPath[${Me.Heading.Degrees},${Me.HeadingTo[${POI.X},${POI.Y}]},${maxDegrees}]}
		{
			return TRUE
		}
		return FALSE
	}	

	/* returns true if heading toX, toY intesects my heading to hotspot */
	member IntersectsGrind(float toX, float toY, float maxDegrees=45)
	{
		if ${This.IntersectsPathXY[${Grind.X},${Grind.Y},${toX},${toY},${maxDegrees}]}
		{
			return TRUE
		}				
		return FALSE
	}

	/* returns true if heading toX, toY intersects my heading to pathX, pathY */	
	member IntersectsPathXY(float pathX, float pathY, float toX, float toY, maxDegrees=45)
	{
		if ${This.IntersectsPath[${Me.HeadingTo[${pathX},${pathY}]},${Me.HeadingTo[${toX},${toY}]},${maxDegrees}]}
		{
			return TRUE
		}
		return FALSE	
	}
			
	/* returns true if toHeading is within maxDegrees of pathHeading */
	member IntersectsPath(float pathHeading, float toHeading, float maxDegrees=45)
	{
		variable float maxLeft = ${Math.Calc[${pathHeading} + ${maxDegrees}]}
		variable float maxRight = ${Math.Calc[${pathHeading} - ${maxDegrees}]}
		
		if ${toX} == 0 && ${toY} == 0
		{
			/* no coords */
			return TRUE
		}	
		/* max sure our min and max fir within 0 to 360 */
		if ${maxLeft} > 360
		{
			maxLeft:Set[${maxLeft}-360]
		}
		if ${maxRight} < 0
		{
			maxRight:Set[${maxRight}+360]
		}
		
		/* Left is greater than Right, which is to be expected - checking target heading */
		if (${maxLeft} > ${maxRight}) && (${${toHeading}}<=${maxLeft} && ${${toHeading}}>=${maxRight})
		{
			return TRUE
		}
		/* Left is less than Right, which is when things get tricky */
		if (${maxLeft} < ${maxRight}) && ((${${toHeading}} <= ${maxLeft} && ${${toHeading}} >= 0)||(${${toHeading}} >= ${maxRight} && ${${toHeading}} <= 360))
		{
			return TRUE
		}
		return FALSE
	}	
}

objectdef oStuck inherits oBase
{
	variable point3f LastLocation
	variable int NextCheck
	variable int Frequency = 10
	variable int StartTime = 0
	variable float MinDistance = 5	
	variable int LastStartTime = ${LavishScript.RunningTime}
	
	method Initialize()
	{
		This.LastLocation:Set[${Me.X},${Me.Y},${Me.Z}]
		This.NextCheck:Set[${LavishScript.RunningTime}]
	}

	member Elapsed()
	{
		variable float seconds	= 0
		if ${This.Check}
		{
			/* use the old start time if stuck within the last 15 seconds */
			if ${This.LastStartTime} < ${This.StartTime} && ${Math.Calc[(${This.StartTime}-${This.LastStartTime})/1000].Round} < 20
			{
				This:Debug["Last Stuck was within last 15 seconds, reset elapsed time to that value"]
				This.StartTime:Set[${This.LastStartTime}]
			}
			elseif ${This.LastStartTime} < ${This.StartTime}
			{
				This.JumpJump:Set[0]
			}
			This.LastStartTime:Set[${This.StartTime}]		
			
			if ${This.StartTime} == 0
			{
				return ${seconds}
			}		
			seconds:Set[${Math.Calc[(${LavishScript.RunningTime}-${This.StartTime})/1000].Deci}]		
			This:Debug["We have been stuck for ${seconds} seconds."]
		}
		return ${seconds}
	}
	
	member Check()
	{
		if ${This.NextCheck} < ${LavishScript.RunningTime}
		{
			if ${This.Moved}
			{
				This:Update
				return FALSE
			}
			This:MarkStart 	/* marks the start time we got stuck */			
			return TRUE
		}
		if ${This.Moved}
		{
			This:Update
		}
		return FALSE
	}
	
	member Moved()
	{
		if ${Math.Distance[${Me.X},${Me.Y},${Me.Z},${This.LastLocation.X},${This.LastLocation.Y},${This.LastLocation.Z}]} > ${This.MinDistance}
		{
			return TRUE
		}	
		return FALSE
	}	
	
	method Update()
	{
		This:ResetStart
		This.LastLocation:Set[${Me.X},${Me.Y},${Me.Z}]
		This.NextCheck:Set[${This.InMilliseconds[${This.Frequency}]}]
		return
	}
	
	method MarkStart()
	{
		if ${This.StartTime}==0
		{
			/* subtract frequency to get real start since we dont record start until after we have been stuck for at least frequency */
			This.StartTime:Set[${LavishScript.RunningTime}-${Math.Calc[10*${Frequency}]}	]	
		}
	}
	
	method ResetStart()
	{
		This.StartTime:Set[0]
	}
	
	/* jump around!  jump around!  jump up! jump up! and get down! */
	variable int JumpJump = 0
	variable int LastHoP = ${LavishScript.RunningTime}
	method HouseOfPain()
	{
		variable string direction = "left"
		variable int random = ${Math.Rand[100]}
				
		if ${LavishScript.RunningTime} < ${This.LastHoP}
		{
			return
		}
		
		/* direction random */
		if ${random} < 50
		{
			direction:Set["right"]
		}
		
		This.JumpJump:Inc	
		switch ${This.JumpJump}
		{
			case 6
			{
				This.LastHoP:Set[${This.InTenths[15]}]	
				POI.StuckCount:Inc
				This:Output["HouseOfPain: StuckCount ${POI.StuckCount}"]					
			}
			case 5
			{
				move ${direction} 1800
				This.LastHoP:Set[${This.InTenths[18]}]		
				This:Output["We have been stuck ${Int[${Math.Calc[(${LavishScript.RunningTime}-${This.StartTime})/1000].Round}]} seconds."]				
				This:Output["HouseOfPain: Move ${direction} 1800"]	
				break				
			}			
			case 4
			{
				move -stop	
				move ${direction} 3000 backward 800	
				This.LastHoP:Set[${This.InTenths[30]}]		
				Bot.ForcedStateWait:Set[${This.InTenths[30]}]
				This:Output["We have been stuck ${Int[${Math.Calc[(${LavishScript.RunningTime}-${This.StartTime})/1000].Round}]} seconds."]				
				This:Output["HouseOfPain: Move ${direction} 3000 backward 3000"]	
				break
			}
			case 3
			{
				POI.StuckCount:Inc
				This:Output["HouseOfPain: StuckCount ${POI.StuckCount}"]				
			}			
			case 2
			{
				move ${direction} 1800
				This.LastHoP:Set[${This.InTenths[18]}]		
				This:Output["We have been stuck ${Int[${Math.Calc[(${LavishScript.RunningTime}-${This.StartTime})/1000].Round}]} seconds."]				
				This:Output["HouseOfPain: Move ${direction} 3000"]	
				break				
			}
			case 1
			{
				move -stop
				wowpress JUMP						
				move forward 500
				This.LastHoP:Set[${This.InTenths[5]}]		
				This:Output["We have been stuck ${Int[${Math.Calc[(${LavishScript.RunningTime}-${This.StartTime})/1000].Round}]} seconds."]
				This:Output["HouseOfPain: Move forward 500 + JUMP"]	
				break				
			}
			default
			{
				This.JumpJump:Set[0]			
			}
		}
	}	
}