// ----------------------------------------------------------------------------
// Path Following behaviors
public Vector3 steerToStayOnPath(float predictionTime, Pathway path)
{
// predict our future position
Vector3 futurePosition = PredictFuturePosition(predictionTime);
// find the point on the path nearest the predicted future position
//Vector3 tangent;
//float outside;
mapReturnStruct tStruct = new mapReturnStruct();
Vector3 onPath = path.mapPointToPath(futurePosition, tStruct);
if (tStruct.outside < 0)
{
// our predicted future position was in the path,
// return zero steering.
return(Vector3.zero);
}
else
{
// our predicted future position was outside the path, need to
// steer towards it. Use onPath projection of futurePosition
// as seek target
annotatePathFollowing(futurePosition, onPath, onPath, tStruct.outside);
return(steerForSeek(onPath));
}
}
public override Vector3 mapPointToPath(Vector3 point, mapReturnStruct tStruct)//Vector3 tangent, float outside)
{
float d;
float minDistance = float.MaxValue;// FLT_MAX;
Vector3 onPath = Vector3.zero;
// loop over all segments, find the one nearest to the given point
for (int i = 1; i < pointCount; i++)
{
segmentLength = lengths[i];
segmentNormal = normals[i];
d = pointToSegmentDistance(point, points[i - 1], points[i]);
if (d < minDistance)
{
minDistance = d;
onPath = chosen;
tStruct.tangent = segmentNormal;
}
}
// measure how far original point is outside the Pathway's "tube"
tStruct.outside = (onPath - point).magnitude - radius;//Vector3::distance (onPath, point) - radius;
// return point on path
return(onPath);
}
// how far outside path tube is the given point? (negative is inside)
public float howFarOutsidePath(Vector3 point)
{
//float outside;
//Vector3 tangent;
mapReturnStruct tStruct = new mapReturnStruct();
mapPointToPath(point, tStruct);//tangent, outside);
return(tStruct.outside);
}
public Vector3 steerToFollowPath(int direction, float predictionTime, Pathway path)
{
// our goal will be offset from our path distance by this amount
float pathDistanceOffset = direction * predictionTime * Speed();
// predict our future position
Vector3 futurePosition = PredictFuturePosition(predictionTime);
// measure distance along path of our current and predicted positions
float nowPathDistance =
path.mapPointToPathDistance(Position);
float futurePathDistance =
path.mapPointToPathDistance(futurePosition);
// are we facing in the correction direction?
bool rightway = ((pathDistanceOffset > 0) ?
(nowPathDistance < futurePathDistance) :
(nowPathDistance > futurePathDistance));
// find the point on the path nearest the predicted future position
// XXX need to improve calling sequence, maybe change to return a
// XXX special path-defined object which includes two Vector3s and a
// XXX bool (onPath,tangent (ignored), withinPath)
// Vector3 tangent;
//float outside;
mapReturnStruct tStruct = new mapReturnStruct();
Vector3 onPath = path.mapPointToPath(futurePosition, tStruct);
// no steering is required if (a) our future position is inside
// the path tube and (b) we are facing in the correct direction
if ((tStruct.outside < 0) && rightway)
{
// all is well, return zero steering
return(Vector3.zero);
}
else
{
// otherwise we need to steer towards a target point obtained
// by adding pathDistanceOffset to our current path position
float targetPathDistance = nowPathDistance + pathDistanceOffset;
Vector3 target = path.mapPathDistanceToPoint(targetPathDistance);
annotatePathFollowing(futurePosition, onPath, target, tStruct.outside);
// return steering to seek target on path
return(steerForSeek(target));
}
}
// Given an arbitrary point ("A"), returns the nearest point ("P") on
// this path. Also returns, via output arguments, the path tangent at
// P and a measure of how far A is outside the Pathway's "tube". Note
// that a negative distance indicates A is inside the Pathway.
public virtual Vector3 mapPointToPath(Vector3 point, mapReturnStruct tStruct)
{
return(Vector3.zero);
}