You'll likely find that iteration will be the simplest to implement. Essentially you're going to use a for
loop, and step along the car's path. You can use the same methods that you use for updating the car's position in game.
You will need to ensure that you have enough iterations to maintain reasonable accuracy, but you may not want the same number of points in your sample. You can just iterate more often than you place points in your list.
Take the amount of time you want to look ahead and divide it by the number of iterations you want to perform. This will give you your time step for each iteration. The smaller the time step, the more accurate the result will be. This is similar to a Riemann sum. You'll get a more accurate picture with finer resolution.
For example, if we wanted to look ahead 10 seconds:
Vector3 simulationPosition = new Vector3(carCurrentPosition);
Vector3 simulationRotation = new Vector3(carCurrentRotation);
List<Vector3> dataPoints = new List<Vector3>(); //a list to hold all our data points
//drawing a line through all these points will give you your anticipated path
float secondsInMS = 10000;
int iterations = 1000;
float timeStep = secondsInMS/iterations;
for(int i = 0; i < 1000; i++) {
float deltaTime = (float) (i * timeStep);
//update the simulation position
//small time step means more frequent updates and more accurate final position
updatePositionAndRotation(simulationPosition, simulationRotation, velocity, deltaTime);
if(i%50 == 2) { //mod by 50 so that our 1000 iterations turns into 20 data points
dataPoints.add(new Vector3(simulationPosition));
}
}
Where updatePositionAndRotation
takes the simulation's current position and rotation and calculates the new position and rotation based on the velocity and delta time. You likely have a function for this already, so use that here to update the simulation values.