基于Unity3D的循环路径的实现

废话少说，直接上代码：

路径脚本

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif


public class WaypointCircuit : MonoBehaviour {

	public WaypointList waypointList = new WaypointList();
	[SerializeField] bool smoothRoute = true;
	int numPoints;
	Vector3[] points;
	float[] distances;

	public float editorVisualisationSubsteps = 100;
	public float Length { get; private set; }
	public Transform[] Waypoints { get { return waypointList.items; } }

	//this being here will save GC allocs
	int p0n;
	int p1n;
	int p2n;
	int p3n;

	private float i;
	Vector3 P0;
	Vector3 P1;
	Vector3 P2;
	Vector3 P3;

	// Use this for initialization
	void Awake () {
		if (Waypoints.Length > 1)
		{
			CachePositionsAndDistances();
		}
		numPoints = Waypoints.Length;
	}

	public RoutePoint GetRoutePoint(float dist)
	{
		// position and direction
		Vector3 p1 = GetRoutePosition(dist);
		Vector3 p2 = GetRoutePosition(dist + 0.1f);
		Vector3 delta = p2-p1;
		return new RoutePoint( p1, delta.normalized );
	}

	public Vector3 GetRoutePosition(float dist)
	{
		int point = 0;

		if (Length == 0)
		{
			Length = distances[distances.Length-1];
		}

		dist = Mathf.Repeat(dist,Length);

		while (distances[point] < dist) { ++point; }


		// get nearest two points, ensuring points wrap-around start & end of circuit
		p1n = ((point-1) + numPoints) % numPoints;
		p2n = point;

		// found point numbers, now find interpolation value between the two middle points

		i = Mathf.InverseLerp(distances[p1n],distances[p2n],dist);

		if (smoothRoute)
		{
			// smooth catmull-rom calculation between the two relevant points



			// get indices for the surrounding 2 points, because
			// four points are required by the catmull-rom function
			p0n = ((point-2) + numPoints) % numPoints;
			p3n = (point+1) % numPoints;

			// 2nd point may have been the 'last' point - a dupe of the first,
			// (to give a value of max track distance instead of zero)
			// but now it must be wrapped back to zero if that was the case.
			p2n = p2n % numPoints;

			P0 = points[ p0n ];
			P1 = points[ p1n ];
			P2 = points[ p2n ];
			P3 = points[ p3n ];

			return CatmullRom(P0,P1,P2,P3,i);

		} else {

			// simple linear lerp between the two points:

			p1n = ((point-1) + numPoints) % numPoints;
			p2n = point;

			return Vector3.Lerp ( points[p1n], points[p2n], i );

		}

	}



	Vector3 CatmullRom(Vector3 _P0, Vector3 _P1, Vector3 _P2, Vector3 _P3, float _i)
	{
		// comments are no use here... it's the catmull-rom equation.
		// Un-magic this, lord vector!
		return 0.5f * ( (2 * _P1) + (-_P0 + _P2) * _i + (2*_P0 - 5*_P1 + 4*_P2 - _P3) * _i*_i + (-_P0 + 3*_P1 - 3*_P2 + _P3) * _i*_i*_i );
	}


	void CachePositionsAndDistances()
	{
		// transfer the position of each point and distances between points to arrays for
		// speed of lookup at runtime
		points = new Vector3[Waypoints.Length+1];
		distances = new float[Waypoints.Length+1];

		float accumulateDistance = 0;
		for (int i = 0; i 1)
		{
			numPoints = Waypoints.Length;

			CachePositionsAndDistances();
			Length = distances[distances.Length-1];

			Gizmos.color = selected ? Color.yellow : new Color(1,1,0,0.5f);
			Vector3 prev = Waypoints[0].position;
			if (smoothRoute)
			{
				for (float dist=0; dist 0)
		{

			for (int i=-1; i 0) items.MoveArrayElement(i,i+1);
									break;
								case "^":
									if (i < items.arraySize-1) items.MoveArrayElement(i,i-1);
									break;
								}

							}
						}
					}
				}

				y += lineHeight + spacing;
				if (changedLength)
				{
					break;
				}
			}

		} else {

			// add button
			var addButtonRect = new Rect ((x + position.width) - widths[widths.Length-1]*inspectorWidth, y, widths[widths.Length-1]*inspectorWidth, lineHeight);
			if (GUI.Button (addButtonRect, "+")) {
				items.InsertArrayElementAtIndex(items.arraySize);
			}

			y += lineHeight + spacing;
		}

		// add all button
		var addAllButtonRect = new Rect (x, y, inspectorWidth, lineHeight);
		if (GUI.Button (addAllButtonRect, "Assign using all child objects"))
		{
			var circuit = property.FindPropertyRelative("circuit").objectReferenceValue as WaypointCircuit;
			var children = new Transform[ circuit.transform.childCount ];
			int n=0; foreach (Transform child in circuit.transform) children[n++] = child;
			System.Array.Sort( children, new TransformNameComparer() );
			circuit.waypointList.items = new Transform[children.Length];
			for (n=0; n

角色脚本

using UnityEngine;
using System.Collections;

public class Follow : MonoBehaviour {

	// 路径脚本
	[SerializeField]
	private WaypointCircuit circuit;

	//移动距离
	private float dis;
	//移动速度
	private float speed;
	// Use this for initialization
	void Start()
	{
		dis = 0;
		speed = 10;
	}

	// Update is called once per frame
	void Update()
	{
		//计算距离
		dis += Time.deltaTime * speed;
		//获取相应距离在路径上的位置坐标
		transform.position = circuit.GetRoutePoint (dis).position;
		//获取相应距离在路径上的方向
		transform.rotation = Quaternion.LookRotation (circuit.GetRoutePoint (dis).direction);
	}
}