View difference between Paste ID: 5iRzeJix and enHVbev4

 //#define ASTARDEBUG
 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 using Pathfinding;
 using Pathfinding.RVO;
 
-/** AI for 2D top down games.
+/** Base class for AIs.
- * This is one of the default movement scripts which comes with the A* Pathfinding Project.
+
- * 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
+ * \see AIPath
- * to set up movement for the characters in your game.
+ * \see AI2DTopDown
- * \n
+
- * This script will try to follow a target transform, and at regular intervals the path to that target will be recalculated.
+
 public abstract class AIPathBase : MonoBehaviour {
- * \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
+	/** Determines how often it will search for new paths.
- * 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
+	 * If you have fast moving targets or AIs, you might want to set it to a lower value.
- * 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.
+	 * The value is in seconds between path requests.
- * 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.
+	public float repathRate = 0.5F;
- * 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
+
- * but also any intermediate points, so be sure to set #forwardLook and #pickNextWaypointDist to a higher value than this.\n
+	/** Target to move towards.
- * #pickNextWaypointDist is simply determines within what range it will switch to target the next waypoint in the path.\n
+	 * The AI will try to follow/move towards this target.
- * #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
+	 * 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.
- * 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.
+	public Transform target;
- * \shadowimage{aipath_variables.png}
+
- * This script can use a Rigidbody2D for movement or it can simply use transform.position.
+	/** Enables or disables searching for paths.
- * If it finds a Rigidbody2D attached to the same GameObject, it will start to use it automatically.
+	 * Setting this to false does not stop any active path requests from being calculated or stop it from continuing to follow the current path.
 	 * \see #canMove
- * \ingroup movementscripts
+
 	public bool canSearch = true;
 
-[AddComponentMenu("Pathfinding/AI/AIPath (2D top down)")]
+	/** Enables or disables movement.
-public class AIPath2DTopDown : AIPathBase {
+	  * \see #canSearch */
 	public bool canMove = true;
-	/** Cached Rigidbody component */
+
-	protected Rigidbody2D rigid;
+	/** Maximum velocity.
 	 * This is the maximum speed in world units per second.
 	 */
 	public float speed = 3;
 
-	protected override void Awake () {
+	/** Rotation speed.
-		base.Awake ();
+	 * Rotation is calculated using Quaternion.SLerp. This variable represents the damping, the higher, the faster it will be able to rotate.
 	 */
-		//Cache some other components (not all are necessarily there)
+	public float turningSpeed = 5;
-		rigid = GetComponent<Rigidbody2D>();
+
 	/** Distance from the target point where the AI will start to slow down.
 	 * Note that this doesn't only affect the end point of the path
-	public override Vector3 GetFeetPosition () {
+ 	 * but also any intermediate points, so be sure to set #forwardLook and #pickNextWaypointDist to a higher value than this
  	 */
 	public float slowdownDistance = 0.6F;
 
-	public virtual void Update () {
+	/** Determines within what range it will switch to target the next waypoint in the path */
 	public float pickNextWaypointDist = 2;
-		if (!canMove) { return; }
+
 	/** Target point is Interpolated on the current segment in the path so that it has a distance of #forwardLook from the AI.
-		Vector2 dir = CalculateVelocity (GetFeetPosition());
+	  * See the detailed description of AIPath for an illustrative image */
 	public float forwardLook = 1;
-		//Rotate towards targetDirection (filled in by CalculateVelocity)
+
-		RotateTowards (targetDirection);
+	/** Distance to the end point to consider the end of path to be reached.
 	 * When this has been reached, the AI will not move anymore until the target changes and OnTargetReached will be called.
-		if (rigid != null) {
+
-			//rigid.AddForce (dir, ForceMode2D.Impulse);
+	public float endReachedDistance = 0.2F;
-			rigid.MovePosition (rigid.position + dir*Time.deltaTime);
+
 	/** Do a closest point on path check when receiving path callback.
-			transform.Translate (dir*Time.deltaTime, Space.World);
+	 * Usually the AI has moved a bit between requesting the path, and getting it back, and there is usually a small gap between the AI
 	 * and the closest node.
 	 * If this option is enabled, it will simulate, when the path callback is received, movement between the closest node and the current
 	 * AI position. This helps to reduce the moments when the AI just get a new path back, and thinks it ought to move backwards to the start of the new path
-	/** Point to where the AI is heading.
+	 * even though it really should just proceed forward.
-	  * Filled in by #CalculateVelocity */
+
-	protected Vector2 targetPoint;
+	public bool closestOnPathCheck = true;
-	/** Relative direction to where the AI is heading.
+
-	 * Filled in by #CalculateVelocity */
+	protected float minMoveScale = 0.05F;
-	protected Vector2 targetDirection;
+
 	/** Cached Seeker component */
-	/** Calculates desired velocity.
+	protected Seeker seeker;
-	 * 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,
+	/** Cached Transform component */
-	 * and slows down when close to the target.
+	protected Transform tr;
-	 * /see speed
+
-	 * /see endReachedDistance
+	/** Time when the last path request was sent */
-	 * /see slowdownDistance
+	protected float lastRepath = -9999;
-	 * /see CalculateTargetPoint
+
-	 * /see targetPoint
+	/** Current path which is followed */
-	 * /see targetDirection
+	protected Path path;
-	 * /see currentWaypointIndex
+
 	/** Current index in the path which is current target */
-	protected Vector2 CalculateVelocity (Vector2 currentPosition) {
+	protected int currentWaypointIndex = 0;
-		if (path == null || path.vectorPath == null || path.vectorPath.Count == 0) return Vector3.zero;
+
 	/** Holds if the end-of-path is reached
-		List<Vector3> vPath = path.vectorPath;
+	 * \see TargetReached */
 	protected bool targetReached = false;
-		// Just for the rest of the code to work, if there is only one waypoint in the path
+
-		// add another one
+	/** Only when the previous path has been returned should be search for a new path */
-		if (vPath.Count == 1) {
+	protected bool canSearchAgain = true;
-			vPath.Insert (0,currentPosition);
+
 	protected Vector3 lastFoundWaypointPosition;
 	protected float lastFoundWaypointTime = -9999;
-		// Make sure we stay inside valid ranges
+
-		currentWaypointIndex = Mathf.Clamp (currentWaypointIndex, 1, vPath.Count - 1);
+	/** Returns if the end-of-path has been reached
 	 * \see targetReached */
-		// Possibly pick the next segment
+	public bool TargetReached {
 		get {
-			if (currentWaypointIndex < vPath.Count-1) {
+			return targetReached;
-				//There is a "next path segment"
+
-				Vector2 nextWaypointDir = (Vector2)vPath[currentWaypointIndex] - currentPosition;
+
-				float dist = nextWaypointDir.sqrMagnitude;
+
-					//Mathfx.DistancePointSegmentStrict (vPath[currentWaypointIndex+1],vPath[currentWaypointIndex+2],currentPosition);
+	/** Holds if the Start function has been run.
-				if (dist < pickNextWaypointDist*pickNextWaypointDist) {
+	 * Used to test if coroutines should be started in OnEnable to prevent calculating paths
-					lastFoundWaypointPosition = currentPosition;
+	 * in the awake stage (or rather before start on frame 0).
-					lastFoundWaypointTime = Time.time;
+
-					currentWaypointIndex++;
+	private bool startHasRun = false;
-				} else {
+
-					break;
+
-				}
+
-			} else {
+
-				break;
+	protected virtual void Awake () {
-			}
+		seeker = GetComponent<Seeker>();
 
 		//This is a simple optimization, cache the transform component lookup
-		// Calculate the point we should move towards
+		tr = transform;
-		Vector2 targetPosition = CalculateTargetPoint (currentPosition,vPath[currentWaypointIndex-1] , vPath[currentWaypointIndex]);
+
 
-		// Vector to the target position
+	/** Starts searching for paths.
-		Vector2 dir = targetPosition-currentPosition;
+	 * If you override this function you should in most cases call base.Start () at the start of it.
-		float targetDist = dir.magnitude;
+	 * \see OnEnable
 	 * \see RepeatTrySearchPath
-		float slowdown = Mathf.Clamp01 (targetDist / slowdownDistance);
+
 	protected virtual void Start () {
-		this.targetDirection = dir;
+		startHasRun = true;
-		this.targetPoint = targetPosition;
+		OnEnable ();
 	}
-		if (currentWaypointIndex == vPath.Count-1 && targetDist <= endReachedDistance) {
+
-			if (!targetReached) { targetReached = true; OnTargetReached (); }
+	/** Run at start and when reenabled.
 	 * Starts RepeatTrySearchPath.
-			//Send a move request, this ensures gravity is applied
+	 *
-			return Vector3.zero;
+	 * \see Start
 	 */
 	protected virtual void OnEnable () {
-		// The Y axis is forward in 2D space
+
-		Vector2 forward = -tr.up;
+		lastRepath = -9999;
-		float dot = Vector2.Dot (dir.normalized,forward);
+		canSearchAgain = true;
-		float sp = speed * Mathf.Max (dot,minMoveScale) * slowdown;
+
 		lastFoundWaypointPosition = GetFeetPosition ();
-#if ASTARDEBUG
+
-		Debug.DrawLine (vPath[currentWaypointIndex-1] , vPath[currentWaypointIndex],Color.black);
+		if (startHasRun) {
-		Debug.DrawLine (GetFeetPosition(),targetPosition,Color.red);
+			//Make sure we receive callbacks when paths complete
-		Debug.DrawRay (targetPosition,Vector3.up, Color.red);
+			seeker.pathCallback += OnPathComplete;
-		Debug.DrawRay (GetFeetPosition(),dir,Color.yellow);
+
-		Debug.DrawRay (GetFeetPosition(),forward*sp,Color.cyan);
+			StartCoroutine (RepeatTrySearchPath ());
-#endif
+
 	}
-		// Make sure we don't overshoot the target
+
-		// when the framerate is low
+	public void OnDisable () {
-		if (Time.deltaTime	> 0) {
+		// Abort calculation of path
-			sp = Mathf.Clamp (sp,0,targetDist/(Time.deltaTime*2));
+		if (seeker != null && !seeker.IsDone()) seeker.GetCurrentPath().Error();
 
-		return forward*sp;
+		// Release current path
 		if (path != null) path.Release (this);
 		path = null;
-	/** Rotates in the specified direction.
+
-	 * Rotates around the Y-axis.
+		//Make sure we receive callbacks when paths complete
-	 * \see turningSpeed
+		seeker.pathCallback -= OnPathComplete;
 	}
-	protected void RotateTowards (Vector2 dir) {
+
 	/** Tries to search for a path every #repathRate seconds.
-		if (dir == Vector2.zero) return;
+	  * \see TrySearchPath
 	  */
-		// Figure out the angle so that the Y axis faces dir
+	protected IEnumerator RepeatTrySearchPath () {
-		float angle = Mathf.Atan2 (dir.x, -dir.y)*Mathf.Rad2Deg;
+
 			float v = TrySearchPath ();
-		Vector3 rot = tr.eulerAngles;
+			yield return new WaitForSeconds (v);
-		rot.z = Mathf.LerpAngle (rot.z, angle, turningSpeed * Time.deltaTime);
+
-		tr.eulerAngles = rot;
+
 
 	/** Tries to search for a path.
-	/** Calculates target point from the current line segment.
+	 * Will search for a new path if there was a sufficient time since the last repath and both
-	 * \param p Current position
+	 * #canSearchAgain and #canSearch are true and there is a target.
-	 * \param a Line segment start
+	 *
-	 * \param b Line segment end
+	 * \returns The time to wait until calling this function again (based on #repathRate)
-	 * The returned point will lie somewhere on the line segment.
+
-	 * \see #forwardLook
+	public float TrySearchPath () {
-	 * \todo This function uses .magnitude quite a lot, can it be optimized?
+		if (Time.time - lastRepath >= repathRate && canSearchAgain && canSearch && target != null) {
 			SearchPath ();
-	protected Vector2 CalculateTargetPoint (Vector2 p, Vector2 a, Vector2 b) {
+			return repathRate;
 		} else {
-		float magn = (a-b).magnitude;
+			//StartCoroutine (WaitForRepath ());
-		if (magn == 0) return a;
+			float v = repathRate - (Time.time-lastRepath);
 			return v < 0 ? 0 : v;
-		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 */
-		float lookAhead = Mathf.Clamp (forwardLook - distance, 0.0F, forwardLook);
+	public virtual void SearchPath () {
 
-		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);
 	}
 
 	public virtual void OnTargetReached () {
 		//End of 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
 	}
 
 	/** 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;
 		}
 
 		//Release the previous path
 		if (path != null) path.Release (this);
 
 		//Replace the old path
 		path = p;
 
 		//Reset some variables
 		currentWaypointIndex = 0;
 		targetReached = false;
 	}
 
 	public virtual Vector3 GetFeetPosition () {
 		return tr.position;
 	}
 }