Add penalty to previous path on point graph to prevent u-turns? A* Pathfinding Project - graph

Question

I am using Aron Granberg's A* Pathfinding Project. So I have a point graph set up in this picture:
I have each car choosing a random node on the point graph and following a path to it.
Right now, the cars traveling on the road have a tendency to make u-turns to get to their next destination. For example, suppose the original path was from point A to point B. Once the car reaches point B, it then randomly chooses to travel to point C.
Is there any way where I can force it to always take the yellow path instead of the purple path to prevent u-turns? I was thinking something along the lines of setting penalties for the previous path, but the penalties would have to only apply to a single agent as I don't want the penalties to apply to the other cars on the road. Is there a feasible way to do this? I have included my pathfinding code below.
using UnityEngine;
using System.Collections;
using System.Linq;
//Note this line, if it is left out, the script won't know that the class 'Path' exists and it will throw compiler errors
//This line should always be present at the top of scripts which use %Pathfinding
using Pathfinding;
public class newPathfind : MonoBehaviour {
//The point to move to
private Vector3 targetPosition;
private bool pathComplete;
public bool ManualList = false;
//public int members = 0;
//private int x = 0;
public GameObject target1;
public GameObject target2;
public GameObject target3;
public GameObject target4;
public GameObject target5;
private GameObject[] Waypoints;
private GameObject[] oneway;
private GameObject[] twoway;
public static int randomPoint;
private Seeker seeker;
private CharacterController controller;
//The calculated path
public Path path;
//The AI's speed per second
public float speed = 500;
//The max distance from the AI to a waypoint for it to continue to the next waypoint
public float nextWaypointDistance = 3;
//The waypoint we are currently moving towards
private int currentWaypoint = 0;
public void Start () {
seeker = GetComponent<Seeker>();
controller = GetComponent<CharacterController>();
Vector3 randomLoc = Vector3.zero;
if (ManualList) {
Waypoints = new GameObject[5];
Waypoints[0] = target1;
Waypoints[1] = target2;
Waypoints[2] = target3;
Waypoints[3] = target4;
Waypoints[4] = target5;
} else {
//Waypoints = GameObject.FindGameObjectsWithTag("network");
twoway = GameObject.FindGameObjectsWithTag ("network");
oneway = GameObject.FindGameObjectsWithTag ("oneway");
Waypoints = oneway.Concat (twoway).ToArray ();
}
do {
randomPoint = Random.Range (0, Waypoints.Length-1);
randomLoc = Waypoints[randomPoint].transform.position;
targetPosition = new Vector3 (randomLoc.x, gameObject.transform.position.y, randomLoc.z);
} while ((Vector3.Distance(gameObject.transform.position, targetPosition) < 50f));
//Start a new path to the targetPosition, return the result to the OnPathComplete function
seeker.StartPath (transform.position,targetPosition, OnPathComplete);
}
public void OnPathComplete (Path p) {
Debug.Log ("Yey, we got a path back. Did it have an error? "+p.error);
if (!p.error) {
path = p;
//Reset the waypoint counter
currentWaypoint = 0;
pathComplete = true;
}
}
public void FixedUpdate () {
if (path == null) {
return;
}
if (currentWaypoint >= path.vectorPath.Count && pathComplete == true) {
Debug.Log ("End Of Path Reached");
Start();
pathComplete = false;
return;
}
//Direction to the next waypoint
Vector3 dir = Vector3.zero;
if (currentWaypoint >= 0 && currentWaypoint < path.vectorPath.Count) {
dir = (path.vectorPath [currentWaypoint] - transform.position).normalized;
}
if (dir != Vector3.zero) {
transform.rotation = Quaternion.LookRotation (dir);
}
dir *= speed * Time.fixedDeltaTime;
controller.SimpleMove (dir);
//Check if we are close enough to the next waypoint
//If we are, proceed to follow the next waypoint
if (Vector3.Distance (transform.position,path.vectorPath[currentWaypoint]) < nextWaypointDistance) {
currentWaypoint++;
return;
}
}
public void OnDisable () {
seeker.pathCallback -= OnPathComplete;
}
}

Answer 1

I couldn't find how to do this using Aron Granberg's A* Pathfinding Project, but essentially you'll need to change the cost of the last visited node to maybe about 3-5 times its normal cost (would probably need experimenting) before calling seeker.StartPath again.
I would assume that the pathfinder has some way of asking you what the cost for each node is. If the node is the same as the last node the unit visited, you would return a multiple of its actual cost. Of course, you will need to know for which unit it is pathing for.
Closest thing I could find (knowing nothing about the library) was GraphUpdates where you are able to apply penalties to various nodes:
GraphUpdateObject guo = new GraphUpdateObject(myBounds);
guo.addPenalty = 10000; //Here goes the penalty to apply, you need quite large values usually
AstarPath.active.UpdateGraphs (guo);
Not sure how you would tie this with a unit other than updating the graph before calling the seeker for a particular unit and making sure nobody else calls the seeker until that's done (very inefficient).

Answer 2

Difficult question... One thing you could do (for a car already traveling) is evaluate a straight line on the path of the car to the next intersection. That would be the next logical time that the driver would make a decision to recalculate their path. Doing it this way would tell the car to continue using the seeker until it found the starting node of the path (in this case it would drastically reduce your u-turn behavior) which happens to be at the next intersection making your hypothetical much less likely and closer mimick driving behavior.
Also on busy roads you may want to consider using the filter called alternative path... If you add this to your existing car prefab, you can create a penalty for too many other units taking the same path. If you set it to ...say 100, unless it was the only realistic path, after 10 cars took the same path likely you would have cars taking alternate routes
Just my two cents
My edited two cents, adding weights to roads, unless it is the entirety of the road (ie dirt vs. pavement) isnt going to be too feasible. Unless I have missed something in the docs (let me know if I did because I want to use it) you are unable to get the weight for a given node/waypoint.You can however choose between different paths with different penalties. (IE you cant do path.vectorPath[currentWaypoint].weight, but you can do path.GetTagPenalty and choose an alternate path)

Answer 3

Angle Penalty in the "Advanced" section may help here.