void FixedUpdate()
{
if (segmentIndex >= path.NumSegments)
{
return;
}
if (t >= 1.0f)
{
segmentIndex++;
if (segmentIndex >= path.NumSegments)
{
return;
}
RecomputeSegment();
}
var tangent = t * t * v1 + t * v2 + v3;
t = t + Time.deltaTime * Speed / tangent.magnitude;
transform.position = Bezier.EvaluateCubic(A, B, C, D, t);
//transform.eulerAngles = new Vector3(0.0f, 0.0f, MathHelpers.Angle(tangent, Vector2.right));
if (gameObject.layer == LayerMask.NameToLayer("enemy"))
{
EM.UpdateEnemy(gameObject, path.NumSegments - segmentIndex - t);
}
}
public bool NextStepCalculatePoint(int repeats = 1, float spacing = 3)
{
if (initialized)
{
for (int i = 0; i < repeats; i++)
{
lerpT += 1f / divisions;
Vector2 pointOnCurve = Bezier.EvaluateCubic(segmentPoints, lerpT);
dstSinceLastEvenPoint = overshootDst + Vector2.Distance(previousPoint, pointOnCurve);
if (dstSinceLastEvenPoint >= spacing)
{
overshootDst = dstSinceLastEvenPoint - spacing;
Vector2 newEvenlySpacedPoint = pointOnCurve + (previousPoint - pointOnCurve).normalized * overshootDst;
EvenlySpacedPoints.Add(newEvenlySpacedPoint);
previousPoint = newEvenlySpacedPoint;
}
if (lerpT >= 1)
{
calculated = true;
return(true);
}
}
}
return(false);
}
public Vector2[] CalculateEvenlySpacedPoints(float spacing, float resolution = 1)
{
List <Vector2> evenlySpacedPoints = new List <Vector2>();
evenlySpacedPoints.Add(points[0]);
Vector2 previousPoint = points[0];
float dstSinceLastEvenPoint = 0;
for (int segmentIndex = 0; segmentIndex < NumSegments; segmentIndex++)
{
Vector2[] p = GetPointsInSegment(segmentIndex);
float controlNetLength = Vector2.Distance(p[0], p[1]) + Vector2.Distance(p[1], p[2]) + Vector2.Distance(p[2], p[3]);
float estimatedCurveLength = Vector2.Distance(p[0], p[3]) + controlNetLength / 2f;
int divisions = Mathf.CeilToInt(estimatedCurveLength * resolution * 10);
float t = 0;
while (t <= 1)
{
t += 1f / divisions;
Vector2 pointOnCurve = Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t);
dstSinceLastEvenPoint += Vector2.Distance(previousPoint, pointOnCurve);
while (dstSinceLastEvenPoint >= spacing)
{
float overshootDst = dstSinceLastEvenPoint - spacing;
Vector2 newEvenlySpacedPoint = pointOnCurve + (previousPoint - pointOnCurve).normalized * overshootDst;
evenlySpacedPoints.Add(newEvenlySpacedPoint);
dstSinceLastEvenPoint = overshootDst;
previousPoint = newEvenlySpacedPoint;
}
previousPoint = pointOnCurve;
}
}
return(evenlySpacedPoints.ToArray()); //converts list into an array
}
public Vector2[] CalculateSpacedPoints(float spacing, float resolution = 1)
{
List<Vector2> evenlySpacedPoints = new List<Vector2>();
evenlySpacedPoints.Add(points[0]);
Vector2 prevPoint = points[0];
float distTravelled = 0;
for (int segIndex = 0; segIndex < NumSegments; segIndex++)
{
Vector2[] p = GetPointsInSegment(segIndex);
float controlNetLength = Vector2.Distance(p[0], p[1]) + Vector2.Distance(p[1], p[2]) + Vector2.Distance(p[2], p[3]);
float estimatedCurveLength = Vector2.Distance(p[0], p[3]) + controlNetLength * .5f;
int divisions = Mathf.CeilToInt(estimatedCurveLength * resolution * 10);
float t = 0;
while (t <= 1)
{
t += 1f/divisions;
Vector2 pointOnCurve = Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t);
distTravelled += Vector2.Distance(prevPoint, pointOnCurve);
while (distTravelled >= spacing)
{
float overshoot = distTravelled - spacing;
Vector2 newEvenlySpacedPoint = pointOnCurve + (prevPoint - pointOnCurve).normalized * overshoot;
evenlySpacedPoints.Add(newEvenlySpacedPoint);
distTravelled = overshoot;
prevPoint = newEvenlySpacedPoint;
}
prevPoint = pointOnCurve;
}
}
return evenlySpacedPoints.ToArray();
}
public Vector3[] CalculateEvenlySpacePoints(float spacing, float resolution = 1f)
{
List <Vector3> spacedPoints = new List <Vector3>();
spacedPoints.Add(points[0]);
var previousPoint = points[0];
float distanceFromPrevious = 0f;
for (int segIndex = 0; segIndex < NumSegments; ++segIndex)
{
Vector3[] p = GetPointsInSegment(segIndex);
float controlNetLength = Vector3.Distance(p[0], p[1]) + Vector3.Distance(p[1], p[2]) + Vector3.Distance(p[2], p[3]);
float estimatedCurveLEngth = Vector3.Distance(p[0], p[3]) + (controlNetLength * 0.5f);
int divisions = (int)estimatedCurveLEngth * (int)resolution * 10;
float t = 0f;
while (t <= 1f)
{
t += 1f / divisions;
var poc = Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t);
distanceFromPrevious += Vector3.Distance(previousPoint, poc);
while (distanceFromPrevious >= spacing)
{
float overShoot = distanceFromPrevious - spacing;
Vector3 newPoint = poc + (previousPoint - poc).normalized * overShoot;
spacedPoints.Add(newPoint);
distanceFromPrevious = overShoot;
previousPoint = newPoint;
}
previousPoint = poc;
}
}
return(spacedPoints.ToArray());
}
public Vector3[] CalculateEvenlySpacedPoints(float spacing, int Set_Start, int segment_num, float resolution = 1)
{
List <Vector3> evenlySpacedPoints = new List <Vector3>();
if (points == null)
{
Debug.LogError("qweqweqwe");
}
if (points[0].Main_Object == null)
{
Debug.LogError("141244112421");
}
//string asd = "";
//for (int i = 0; i < points.Count; i++)
//{
// asd += string.Format("{0} {1} {2}, ", points[i].transform.position.x, points[i].transform.position.y, points[i].transform.position.z);
//}
//Debug.LogError(asd);
evenlySpacedPoints.Add(points[Set_Start].Main_Object.transform.position);
Vector3 previousPoint = points[Set_Start].Main_Object.transform.position;
float dstSinceLastEvenPoint = Set_Start;
for (int segmentIndex = Set_Start; segmentIndex < segment_num; segmentIndex++)
{
Vector3[] p = GetPointsInSegment(segmentIndex);
float controlNetLength = Vector3.Distance(p[0], p[1]) + Vector3.Distance(p[1], p[2]) + Vector3.Distance(p[2], p[3]);
float estimatedCurveLength = Vector3.Distance(p[0], p[3]) + controlNetLength / 2f;
int divisions = Mathf.CeilToInt(estimatedCurveLength * resolution * 10);
float t = 0;
while (t <= 1)
{
t += 1f / divisions;
Vector3 pointOnCurve = Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t);
dstSinceLastEvenPoint += Vector3.Distance(previousPoint, pointOnCurve);
while (dstSinceLastEvenPoint >= spacing)
{
float overshootDst = dstSinceLastEvenPoint - spacing;
Vector3 newEvenlySpacedPoint = pointOnCurve + (previousPoint - pointOnCurve).normalized * overshootDst;
evenlySpacedPoints.Add(newEvenlySpacedPoint);
dstSinceLastEvenPoint = overshootDst;
previousPoint = newEvenlySpacedPoint;
}
previousPoint = pointOnCurve;
}
}
return(evenlySpacedPoints.ToArray());
}
public Vector2 CalculatePointOnCurve(int segmentIndex, float t)
{
Vector2[] p = GetPointsInSegment(segmentIndex);
return(Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t));
}
public Vector3 GetPosPath(int index, float progress, float right_offset)
{
Node cur = nodes[index];
return(Bezier.EvaluateCubic(cur.get_pos(right_offset), cur.get_AnchorA(right_offset), cur.get_AnchorBNext(right_offset), cur.get_next_pos(right_offset), progress));
}