void PickRandomTrip()
{
var streetPoints = GameObject.FindGameObjectsWithTag("streetPoint");
startNode = streetPoints[(int)Random.Range(0, streetPoints.Length - 1)].GetComponent <NodeHandler>().node;
endNode = streetPoints[(int)Random.Range(0, streetPoints.Length - 1)].GetComponent <NodeHandler>().node;
}
/// <summary>
/// Instantiate the truck and send it to the predefined destinations
/// </summary>
/// <param name="destinations"></param>
private void SendTruck(List <NodeStreet> destinations)
{
spawnPoint = GetComponentInChildren <SpawnPointHandler>().node;
var truck = Instantiate(garbageTruck, Utils.Down(spawnPoint.nodePosition) + Vector3.up, Quaternion.identity);
Utils.SendVehicleFromTo(spawnPoint, destinations[0], truck);
truck.GetComponent <TruckAIController>().destinations = destinations;
}
public WHWorker(int adultIndex, HUEconomy myHUEconomy, HUCarsHandler myHUCarsHandler, System.DateTime workingStart, int workingHours, NodeStreet workSpawn, Quaternion rot)
{
this.myHUEconomy = myHUEconomy;
this.myHUCarsHandler = myHUCarsHandler;
this.workingStart = workingStart;
this.workingHours = workingHours;
this.adultIndex = adultIndex;
this.workSpawn = workSpawn;
this.rot = rot;
}
private void CheckAtPositionForNodesFromCross(Vector3 checkPos, NodeStreet curNode, float radius = 2f)
{
var colls = Physics.OverlapSphere(checkPos, radius, LayerMask.GetMask("network"));
foreach (Collider c in colls)
{
var nextNode = c.gameObject.GetComponent <NodeHandler>().node;
var curStreet = new ArcStreet(curNode, nextNode);
curNode.AddStreet(curStreet);
}
}
public void InitializeNode()
{
if (node == null)
{
node = new NodeStreet(transform.position - (Vector3.up * transform.position.y));
}
else
{
node.nodePosition = transform.position - (Vector3.up * transform.position.y);
node.availableStreets.Clear();
}
}
public static List <NodeStreet> PathFromTo(NodeStreet startNode, NodeStreet endNode, GameObject vehicle)
{
// pathfinding
var pathFinder = new AStar(startNode, endNode, vehicle);
var found = pathFinder.PathFinder();
var path = new List <NodeStreet>();
foreach (NodeStreet n in pathFinder.path)
{
path.Add(n);
}
return(path);
}
public static void SendVehicleFromTo(NodeStreet startNode, NodeStreet endNode, GameObject vehicle)
{
var path = AStar.PathFromTo(startNode, endNode, vehicle);
if (path.Count > 0)
{
vehicle.transform.LookAt(path[0].nodePosition);
vehicle.GetComponent <VehicleAIController>().nextWaypoint = path[0];
vehicle.GetComponent <VehicleAIController>().waypoints = path;
vehicle.GetComponent <VehicleAIController>().arrivalNode = endNode;
return;
}
Debug.Log("Path not found");
}
public IEnumerator ShopperResender(int hours, NodeStreet backNode, GameObject actualWorkerCar, GameObject workerCarModel, int minutes = 0)
{
while (Vector3.Distance(Utils.Down(transform.position), actualWorkerCar.transform.position) > 5)
{
yield return(new WaitForFixedUpdate());
}
yield return(new WaitForSeconds((hours * 3600 + minutes * 60) / Settings.timeMultiplyer));
var startNode = GetComponentInChildren <SpawnPointHandler>().node;
var car = Instantiate(workerCarModel, startNode.nodePosition, transform.rotation);
Utils.SendVehicleFromTo(startNode, backNode, car);
}
public GameObject WorkerMoving(NodeStreet startNode, NodeStreet endNode, Quaternion rot)
{
if (startNode == null || endNode == null)
{
return(null);
}
else
{
var worker = Instantiate(car, startNode.nodePosition + Vector3.up, rot, carsManager.garage.transform);
StartCoroutine(SendWorker(startNode, endNode, worker));
return(worker);
}
}
public AStar(NodeStreet startNode, NodeStreet endNode, GameObject vehicle)
{
// Initialize the set of nodes and the path
openedNodes = new List <NodeStreet>();
closedNodes = new HashSet <NodeStreet>();
path = new List <NodeStreet>();
this.vehicle = vehicle;
// Setting a reference for the start and the end node
this.startNode = startNode;
this.endNode = endNode;
// adding the start node to the opened ones list
openedNodes.Add(startNode);
}
/// <summary>
/// Finding the nearest node within radius
/// </summary>
/// <param name="pos"></param>
/// <param name="radius"></param>
/// <returns></returns>
public static NodeStreet NearestNode(Vector3 pos, float radius = 14)
{
NodeStreet nearNode = null;
float minDist = Mathf.Infinity;
var colls = Physics.OverlapSphere(pos, radius, LayerMask.GetMask("network"));
foreach (Collider c in colls)
{
if (Vector3.Distance(pos, c.gameObject.transform.position) < minDist)
{
minDist = Vector3.Distance(pos, c.gameObject.transform.position);
nearNode = c.gameObject.GetComponent <NodeHandler>().node;
}
}
return(nearNode);
}
private float GetDistance(NodeStreet a, NodeStreet b)
{
// Checking if nodes are connected
ArcStreet connectingStreet = null;
bool isConnected = false;
foreach (ArcStreet fromA in a.availableStreets)
{
if (fromA.arrivalNode.Equals(b))
{
isConnected = true;
connectingStreet = fromA;
break;
}
}
if (!isConnected)
{
return(Vector3.Distance(a.nodePosition, b.nodePosition));
}
//return Mathf.Infinity;
return(connectingStreet.lenght);
}
private IEnumerator Connect(Vector3 PosToCheck)
{
yield return(new WaitForFixedUpdate());
yield return(new WaitForFixedUpdate());
var colls = Physics.OverlapSphere(PosToCheck, 5f, LayerMask.GetMask("network"));
if (colls.Length == 0)
{
StartCoroutine(Connect(transform.position + transform.forward * 7 + transform.right * 3));
yield return(null);
}
else
{
NodeStreet nearestNode = colls[0].gameObject.GetComponent <NodeHandler>().node;
foreach (Collider c in colls)
{
var nextNode = c.gameObject.GetComponent <NodeHandler>().node;
if (Vector3.Distance(transform.position, c.gameObject.transform.position) <
Vector3.Distance(transform.position, nearestNode.nodePosition))
{
nearestNode = nextNode;
}
}
// Linking it to me
var linkingStret = new ArcStreet(nearestNode, node);
nearestNode.AddStreet(linkingStret);
// Linking me to it
var curStreet = new ArcStreet(node, nearestNode);
node.AddStreet(curStreet);
}
}
public ArcStreet(NodeStreet startNode, NodeStreet arrivalNode)
{
this.startNode = startNode;
this.arrivalNode = arrivalNode;
}
void GO()
{
startNode = startPoint.GetComponent <NodeHandler>().node;
endNode = endPoint.GetComponent <NodeHandler>().node;
}
private void CheckAtPositionForNodesFromStreetPoint(Collider[] colls, GameObject streetPoint, NodeStreet curNode)
{
foreach (Collider c in colls)
{
var nextNode = c.gameObject.GetComponent <NodeHandler>().node;
var curStreet = new ArcStreet(curNode, nextNode);
curNode.AddStreet(curStreet);
}
}
public bool PathFinder()
{
while (openedNodes.Count > 0)
{
// Finding the best node from all the opened nodes
NodeStreet currentNode = openedNodes[0];
for (int i = 1; i < openedNodes.Count; i++)
{
var node = openedNodes[i];
if (node.fCost < currentNode.fCost | (node.fCost == currentNode.fCost && node.hCost < currentNode.hCost))
{
currentNode = node;
}
}
openedNodes.Remove(currentNode);
closedNodes.Add(currentNode);
// cheching for the finding path condition
if (currentNode.Equals(endNode))
{
RetracePath();
return(true);
}
// Analyzing neighbors
var neighbours = currentNode.GetNeighbors();
foreach (NodeStreet neighbour in neighbours)
{
// the neighbor has already been explored
if (closedNodes.Contains(neighbour))
{
continue;
}
// Extra cost to avoid traffic jam on single lane
float carPresence = 0;
Vector3 ext = Vector3.one;
var dir = neighbour.nodePosition - currentNode.nodePosition;
if (Mathf.Abs(dir.x) > Mathf.Abs(dir.z))
{
ext += Vector3.right * (14 - 2);
}
else
{
ext += Vector3.forward * (14 - 2);
}
var colls = Physics.OverlapBox(neighbour.nodePosition, ext, Quaternion.identity, LayerMask.GetMask("vehicle"));
foreach (Collider c in colls)
{
if (c.gameObject != vehicle)
{
carPresence += carCost;
}
}
float newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour) + carPresence;
if (newMovementCostToNeighbour < neighbour.gCost | !openedNodes.Contains(neighbour))
{
neighbour.gCost = newMovementCostToNeighbour;
neighbour.hCost = GetDistance(neighbour, endNode);
neighbour.parent = currentNode;
if (!openedNodes.Contains(neighbour))
{
openedNodes.Add(neighbour);
}
}
}
}
return(false);
}
private IEnumerator SendWorker(NodeStreet startNode, NodeStreet endNode, GameObject worker)
{
yield return(new WaitForFixedUpdate());
Utils.SendVehicleFromTo(startNode, endNode, worker);
}
public void RemoveNode(int index)
{
arrivalNode = null;
}
