View difference between Paste ID: tAsRFKyF and enHVbev4

-//#define ASTARDEBUG
+
 using System.Collections;
 using System.Collections.Generic;
 using Pathfinding;
 
-using Pathfinding.RVO;
+/** Simple movement script.
  * This movement script will follow the path exactly, it uses linear interpolation to move between the waypoints in the path.
-/** AI for 2D top down games.
+ * This is desirable for some types of games.
- * This is one of the default movement scripts which comes with the A* Pathfinding Project.
+ * It also works in 2D.
- * It is in no way required by the rest of the system, so feel free to write your own. But I hope this script will make it easier
+
- * to set up movement for the characters in your game.
+ * For nicer movement, I recommend adding the Simple Smooth Modifier to the GameObject as well.
- * \n
+
- * This script will try to follow a target transform, and at regular intervals the path to that target will be recalculated.
+
  */
- * \section variables Quick overview of the variables
+
- * In the inspector in Unity, you will see a bunch of variables. You can view detailed information further down, but here's a quick overview.\n
+[AddComponentMenu("Pathfinding/AI/AISimpleLerp (2D,3D generic)")]
- * The #repathRate determines how often it will search for new paths, if you have fast moving targets, you might want to set it to a lower value.\n
+public class AISimpleLerp : MonoBehaviour
- * The #target variable is where the AI will try to move, it can be a point on the ground where the player has clicked in an RTS for example.
+{
- * Or it can be the player object in a zombie game.\n
+
- * The speed is self-explanatory, so is turningSpeed, however #slowdownDistance might require some explanation.
+	/** Determines how often it will search for new paths.
- * It is the approximate distance from the target where the AI will start to slow down. Note that this doesn't only affect the end point of the path
+	 * If you have fast moving targets or AIs, you might want to set it to a lower value.
- * but also any intermediate points, so be sure to set #forwardLook and #pickNextWaypointDist to a higher value than this.\n
+	 * The value is in seconds between path requests.
- * #pickNextWaypointDist is simply determines within what range it will switch to target the next waypoint in the path.\n
+
- * #forwardLook will try to calculate an interpolated target point on the current segment in the path so that it has a distance of #forwardLook from the AI\n
+	public float repathRate = 0.5F;
- * Below is an image illustrating several variables as well as some internal ones, but which are relevant for understanding how it works.
+
- * Note that the #forwardLook range will not match up exactly with the target point practically, even though that's the goal.
+	/** Target to move towards.
- * \shadowimage{aipath_variables.png}
+	 * The AI will try to follow/move towards this target.
- * This script can use a Rigidbody2D for movement or it can simply use transform.position.
+	 * It can be a point on the ground where the player has clicked in an RTS for example, or it can be the player object in a zombie game.
- * If it finds a Rigidbody2D attached to the same GameObject, it will start to use it automatically.
+
 	public Transform target;
 
 	/** Enables or disables searching for paths.
 	 * Setting this to false does not stop any active path requests from being calculated or stop it from continuing to follow the current path.
-[AddComponentMenu("Pathfinding/AI/AIPath (2D top down)")]
+	 * \see #canMove
-public class AIPath2DTopDown : AIPathBase {
+
 	public bool canSearch = true;
-	/** Cached Rigidbody component */
+
-	protected Rigidbody2D rigid;
+	/** Enables or disables movement.
 	  * \see #canSearch */
 	public bool canMove = true;
 
 	/** Speed in world units */
-	protected override void Awake () {
+	public float speed = 3;
-		base.Awake ();
+
 	/** If true, the AI will rotate to face the movement direction */
-		//Cache some other components (not all are necessarily there)
+	public bool enableRotation = true;
-		rigid = GetComponent<Rigidbody2D>();
+
 	/** If true, rotation will only be done along the Z axis */
 	public bool rotationIn2D = false;
-	public override Vector3 GetFeetPosition () {
+
 	/** How quickly to rotate */
 	public float rotationSpeed = 10;
 
-	public virtual void Update () {
+	/** If true, some interpolation will be done when a new path has been calculated.
 	 * This is used to avoid short distance teleportation.
-		if (!canMove) { return; }
+
 	public bool interpolatePathSwitches = true;
-		Vector2 dir = CalculateVelocity (GetFeetPosition());
+
 	/** How quickly to interpolate to the new path */
-		//Rotate towards targetDirection (filled in by CalculateVelocity)
+	public float switchPathInterpolationSpeed = 5;
-		RotateTowards (targetDirection);
+
 	/** Cached Seeker component */
-		if (rigid != null) {
+	protected Seeker seeker;
-			//rigid.AddForce (dir, ForceMode2D.Impulse);
+
-			rigid.MovePosition (rigid.position + dir*Time.deltaTime);
+	/** Cached Transform component */
 	protected Transform tr;
-			transform.Translate (dir*Time.deltaTime, Space.World);
+
 	/** Time when the last path request was sent */
 	protected float lastRepath = -9999;
 
-	/** Point to where the AI is heading.
+	/** Current path which is followed */
-	  * Filled in by #CalculateVelocity */
+	protected ABPath path;
-	protected Vector2 targetPoint;
+
-	/** Relative direction to where the AI is heading.
+	/** Current index in the path which is current target */
-	 * Filled in by #CalculateVelocity */
+	protected int currentWaypointIndex = 0;
-	protected Vector2 targetDirection;
+
 	/** How far the AI has moved on the current segment */
-	/** Calculates desired velocity.
+	protected float lerpTime = 0;
-	 * Finds the target path segment and returns the forward direction, scaled with speed.
+
-	 * A whole bunch of restrictions on the velocity is applied to make sure it doesn't overshoot, does not look too far ahead,
+	/** Holds if the end-of-path is reached
-	 * and slows down when close to the target.
+	 * \see TargetReached */
-	 * /see speed
+	protected bool targetReached = false;
-	 * /see endReachedDistance
+
-	 * /see slowdownDistance
+	/** Only when the previous path has been returned should be search for a new path */
-	 * /see CalculateTargetPoint
+	protected bool canSearchAgain = true;
-	 * /see targetPoint
+
-	 * /see targetDirection
+	/** When a new path was returned, the AI was moving along this ray.
-	 * /see currentWaypointIndex
+	 * Used to smoothly interpolate between the previous movement and the movement along the new path.
 	 * The speed is equal to movement direction.
-	protected Vector2 CalculateVelocity (Vector2 currentPosition) {
+
-		if (path == null || path.vectorPath == null || path.vectorPath.Count == 0) return Vector3.zero;
+	protected Vector3 previousMovementOrigin;
 	protected Vector3 previousMovementDirection;
 	protected float previousMovementStartTime = -9999;
 
 	/** Returns if the end-of-path has been reached
 	 * \see targetReached */
-		if (vPath.Count == 1) {
+	public bool TargetReached {
-			vPath.Insert (0,currentPosition);
+		get {
 			return targetReached;
 		}
 	}
 
 	/** Holds if the Start function has been run.
-		// Possibly pick the next segment
+	 * Used to test if coroutines should be started in OnEnable to prevent calculating paths
 	 * in the awake stage (or rather before start on frame 0).
-			if (currentWaypointIndex < vPath.Count-1) {
+
-				//There is a "next path segment"
+	private bool startHasRun = false;
-				Vector2 nextWaypointDir = (Vector2)vPath[currentWaypointIndex] - currentPosition;
+
-				float dist = nextWaypointDir.sqrMagnitude;
+
-					//Mathfx.DistancePointSegmentStrict (vPath[currentWaypointIndex+1],vPath[currentWaypointIndex+2],currentPosition);
+
-				if (dist < pickNextWaypointDist*pickNextWaypointDist) {
+
-					lastFoundWaypointPosition = currentPosition;
+	protected virtual void Awake () {
-					lastFoundWaypointTime = Time.time;
+		seeker = GetComponent<Seeker>();
-					currentWaypointIndex++;
+
 		//This is a simple optimization, cache the transform component lookup
 		tr = transform;
 	}
-			} else {
+
-				break;
+	/** Starts searching for paths.
 	 * If you override this function you should in most cases call base.Start () at the start of it.
 	 * \see OnEnable
 	 * \see RepeatTrySearchPath
-		// Calculate the point we should move towards
+
-		Vector2 targetPosition = CalculateTargetPoint (currentPosition,vPath[currentWaypointIndex-1] , vPath[currentWaypointIndex]);
+	protected virtual void Start () {
 		startHasRun = true;
-		// Vector to the target position
+		OnEnable ();
-		Vector2 dir = targetPosition-currentPosition;
+
-		float targetDist = dir.magnitude;
+
 	/** Run at start and when reenabled.
-		float slowdown = Mathf.Clamp01 (targetDist / slowdownDistance);
+	 * Starts RepeatTrySearchPath.
 	 *
-		this.targetDirection = dir;
+	 * \see Start
-		this.targetPoint = targetPosition;
+
 	protected virtual void OnEnable () {
-		if (currentWaypointIndex == vPath.Count-1 && targetDist <= endReachedDistance) {
+
-			if (!targetReached) { targetReached = true; OnTargetReached (); }
+		lastRepath = -9999;
 		canSearchAgain = true;
-			//Send a move request, this ensures gravity is applied
+
-			return Vector3.zero;
+		if (startHasRun) {
 			//Make sure we receive callbacks when paths complete
 			seeker.pathCallback += OnPathComplete;
-		// The Y axis is forward in 2D space
+
-		Vector2 forward = -tr.up;
+			StartCoroutine (RepeatTrySearchPath ());
-		float dot = Vector2.Dot (dir.normalized,forward);
+
-		float sp = speed * Mathf.Max (dot,minMoveScale) * slowdown;
+
 
-#if ASTARDEBUG
+	public void OnDisable () {
-		Debug.DrawLine (vPath[currentWaypointIndex-1] , vPath[currentWaypointIndex],Color.black);
+		// Abort calculation of path
-		Debug.DrawLine (GetFeetPosition(),targetPosition,Color.red);
+		if (seeker != null && !seeker.IsDone()) seeker.GetCurrentPath().Error();
-		Debug.DrawRay (targetPosition,Vector3.up, Color.red);
+
-		Debug.DrawRay (GetFeetPosition(),dir,Color.yellow);
+		// Release current path
-		Debug.DrawRay (GetFeetPosition(),forward*sp,Color.cyan);
+		if (path != null) path.Release (this);
-#endif
+		path = null;
 
-		// Make sure we don't overshoot the target
+		//Make sure we receive callbacks when paths complete
-		// when the framerate is low
+		seeker.pathCallback -= OnPathComplete;
-		if (Time.deltaTime	> 0) {
+
-			sp = Mathf.Clamp (sp,0,targetDist/(Time.deltaTime*2));
+
 	/** Tries to search for a path every #repathRate seconds.
-		return forward*sp;
+	  * \see TrySearchPath
 	  */
 	protected IEnumerator RepeatTrySearchPath () {
-	/** Rotates in the specified direction.
+
-	 * Rotates around the Y-axis.
+			float v = TrySearchPath ();
-	 * \see turningSpeed
+			yield return new WaitForSeconds (v);
 		}
-	protected void RotateTowards (Vector2 dir) {
+
 
-		if (dir == Vector2.zero) return;
+	/** Tries to search for a path.
 	 * Will search for a new path if there was a sufficient time since the last repath and both
-		// Figure out the angle so that the Y axis faces dir
+	 * #canSearchAgain and #canSearch are true and there is a target.
-		float angle = Mathf.Atan2 (dir.x, -dir.y)*Mathf.Rad2Deg;
+	 *
 	 * \returns The time to wait until calling this function again (based on #repathRate)
-		Vector3 rot = tr.eulerAngles;
+
-		rot.z = Mathf.LerpAngle (rot.z, angle, turningSpeed * Time.deltaTime);
+	public float TrySearchPath () {
-		tr.eulerAngles = rot;
+		if (Time.time - lastRepath >= repathRate && canSearchAgain && canSearch && target != null) {
 			SearchPath ();
 			return repathRate;
-	/** Calculates target point from the current line segment.
+
-	 * \param p Current position
+			float v = repathRate - (Time.time-lastRepath);
-	 * \param a Line segment start
+			return v < 0 ? 0 : v;
-	 * \param b Line segment end
+
-	 * The returned point will lie somewhere on the line segment.
+
-	 * \see #forwardLook
+
-	 * \todo This function uses .magnitude quite a lot, can it be optimized?
+	/** Requests a path to the target.
 	 * Some inheriting classes will prevent the path from being requested immediately when
-	protected Vector2 CalculateTargetPoint (Vector2 p, Vector2 a, Vector2 b) {
+	 * this function is called, for example when the AI is currently traversing a special path segment
 	 * in which case it is usually a bad idea to search for a new path.
-		float magn = (a-b).magnitude;
+	  */
-		if (magn == 0) return a;
+	public virtual void SearchPath () {
 		ForceSearchPath ();
-		float closest = AstarMath.Clamp01 (AstarMath.NearestPointFactor (a, b, p));
+
-		Vector2 point = (b-a)*closest + a;
+
-		float distance = (point-p).magnitude;
+	/** Requests a path to the target.
 	 * Bypasses 'is-it-a-good-time-to-request-a-path' checks.
-		float lookAhead = Mathf.Clamp (forwardLook - distance, 0.0F, forwardLook);
+	  */
 	public virtual void ForceSearchPath () {
-		float offset = lookAhead / magn;
+		if (target == null) throw new System.InvalidOperationException ("Target is null");
-		offset = Mathf.Clamp (offset+closest,0.0F,1.0F);
+
-		return (b-a)*offset + a;
+		lastRepath = Time.time;
 		//This is where we should search to
 		Vector3 targetPosition = target.position;
 
 		canSearchAgain = false;
 
 		//Alternative way of requesting the path
 		//ABPath p = ABPath.Construct (GetFeetPosition(),targetPoint,null);
 		//seeker.StartPath (p);
 
 		//We should search from the current position
 		seeker.StartPath (GetFeetPosition(), targetPosition);
 	}
 
 	/** The end of the path has been reached.
 	  * If you want custom logic for when the AI has reached it's destination
 	  * add it here
 	  * You can also create a new script which inherits from this one
 	  * and override the function in that script.
 	  */
 	public virtual void OnTargetReached () {
 
 	}
 
 	/** Called when a requested path has finished calculation.
 	  * A path is first requested by #SearchPath, it is then calculated, probably in the same or the next frame.
 	  * Finally it is returned to the seeker which forwards it to this function.\n
 	  */
 	public virtual void OnPathComplete (Path _p) {
 		ABPath p = _p as ABPath;
 		if (p == null) throw new System.Exception ("This function only handles ABPaths, do not use special path types");
 
 		canSearchAgain = true;
 
 		//Claim the new path
 		p.Claim (this);
 
 		// Path couldn't be calculated of some reason.
 		// More info in p.errorLog (debug string)
 		if (p.error) {
 			p.Release (this);
 			return;
 		}
 
 		if (interpolatePathSwitches) {
 			ConfigurePathSwitchInterpolation ();
 		}
 
 		//Release the previous path
 		if (path != null) path.Release (this);
 
 		//Replace the old path
 		path = p;
 
 		// Just for the rest of the code to work, if there is only one waypoint in the path
 		// add another one
 		if (path.vectorPath != null && path.vectorPath.Count == 1) {
 			path.vectorPath.Insert (0,GetFeetPosition());
 		}
 
 		targetReached = false;
 
 		//Reset some variables
 		ConfigureNewPath ();
 	}
 
 	protected virtual void ConfigurePathSwitchInterpolation () {
 		if (path != null && path.vectorPath != null && path.vectorPath.Count > 1) {
 
 			List<Vector3> vPath = path.vectorPath;
 
 			// Make sure we stay inside valid ranges
 			currentWaypointIndex = Mathf.Clamp (currentWaypointIndex, 1, vPath.Count - 1);
 
 			// Current segment vector
 			Vector3 segment = vPath [currentWaypointIndex] - vPath [currentWaypointIndex - 1];
 			float segmentLength = segment.magnitude;
 
 			// Find the approximate length of the path that is left on the current path
 			float approximateLengthLeft = segmentLength * Mathf.Clamp01 (1 - lerpTime);
 			for (int i = currentWaypointIndex; i < vPath.Count-1; i++) {
 				approximateLengthLeft += (vPath [i + 1] - vPath [i]).magnitude;
 			}
 
 			previousMovementOrigin = GetFeetPosition ();
 			previousMovementDirection = segment.normalized * approximateLengthLeft;
 			previousMovementStartTime = Time.time;
 		} else {
 			previousMovementOrigin = Vector3.zero;
 			previousMovementDirection = Vector3.zero;
 			previousMovementStartTime = -9999;
 		}
 	}
 
 	public virtual Vector3 GetFeetPosition () {
 		return tr.position;
 	}
 
 	/** Finds the closest point on the current path.
 	 * Sets #currentWaypointIndex and #lerpTime to the appropriate values.
 	 */
 	protected virtual void ConfigureNewPath () {
 		var points = path.vectorPath;
 
 		var currentPosition = GetFeetPosition ();
 
 		float bestFactor = 0;
 		float bestDist = float.PositiveInfinity;
 		int bestIndex = 0;
 
 		for (int i = 0; i < points.Count-1; i++) {
 			float factor = AstarMath.NearestPointFactor (points[i], points[i+1], currentPosition);
 			Vector3 point = Vector3.Lerp (points[i], points[i+1], factor);
 			float dist = (currentPosition - point).sqrMagnitude;
 
 			if (dist < bestDist) {
 				bestDist = dist;
 				bestFactor = factor;
 				bestIndex = i+1;
 			}
 		}
 
 		currentWaypointIndex = bestIndex;
 		lerpTime = bestFactor;
 	}
 
 	protected virtual void Update () {
 		if (canMove) {
 			Vector3 direction;
 			Vector3 nextPos = CalculateNextPosition (out direction);
 
 			// Rotate unless we are really close to the target
 			if (enableRotation && direction != Vector3.zero) {
 
 				if (rotationIn2D) {
 
 					float angle = Mathf.Atan2(-direction.x, direction.y) * Mathf.Rad2Deg + 180;
 					Vector3 euler = tr.eulerAngles;
 					euler.z = Mathf.LerpAngle (euler.z, angle, Time.deltaTime * rotationSpeed);
 					tr.eulerAngles = euler;
 				} else {
 
 					Quaternion rot = tr.rotation;
 					Quaternion desiredRot = Quaternion.LookRotation (direction);
 
 					tr.rotation = Quaternion.Slerp (rot, desiredRot, Time.deltaTime * rotationSpeed);
 				}
 			}
 
 			tr.position = nextPos;
 		}
 	}
 
 	/** Calculate the AI's next position (one frame in the future).
 	 * \param direction The direction of the segment the AI is currently traversing. Not normalized.
 	 */
 	protected virtual Vector3 CalculateNextPosition ( out Vector3 direction ) {
 
 		if (path == null || path.vectorPath == null || path.vectorPath.Count == 0) {
 			direction = Vector3.zero;
 			return Vector3.zero;
 		}
 
 		List<Vector3> vPath = path.vectorPath;
 
 		// Make sure we stay inside valid ranges
 		currentWaypointIndex = Mathf.Clamp (currentWaypointIndex, 1, vPath.Count - 1);
 
 		// Current segment vector
 		Vector3 segment = vPath[currentWaypointIndex] - vPath[currentWaypointIndex - 1];
 		float segmentLength = segment.magnitude;
 
 		if (segmentLength > 0) {
 			// Move forwards
 			// lerpTime is between 0 and 1
 			lerpTime += Time.deltaTime * speed / segmentLength;
 		} else {
 			// Make sure zero length segments are handled correctly
 			lerpTime = 1;
 		}
 
 		// Pick the next segment if we have traversed the current one completely
 		if (lerpTime > 1 && currentWaypointIndex < vPath.Count-1) {
 			float overshootDistance = (lerpTime-1) * segmentLength;
 
 			while (true) {
 				currentWaypointIndex++;
 
 				// Next segment vector
 				Vector3 nextSegment = vPath[currentWaypointIndex] - vPath[currentWaypointIndex - 1];
 				float nextSegmentLength = segment.magnitude;
 
 				if (overshootDistance <= nextSegmentLength || currentWaypointIndex == vPath.Count-1) {
 					segment = nextSegment;
 					segmentLength = nextSegmentLength;
 					lerpTime = Mathf.Clamp01 (overshootDistance/nextSegmentLength);
 					break;
 				} else {
 					overshootDistance -= nextSegmentLength;
 				}
 			}
 		}
 
 		if (lerpTime >= 1 && currentWaypointIndex == vPath.Count - 1) {
 			if (!targetReached) {
 				OnTargetReached ();
 			}
 			targetReached = true;
 		}
 
 		// Find our position along the path using a simple linear interpolation
 		Vector3 positionAlongCurrentPath = segment * Mathf.Clamp01 (lerpTime) + vPath [currentWaypointIndex - 1];
 
 		direction = segment;
 
 		if (interpolatePathSwitches) {
 			// Find the approximate position we would be at if we
 			// would have continued to follow the previous path
 			Vector3 positionAlongPreviousPath = previousMovementOrigin + Vector3.ClampMagnitude (previousMovementDirection, speed * (Time.time - previousMovementStartTime));
 
 			// Use this to debug
 			//Debug.DrawLine (previousMovementOrigin, positionAlongPreviousPath, Color.yellow);
 
 
 			return Vector3.Lerp (positionAlongPreviousPath, positionAlongCurrentPath, switchPathInterpolationSpeed * (Time.time - previousMovementStartTime));
 		} else {
 			return positionAlongCurrentPath;
 		}
 	}
 }