/// <summary>
/// Creates a path of Roads constraining to the city metric between two Intersections.
/// </summary>
/// <param name="head"></param>
/// <param name="tail"></param>
/// <returns></returns>
public static RoadPath CreatePath(Intersection head, Intersection tail)
{
RoadPath rp = new RoadPath(head, tail);
rp.BuildPath();
return(rp);
}
private void BuildRoad()
{
var cubeType = MapService.GetCubeType(LifeGoalTargetX, LifeGoalTargetZ);
if (cubeType == CubeTypes.Grass)
{
if (GameService.RockCount > 0)
{
Progress += Time.deltaTime * ContinueRoadSpeed;
if (Progress > Mathf.PI * 2f)
{
GameService.RockCount--;
MapService.ConvertGrassToRoad(LifeGoalTargetX, LifeGoalTargetZ);
}
if (Progress >= Mathf.PI * 2f)
{
Progress -= Mathf.PI * 2f;
}
}
else
{
Progress = 0;
}
}
else if (cubeType == CubeTypes.Road)
{
var next = RoadPath.Dequeue();
LifeGoalTargetX = next.X;
LifeGoalTargetZ = next.Z;
ScheduleMovingSteps(new[] { next });
}
}
private void GenerateRoadSet()
{
for (int i = 0; i < length; i++)
{
GameObject roadObject = Instantiate(roadPrefab);
roadObject.transform.SetParent(transform);
roadObject.transform.localScale = Vector3.one;
roadObject.name = "Road";
if (currentRoad == null)
{
roadObject.transform.localPosition = Vector3.zero;
roadObject.transform.localEulerAngles = Vector3.zero;
}
else
{
roadObject.transform.localPosition = currentRoad.EdgePosition;
roadObject.transform.localEulerAngles = currentRoad.EdgeRotation;
}
currentRoad = roadObject.GetComponent <RoadPath>();
currentRoad.Generate();
GenerateWaypoints();
}
}
public void createPath()
{
roadPath = new RoadPath(transform.position);
roadSettings = new RoadSettings();
meshCreator = new RoadMeshCreator();
}
public void AddPath(NavMeshPath _path)
{
if (listOfPaths == null)
{
listOfPaths = new List <RoadPath> ();
}
RoadPath newPath = new RoadPath();
newPath.SetPath(_path);
listOfPaths.Add(newPath);
}
// Update is called once per frame
void Update()
{
// Change traffic lights when time
if (intersections.Count > 0)
{
foreach (RoadIntersection intersect in intersections)
{
intersect.CheckTimeAndIfReadyChangeLight();
}
}
// Add a new car to the road when time
if (spawningCars && Time.time - carSpawnTimerRef > carSpawnRateActual)
{
// Select random car prefab from list and assign a random path on the road system
GameObject randomCar = carPrefabs[Random.Range(0, carPrefabs.Count)];
currentPathToAssign = spawnPaths[Random.Range(0, spawnPaths.Count)];
// Check if any cars on the road are at the spawn point chosen for new car
bool assignedPathIsBlocked = false;
foreach (NPCVehicle veh in vehicles)
{
if (veh.GetWaypoint() == currentPathToAssign.roadWaypoints[0])
{
assignedPathIsBlocked = true;
}
}
// If the spawn point isn't blocked by any existing cars, put the new car there, add it to the list of cars, and restart timer
if (!assignedPathIsBlocked)
{
GameObject newCar = Instantiate(randomCar, currentPathToAssign.roadWaypoints[0].position, Quaternion.identity);
NPCVehicle newCarAI = newCar.GetComponent <NPCVehicle>();
newCarAI.SetPath(currentPathToAssign, 1);
vehicles.Add(newCar.GetComponent <NPCVehicle>());
carSpawnRateActual = Random.Range(spawnRateSecPerCar - spawnRateDeltaInSec, spawnRateSecPerCar + spawnRateDeltaInSec);
carSpawnTimerRef = Time.time;
}
}
}
public bool IsValidRoad(Vector3 proposedStart, Vector3 proposedEnd)
{
Vector3 center = Vector3.Lerp(proposedStart, proposedEnd, 0.5f);
float length = metricConstraint.Distance(proposedStart, proposedEnd);
Vector3 direction = (proposedEnd - proposedStart).normalized;
List <Vector3> path = new RoadPath(proposedStart, proposedEnd, this).Path;
if (length < settings.minimumRoadLength)
{
return(false);
}
for (int i = 0; i < path.Count - 1; i++)
{
center = Vector3.Lerp(path[i], path[i + 1], 0.5f);
length = metricConstraint.Distance(path[i], path[i + 1]);
if (Physics.CheckBox(center, new Vector3(settings.roadDimensions.x, settings.roadDimensions.y, length * 0.95f) / 2f))
{
return(false);
}
}
return(true);
}
// Update is called once per frame
void Update()
{
switch (State)
{
case DrivingState.MovingToNextPoint:
// As long as this vehicle has a RoadPath, do all of this
if (travelPath != null)
{
currentWaypoint = travelPath.roadWaypoints[currentWaypointIndex]; // Destination is the currentWaypoint transform
// Creates a copy
//Transform copy = new GameObject().transform;
//copy.rotation = this.transform.rotation;
//copy.position = this.transform.position;
//copy.rotation = Quaternion.AngleAxis(travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle, Vector3.forward);
//Destroy(copy.gameObject);
this.transform.LookAt(currentWaypoint.position, upDir);
bool canProceed = true;
foreach (RoadIntersection intersect in trafficController.intersections)
{
if (!intersect.CanProceedThroughLight(currentWaypoint))
{
canProceed = false;
}
iAmTurningLeft = intersect.AlertLeftTurn(currentWaypoint);
if (iAmTurningLeft)
{
iAmTurningLeft = !intersect.LeftTurnEnded(currentWaypoint);
}
if (intersect.IAmAtIntersection(currentWaypoint) && !iAmTurningLeft && intersect.SomeoneIsTurningLeft())
{
canProceed = false;
iAmAvoidingLeftPittsburghLeft = true;
}
}
//Destroy(copy.gameObject);
if (travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants > 1)
{
canProceed = false;
}
for (int i = 1; i < travelPath.numOfWaypointsToSearchAheadForApplyingBrakes + 1; i++)
{
if (currentWaypointIndex + i < travelPath.roadWaypoints.Count)
{
if (travelPath.waypointInstructions[currentWaypointIndex + i].waypointNumOfOccupants > 0)
{
canProceed = false;
}
}
}
if (!canProceed)
{
if (currentSpeed > 0)
{
currentSpeed -= brake;
}
else
{
currentSpeed = 0;
}
}
else
{
if (currentSpeed < actualTopSpeed)
{
currentSpeed += acceleration;
}
}
if (iAmTurningLeft)
{
this.transform.Translate(0, 0, currentSpeed * leftTurnFactor * Time.deltaTime);
}
else if (iAmAvoidingLeftPittsburghLeft)
{
this.transform.Translate(0, 0, currentSpeed * avoidLeftTurnFactor * Time.deltaTime);
}
else
{
this.transform.Translate(0, 0, currentSpeed * Time.deltaTime);
}
this.transform.Translate(0, 0, currentSpeed * Time.deltaTime);
if (Mathf.Abs(Vector3.Distance(this.transform.position, currentWaypoint.position)) < trafficController.proximityToChangeWaypoints)
{
if (travelPath.connectsToOtherPaths && travelPath.connections.Count > 0)
{
bool thisIsAConnectionPoint = false;
Transform newStartPoint = null;
foreach (RoadPathConnection connector in travelPath.connections)
{
if (connector.OldPathEndpoint == currentWaypoint)
{
newStartPoint = connector.NewPathStartPoint;
thisIsAConnectionPoint = true;
}
}
if (thisIsAConnectionPoint)
{
List <RoadPath> possiblePaths = new List <RoadPath>();
foreach (RoadPath path in trafficController.roadPaths)
{
if (path.startWaypoint == newStartPoint)
{
possiblePaths.Add(path);
}
}
if (possiblePaths.Count > 0)
{
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants--;
int randConnectionIndex = Random.Range(0, possiblePaths.Count);
if (possiblePaths.Count == 1 || !trafficController.randomTurns)
{
travelPath = possiblePaths[0];
}
else
{
travelPath = possiblePaths[randConnectionIndex];
}
currentWaypointIndex = 1;
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants++;
}
}
else
{
if (currentWaypointIndex < travelPath.roadWaypoints.Count - 1)
{
currentWaypointIndex++;
if (travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle == 0)
{
upDir = initialUpDir;
}
else
{
upDir = Quaternion.AngleAxis(travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle
- lastBankAngle, this.transform.forward) * this.transform.up;
lastBankAngle = travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle;
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants++;
travelPath.waypointInstructions[currentWaypointIndex - 1].waypointNumOfOccupants--;
}
}
else
{
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants--;
trafficController.AddVehicleToDestroyList(this);
}
}
}
else
{
if (currentWaypointIndex < travelPath.roadWaypoints.Count - 1)
{
currentWaypointIndex++;
if (travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle == 0)
{
upDir = initialUpDir;
}
else
{
upDir = Quaternion.AngleAxis(travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle
- lastBankAngle, this.transform.forward) * this.transform.up;
lastBankAngle = travelPath.waypointInstructions[currentWaypointIndex].maxBankAngle;
}
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants++;
travelPath.waypointInstructions[currentWaypointIndex - 1].waypointNumOfOccupants--;
}
else
{
travelPath.waypointInstructions[currentWaypointIndex].waypointNumOfOccupants--;
trafficController.AddVehicleToDestroyList(this);
}
}
}
}
break;
case DrivingState.Stopped:
break;
}
}
public void SetPath(RoadPath path, int waypointIndex)
{
travelPath = path;
currentWaypointIndex = waypointIndex;
}
private void drawScene()
{
Handles.color = road.roadSettings.nodeColor;
for (int i = 0; i < road.roadPath.PointsCount; i++)
{
Vector3 updatePos;
if (i % 3 == 0)
{
updatePos = Handles.FreeMoveHandle(road.roadPath[i].Position, Quaternion.identity, road.roadSettings.nodeSize, Vector3.zero, Handles.CylinderHandleCap);
}
else
{
updatePos = Handles.PositionHandle(road.roadPath[i].Position, Quaternion.identity);
}
if (updatePos != road.roadPath[i].Position)
{
Undo.RecordObject(road, "Moved point");
road.roadPath.movePosition(i, updatePos);
}
}
for (int i = 0; i < road.roadPath.SegmentCount; i++)
{
Point[] segment = road.roadPath.getSegment(i);
Handles.color = road.roadSettings.lineColor;
Handles.DrawLine(segment[0].Position, segment[1].Position);
Handles.DrawLine(segment[3].Position, segment[2].Position);
if (road.roadSettings.showCurve)
{
Handles.DrawBezier(segment[0].Position, segment[3].Position, segment[1].Position, segment[2].Position, road.roadSettings.curveColor, null, road.roadSettings.curveWidth);
}
}
if (road.roadSettings.showPoints || road.roadSettings.showPointForwards || road.roadSettings.showPointBinormals ||
road.roadSettings.showPointNormals || road.roadSettings.showVertices || road.roadSettings.showTris ||
road.roadSettings.showMeshNormals || road.roadSettings.showUVs || road.roadSettings.showPathCenter)
{
Point[] roadPoints = road.roadPath.getRoadPathPoints(road.roadSettings.spacing);
Vector3[] forwardDir = road.meshCreator.getPointsForward(roadPoints, road.roadPath.Closed);
Vector3[] binormals = road.meshCreator.getPointsBinormal(forwardDir, Vector3.up);
Vector3[] normals = road.meshCreator.getPointsNormal(forwardDir, binormals, new Vector2(0.0f, 1.0f));
if (road.roadSettings.showPathCenter)
{
Vector3 pathCenter = RoadPath.getCenter(roadPoints);
Handles.Label(pathCenter, "Center:\n" + pathCenter.ToString());
}
if (road.roadSettings.showPoints)
{
Handles.color = road.roadSettings.pathColor;
foreach (Point node in roadPoints)
{
Handles.SphereHandleCap(1, node.Position, Quaternion.identity, road.roadSettings.size, EventType.Repaint);
}
}
if (road.roadSettings.showPathLabels)
{
for (int i = 0; i < roadPoints.Length; i++)
{
Handles.Label(roadPoints[i].Position, i.ToString());
}
}
if (road.roadSettings.showPointForwards)
{
Handles.color = road.roadSettings.nodeForwardColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(forwardDir[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showPointBinormals)
{
Handles.color = road.roadSettings.nodeBinormalColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(binormals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showPointNormals)
{
Handles.color = road.roadSettings.nodeNormalColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(normals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
foreach (DrawableShape shape in road.meshCreator.shapesToRender)
{
Shape renderShape = RoadMeshCreator.enumToShape(shape);
if (road.roadSettings.showVertices || road.roadSettings.showTris || road.roadSettings.showPointNormals || road.roadSettings.showUVs || road.roadSettings.showVertIndices)
{
Vector3[] vertices = road.meshCreator.getMeshVertices(roadPoints, renderShape, shape.offset, Vector3.up, shape.trackCompletion, road.roadPath.Closed);
int[] tris = road.meshCreator.getMeshTris(vertices.Length, renderShape, shape.winding, shape.trackCompletion, road.roadPath.Closed);
if (road.roadSettings.showVertices)
{
Handles.color = road.roadSettings.vertexColor;
foreach (Vector3 vertexPos in vertices)
{
Handles.SphereHandleCap(1, vertexPos, Quaternion.identity, road.roadSettings.size, EventType.Repaint);
}
}
if (road.roadSettings.showVertIndices)
{
for (int i = 0; i < vertices.Length; i++)
{
Handles.Label(vertices[i], i.ToString());
}
}
if (road.roadSettings.showTris)
{
Handles.color = Color.green;
for (int i = 0; i < tris.Length / 3; i++)
{
int index = 3 * i;
Handles.DrawLine(vertices[tris[index]], vertices[tris[index + 1]]);
Handles.DrawLine(vertices[tris[index + 1]], vertices[tris[index + 2]]);
Handles.DrawLine(vertices[tris[index + 2]], vertices[tris[index]]);
}
}
if (road.roadSettings.showMeshNormals)
{
Handles.color = Color.white;
Vector3[] vertexNormals = road.meshCreator.pointToMeshNormals(roadPoints, renderShape, Vector3.up, shape.winding, shape.trackCompletion, road.roadPath.Closed);
for (int i = 0; i < vertexNormals.Length; i++)
{
Handles.ArrowHandleCap(1, vertices[i], Quaternion.LookRotation(vertexNormals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showUVs)
{
Vector2[] UVs = road.meshCreator.getMeshUV(vertices.Length, renderShape);
for (int i = 0; i < UVs.Length; i++)
{
Handles.Label(vertices[i], UVs[i].ToString());
}
}
}
}
}
}
