IEnumerator ProcessSpawnOnDeath()
{
bool hasSpawned = false;
while (!hasSpawned)
{
Collider[] colliderHit = Physics.OverlapSphere(transform.position, m_spawnCheckRadius);
bool hitObj = false;
for (int hIndex = 0; hIndex < colliderHit.Length; hIndex++)
{
if (colliderHit[hIndex].transform.GetComponent <TrafficSystemVehicle>())
{
hitObj = true;
}
}
if (!hitObj)
{
TrafficSystemVehicle vehicle = SpawnRandomVehicle();
// if(TrafficSystem.Instance && vehicle)
// TrafficSystem.Instance.RegisterVehicle( vehicle );
hasSpawned = true;
}
if (!hasSpawned)
{
yield return(new WaitForSeconds(m_spawnDelayBetweenTries));
}
}
yield return(null);
}
public void AssignVehicleToFollow( TrafficSystemVehicle a_vehicle )
{
#if WEB_DEMO_ENABLED
if(m_camera && m_TBOrbit && !m_TBOrbit.target && a_vehicle.name.Contains("Full Test Car"))
m_TBOrbit.target = a_vehicle.transform;
#endif
}
public TrafficSystemVehicle SpawnRandomVehicle(bool a_ignoreChangeOfSpawning = false)
{
if (m_vehiclePrefabs.Count <= 0)
{
return(null);
}
if (TrafficSystem.Instance && !TrafficSystem.Instance.CanSpawn())
{
return(null);
}
float chanceOfSpawn = Random.Range(0.0f, 1.0f);
if (!a_ignoreChangeOfSpawning && chanceOfSpawn > m_nodeVehicleSpawnChance)
{
return(null);
}
int randIndex = Random.Range(0, m_vehiclePrefabs.Count);
TrafficSystemVehicle vehicle = Instantiate(m_vehiclePrefabs[randIndex], transform.position, transform.rotation) as TrafficSystemVehicle;
vehicle.m_nextNode = m_startNode;
vehicle.m_velocityMax = Random.Range(m_randVelocityMin, m_randVelocityMax);
return(vehicle);
}
public void AttachVehicleCameraToPreviousVehicle()
{
if (!TrafficSystem.Instance)
{
return;
}
if (TrafficSystem.Instance.GetSpawnedVehicles().Count <= 0)
{
return;
}
if (!m_vehicleCamera)
{
return;
}
m_vehicleCameraIndex--;
if (m_vehicleCameraIndex < 0)
{
m_vehicleCameraIndex = TrafficSystem.Instance.GetSpawnedVehicles().Count - 1;
}
m_vehicleToFollow = TrafficSystem.Instance.GetSpawnedVehicles()[m_vehicleCameraIndex];
}
void Update()
{
if (Instance != this)
{
return;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
}
#if WEB_DEMO_ENABLED
if (Input.GetMouseButtonDown(0))
{
if (m_camera && m_TBOrbit)
{
Ray ray = m_camera.ScreenPointToRay(Input.mousePosition);
RaycastHit[] rays = Physics.RaycastAll(ray);
for (int hIndex = 0; hIndex < rays.Length; hIndex++)
{
TrafficSystemVehicle vehicle = rays[hIndex].transform.GetComponent <TrafficSystemVehicle>();
if (vehicle)
{
m_TBOrbit.target = vehicle.transform;
break;
}
}
}
}
#endif
}
void OnTriggerExit(Collider a_obj)
{
if (a_obj.GetComponent <TrafficSystemVehicle>())
{
TrafficSystemVehicle vehicle = a_obj.GetComponent <TrafficSystemVehicle>();
if (m_vehiclesInTrigger.Count > 0)
{
if (m_linkedTriggers.Count > 0)
{
bool foundVehicle = false;
for (int lIndex = 0; lIndex < m_linkedTriggers.Count; lIndex++)
{
if (m_linkedTriggers[lIndex].m_vehiclesInTrigger.Count > 0)
{
m_linkedTriggers[lIndex].m_vehiclesInTrigger[0].StopMoving = false;
foundVehicle = true;
}
}
if (!foundVehicle)
{
m_vehiclesInTrigger[0].StopMoving = false;
}
}
else
{
m_vehiclesInTrigger[0].StopMoving = false;
}
}
m_vehiclesInTrigger.Remove(vehicle);
}
}
void OnTriggerEnter(Collider a_obj)
{
if (a_obj.GetComponent <TrafficSystemVehicle>())
{
TrafficSystemVehicle vehicle = a_obj.GetComponent <TrafficSystemVehicle>();
if (m_vehiclesInTrigger.Count > 0)
{
if (IsAnyVehicleStopped(vehicle))
{
vehicle.StopMoving = true;
}
}
for (int lIndex = 0; lIndex < m_linkedTriggers.Count; lIndex++)
{
if (m_linkedTriggers[lIndex].m_vehiclesInTrigger.Count > 0)
{
for (int vIndex = 0; vIndex < m_linkedTriggers[lIndex].m_vehiclesInTrigger.Count; vIndex++)
{
if (m_linkedTriggers[lIndex].m_vehiclesInTrigger[vIndex].IsStopped() && vehicle != m_linkedTriggers[lIndex].m_vehiclesInTrigger[vIndex])
{
vehicle.StopMoving = true;
break;
}
}
}
}
m_vehiclesInTrigger.Add(vehicle);
}
}
void OnTriggerExit(Collider a_obj)
{
if (!m_node)
{
return;
}
#if TRAFFIC_SYSTEM
TrafficSystemVehicle vehicle = null;
if (a_obj.transform.GetComponent <TrafficSystemVehicle>())
{
vehicle = a_obj.transform.GetComponent <TrafficSystemVehicle>();
}
if (vehicle)
{
m_vehiclesWithinReach--;
}
if (m_vehiclesWithinReach <= 0)
{
m_node.m_waitAtNode = false;
}
#endif
}
public void AttachVehicleCameraToNextVehicle()
{
if (TrafficSystem.Instance.GetSpawnedVehicles().Count <= 0)
{
return;
}
if (!m_vehicleCamera)
{
return;
}
if (!m_vehicleCamera)
{
return;
}
m_vehicleCameraIndex++;
if (m_vehicleCameraIndex >= TrafficSystem.Instance.GetSpawnedVehicles().Count)
{
m_vehicleCameraIndex = 0;
}
m_vehicleToFollow = TrafficSystem.Instance.GetSpawnedVehicles()[m_vehicleCameraIndex];
}
public void RegisterVehicle(TrafficSystemVehicle a_vehicle)
{
if (TrafficSystemUI.Instance)
{
TrafficSystemUI.Instance.AssignVehicleToFollow(a_vehicle);
}
m_spawnedVehicles.Add(a_vehicle);
}
public void AssignVehicleToFollow(TrafficSystemVehicle a_vehicle)
{
#if WEB_DEMO_ENABLED
if (m_camera && m_TBOrbit && !m_TBOrbit.target && a_vehicle.name.Contains("Full Test Car"))
{
m_TBOrbit.target = a_vehicle.transform;
}
#endif
}
void OnTriggerEnter(Collider a_obj)
{
TrafficSystemVehicle vehicle = null;
if (a_obj.transform.GetComponent <TrafficSystemVehicle>())
{
vehicle = a_obj.transform.GetComponent <TrafficSystemVehicle>();
}
if (vehicle)
{
// if(m_status == Status.RED)
// {
// vehicle.TrafficLight = this;
// }
// else
// {
// if(vehicle.CanSeeVehicle( true ))
vehicle.AssignTrafficLight(this);
if (vehicle.IsTurningIntoIncomingTraffic() && !m_turnLeftAnytime)
{
m_intersection.AddToPriorityLightQueue(this);
}
// if(!m_checkStarted && m_turnLeftAnytime)
// {
// m_checkStarted = true;
// StartCoroutine( ProcessCheck( vehicle ) );
// }
// }
}
if (a_obj.transform.GetComponent <TrafficSystemVehiclePlayer>())
{
TrafficSystemVehiclePlayer playerVehicle = null;
playerVehicle = a_obj.transform.GetComponent <TrafficSystemVehiclePlayer>();
if (playerVehicle)
{
// playerVehicle.AssignTrafficLight(this);
if (playerVehicle.IsTurningIntoIncomingTraffic() && !m_turnLeftAnytime)
{
m_intersection.AddToPriorityLightQueue(this);
}
playerVehicle.ProcessHasEnteredTrafficLightTrigger(this);
}
// if(!m_checkStarted && m_turnLeftAnytime)
// {
// m_checkStarted = true;
// StartCoroutine( ProcessCheck( vehicle ) );
// }
}
}
IEnumerator ProcessCheck(TrafficSystemVehicle a_vehicle)
{
bool stillWaiting = true;
while (stillWaiting)
{
Collider[] hitColliders = Physics.OverlapSphere(m_checkPos.position, m_checkRadius);
stillWaiting = false;
int i = 0;
while (i < hitColliders.Length)
{
if (hitColliders[i].gameObject.GetComponent <TrafficSystemVehicle>())
{
stillWaiting = true;
break;
}
i++;
}
/*
* RaycastHit[] hitInfo = Physics.SphereCastAll( m_checkPos.position, 10.0f, m_checkPos.transform.up );
*
* stillWaiting = false;
* for(int hIndex = 0; hIndex < hitInfo.Length; hIndex++)
* {
* TrafficSystemVehicle vehicle = hitInfo[hIndex].transform.GetComponent<TrafficSystemVehicle>();
* if(vehicle)
* stillWaiting = true;
* }
*/
if (stillWaiting)
{
if (a_vehicle)
{
a_vehicle.WaitingForTraffic = true;
}
yield return(new WaitForSeconds(m_timeToWaitBetweenCheckes));
}
else
{
if (a_vehicle)
{
a_vehicle.WaitingForTraffic = false;
}
yield return(null);
}
}
m_checkStarted = false;
}
public bool VehicleHasFocus(TrafficSystemVehicle a_vehicle)
{
if (m_followCameraScript)
{
if (m_followCameraScript.m_vehicleToFollow == a_vehicle)
{
return(true);
}
}
return(false);
}
IEnumerator Start()
{
if (TrafficSystem.Instance)
{
TrafficSystem.Instance.RegisterVehicleSpawner(this);
}
if (m_totalToSpawn <= 0)
{
yield break;
}
for (int sIndex = 0; sIndex < m_totalToSpawn; sIndex++)
{
TrafficSystemVehicle vehicle = SpawnRandomVehicle(true);
vehicle.gameObject.SetActive(false);
m_vehiclePool.Add(vehicle);
}
yield return(new WaitForSeconds(m_onStartDelay));
while (m_totalSpawned < m_totalToSpawn)
{
Collider[] colliderHit = Physics.OverlapSphere(transform.position, m_spawnCheckRadius);
bool hitObj = false;
for (int hIndex = 0; hIndex < colliderHit.Length; hIndex++)
{
if (colliderHit[hIndex].transform.GetComponent <TrafficSystemVehicle>())
{
hitObj = true;
}
}
if (!hitObj)
{
if (m_totalSpawned < m_vehiclePool.Count)
{
TrafficSystemVehicle vehicle = m_vehiclePool[m_totalSpawned];
vehicle.gameObject.SetActive(true);
// if(TrafficSystem.Instance && vehicle)
// TrafficSystem.Instance.RegisterVehicle( vehicle );
}
m_totalSpawned++;
}
yield return(new WaitForSeconds(m_spawnDelayBetweenTries));
}
}
public bool IsAnyVehicleStopped( TrafficSystemVehicle a_vehicle )
{
for(int vIndex = 0; vIndex < m_vehiclesInTrigger.Count; vIndex++)
{
if(m_vehiclesInTrigger[vIndex].IsStopped() && a_vehicle != m_vehiclesInTrigger[vIndex])
{
return true;
break;
}
}
return false;
}
public bool IsAnyVehicleStopped(TrafficSystemVehicle a_vehicle)
{
for (int vIndex = 0; vIndex < m_vehiclesInTrigger.Count; vIndex++)
{
if (m_vehiclesInTrigger[vIndex].IsStopped() && a_vehicle != m_vehiclesInTrigger[vIndex])
{
return(true);
break;
}
}
return(false);
}
IEnumerator ProcessCheck( TrafficSystemVehicle a_vehicle )
{
bool stillWaiting = true;
while(stillWaiting)
{
Collider[] hitColliders = Physics.OverlapSphere(m_checkPos.position, m_checkRadius);
stillWaiting = false;
int i = 0;
while ( i < hitColliders.Length )
{
if(hitColliders[i].gameObject.GetComponent<TrafficSystemVehicle>())
{
stillWaiting = true;
break;
}
i++;
}
/*
RaycastHit[] hitInfo = Physics.SphereCastAll( m_checkPos.position, 10.0f, m_checkPos.transform.up );
stillWaiting = false;
for(int hIndex = 0; hIndex < hitInfo.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfo[hIndex].transform.GetComponent<TrafficSystemVehicle>();
if(vehicle)
stillWaiting = true;
}
*/
if(stillWaiting)
{
if(a_vehicle)
a_vehicle.WaitingForTraffic = true;
yield return new WaitForSeconds(m_timeToWaitBetweenCheckes);
}
else
{
if(a_vehicle)
a_vehicle.WaitingForTraffic = false;
yield return null;
}
}
m_checkStarted = false;
}
public void AttachVehicleCameraToPreviousVehicle()
{
if(!TrafficSystem.Instance)
return;
if(TrafficSystem.Instance.GetSpawnedVehicles().Count <= 0)
return;
if(!m_vehicleCamera)
return;
m_vehicleCameraIndex--;
if(m_vehicleCameraIndex < 0)
m_vehicleCameraIndex = TrafficSystem.Instance.GetSpawnedVehicles().Count - 1;
m_vehicleToFollow = TrafficSystem.Instance.GetSpawnedVehicles()[m_vehicleCameraIndex];
}
public void AttachVehicleCameraToNextVehicle()
{
if(TrafficSystem.Instance.GetSpawnedVehicles().Count <= 0)
return;
if(!m_vehicleCamera)
return;
if(!m_vehicleCamera)
return;
m_vehicleCameraIndex++;
if(m_vehicleCameraIndex >= TrafficSystem.Instance.GetSpawnedVehicles().Count)
m_vehicleCameraIndex = 0;
m_vehicleToFollow = TrafficSystem.Instance.GetSpawnedVehicles()[m_vehicleCameraIndex];
}
void OnTriggerEnter(Collider a_obj)
{
TrafficSystemVehicle vehicle = null;
if (a_obj.transform.GetComponent <TrafficSystemVehicle>())
{
vehicle = a_obj.transform.GetComponent <TrafficSystemVehicle>();
}
if (vehicle)
{
if (!m_checkStarted)
{
m_checkStarted = true;
StartCoroutine(ProcessCheck(vehicle));
}
}
}
void Update()
{
if (Application.isPlaying && m_enableVehicleCamera)
{
if (m_enableVehicleChangeKeyboard)
{
if (Input.GetKeyDown(KeyCode.Comma))
{
AttachVehicleCameraToPreviousVehicle();
}
else if (Input.GetKeyDown(KeyCode.Period))
{
AttachVehicleCameraToNextVehicle();
}
}
if (m_enableVehicleChangeMouse && Input.GetMouseButtonDown(0) && m_vehicleCamera)
{
Ray ray = m_vehicleCamera.ScreenPointToRay(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0.0f));
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit))
{
if (raycastHit.collider.GetComponent <TrafficSystemVehicle>())
{
m_vehicleToFollow = raycastHit.collider.GetComponent <TrafficSystemVehicle>();
}
}
}
if (m_vehicleCamera && m_vehicleToFollow)
{
m_vehicleCamera.transform.position = m_vehicleToFollow.transform.position - (m_vehicleToFollow.transform.forward.normalized * m_vehicleCameraOffsetBehind) + new Vector3(0.0f, m_vehicleCameraOffsetAbove, 0.0f);
m_vehicleCamera.transform.forward = Vector3.Slerp(m_vehicleCamera.transform.forward, m_vehicleToFollow.transform.forward + m_vehicleCameraRotation, m_vehicleCameraFaceForwardDelay * Time.deltaTime);
}
}
}
public void RegisterVehicle( TrafficSystemVehicle a_vehicle )
{
if(TrafficSystemUI.Instance)
TrafficSystemUI.Instance.AssignVehicleToFollow( a_vehicle );
m_spawnedVehicles.Add( a_vehicle );
}
public void UnRegisterVehicle( TrafficSystemVehicle a_vehicle )
{
m_spawnedVehicles.Remove( a_vehicle );
RespawnVehicle();
}
public bool VehicleIsOnSameSide( TrafficSystemVehicle a_vehicle )
{
if(a_vehicle && a_vehicle.m_nextNode && a_vehicle.m_nextNode.m_driveSide == m_nextNode.m_driveSide)
return true;
return false;
}
public TrafficSystemNode GetNextNode(TrafficSystemVehicle a_vehicle, bool a_checkLocalConnectedNode = true, List <TrafficSystemNode> a_blockedNodes = null)
{
if (m_connectedNodes.Count <= 0 && !m_connectedLocalNode && m_connectedChangeLaneNodes.Count <= 0)
{
return(null);
}
if (a_checkLocalConnectedNode && m_connectedLocalNode)
{
return(m_connectedLocalNode);
}
float randomChanceUseOfframp = Random.Range(0.0f, 1.0f);
float randomChanceOfDirChange = Random.Range(0.0f, 1.0f);
if (m_connectedChangeLaneNodes.Count > 0)
{
if (randomChanceOfDirChange <= a_vehicle.m_chanceOfDirChange)
{
TrafficSystemNode node = GetRandomChangeLangeNode();
if (node)
{
return(node);
}
}
else if (m_connectedNodes.Count <= 0 && !m_connectedLocalNode)
{
TrafficSystemNode node = GetRandomChangeLangeNode();
if (node)
{
return(node);
}
}
}
TrafficSystemNode offrampNode = null;
for (int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if (node && node.m_roadType == TrafficSystem.RoadType.OFFRAMP)
{
offrampNode = node;
break;
}
}
if (a_vehicle.m_randomLaneChange > 0.0f && m_connectedNodes.Count > 1)
{
float randomChance = Random.Range(0.0f, 1.0f);
if (randomChance <= a_vehicle.m_randomLaneChange)
{
List <int> nodeIndex = new List <int>(m_connectedNodes.Count);
for (int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
nodeIndex.Insert(nIndex, nIndex);
}
TrafficSystemNode sameLaneNode = null;
int count = 0;
while (count < m_connectedNodes.Count)
{
int nIndex = Random.Range(0, nodeIndex.Count);
int lIndex = nodeIndex[nIndex];
TrafficSystemNode node = m_connectedNodes[lIndex];
if (node)
{
bool blockNode = false;
if (a_blockedNodes != null)
{
for (int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if (node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if (!blockNode)
{
if (node.m_lane != m_lane || (node.m_lane == m_lane && node.m_roadType == TrafficSystem.RoadType.OFFRAMP))
{
return(node);
}
else
{
sameLaneNode = node;
}
}
}
nodeIndex.Remove(nIndex);
count++;
}
if (sameLaneNode)
{
return(sameLaneNode);
}
}
else
{
for (int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if (node && node.m_lane == m_lane)
{
bool blockNode = false;
if (a_blockedNodes != null)
{
for (int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if (node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if (!blockNode)
{
if (randomChanceUseOfframp <= a_vehicle.m_chanceOfUsingOfframp)
{
if (offrampNode)
{
return(offrampNode);
}
}
else if (node.IsNormalRoad())
{
return(node);
}
}
}
}
}
}
TrafficSystemNode nextNodeInOurLane = null;
TrafficSystemNode nextNodeNotInOurLane = null;
for (int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if (node)
{
bool blockNode = false;
if (a_blockedNodes != null && m_connectedNodes.Count > 1)
{
for (int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if (node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if (!blockNode)
{
if (node.m_lane == m_lane)
{
if (randomChanceUseOfframp <= a_vehicle.m_chanceOfUsingOfframp)
{
if (offrampNode)
{
return(offrampNode);
}
else if (node.IsNormalRoad())
{
return(node);
}
else
{
nextNodeInOurLane = node;
}
}
else if (node.IsNormalRoad())
{
return(node);
}
else
{
nextNodeNotInOurLane = node;
}
}
else
{
nextNodeNotInOurLane = node;
}
}
}
}
if (nextNodeInOurLane)
{
return(nextNodeInOurLane);
}
else
{
return(nextNodeNotInOurLane);
}
}
public void SpawnRandomVehicle( TrafficSystemVehicle a_vehiclePrefab )
{
if(!TrafficSystem.Instance)
return;
TrafficSystemNode node = null;
int randomLane = Random.Range(0, 4);
switch(randomLane)
{
case 0:
{
for(int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if(m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if(m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if(m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if(m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
}
break;
case 1:
{
for(int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if(m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if(m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if(m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if(m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
}
break;
case 2:
{
for(int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if(m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if(m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if(m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if(m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
}
break;
case 3:
{
for(int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if(m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if(m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if(m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
if(!node)
{
for(int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if(m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
}
break;
}
if(node)
{
Vector3 pos = node.transform.position;
pos -= a_vehiclePrefab.m_offsetPosVal;
TrafficSystemVehicle vehicle = Instantiate( a_vehiclePrefab, pos, node.transform.rotation ) as TrafficSystemVehicle;
vehicle.m_nextNode = node;
vehicle.m_velocityMax = Random.Range(TrafficSystem.Instance.m_randVehicleVelocityMin, TrafficSystem.Instance.m_randVehicleVelocityMax);
TrafficSystemNode nextNode = node.GetNextNode( vehicle, false );
if(nextNode)
vehicle.transform.forward = nextNode.transform.position - vehicle.transform.position;
// TrafficSystem.Instance.RegisterVehicle( vehicle );
}
}
public void SpawnRandomVehicle(TrafficSystemVehicle a_vehiclePrefab)
{
if (!TrafficSystem.Instance)
{
return;
}
TrafficSystemNode node = null;
int randomLane = Random.Range(0, 4);
switch (randomLane)
{
case 0:
{
for (int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if (m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if (m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if (m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if (m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
}
break;
case 1:
{
for (int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if (m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if (m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if (m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if (m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
}
break;
case 2:
{
for (int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if (m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if (m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if (m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if (m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
}
break;
case 3:
{
for (int nIndex = 0; nIndex < m_primaryRightLaneNodes.Count; nIndex++)
{
if (m_primaryRightLaneNodes[nIndex])
{
node = m_primaryRightLaneNodes[nIndex];
break;
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_primaryLeftLaneNodes.Count; nIndex++)
{
if (m_primaryLeftLaneNodes[nIndex])
{
node = m_primaryLeftLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryRightLaneNodes.Count; nIndex++)
{
if (m_secondaryRightLaneNodes[nIndex])
{
node = m_secondaryRightLaneNodes[nIndex];
break;
}
}
}
if (!node)
{
for (int nIndex = 0; nIndex < m_secondaryLeftLaneNodes.Count; nIndex++)
{
if (m_secondaryLeftLaneNodes[nIndex])
{
node = m_secondaryLeftLaneNodes[nIndex];
break;
}
}
}
}
break;
}
if (node)
{
Vector3 pos = node.transform.position;
pos -= a_vehiclePrefab.m_offsetPosVal;
TrafficSystemVehicle vehicle = Instantiate(a_vehiclePrefab, pos, node.transform.rotation) as TrafficSystemVehicle;
vehicle.m_nextNode = node;
vehicle.m_velocityMax = Random.Range(TrafficSystem.Instance.m_randVehicleVelocityMin, TrafficSystem.Instance.m_randVehicleVelocityMax);
TrafficSystemNode nextNode = node.GetNextNode(vehicle, false);
if (nextNode)
{
vehicle.transform.forward = nextNode.transform.position - vehicle.transform.position;
}
// TrafficSystem.Instance.RegisterVehicle( vehicle );
}
}
public virtual void Update()
{
// CanSeeVehicleViaSphere();
if(!TrafficLight)
m_trafficLightCoolDown += Time.deltaTime;
StopMoving = false;
if(WaitingForTraffic)
StopMoving = true;
if(CrashDetected)
{
m_timetoWaitAfterCrashTimer += Time.deltaTime;
CrashOverCheck();
}
if(IsStuck())
{
m_stuckDestroyTimer += Time.deltaTime;
if(m_stuckDestroyTimer >= m_stuckDestroyTimerMax)
{
if (Debug.isDebugBuild)
Debug.LogWarning("Vehicle Destroyed - m_stuckDestroyTimerMax - Vehicle had unusual behaviour");
Kill();
}
}
else if(IsStopped() && m_enableWaitingDestroyTimer)
{
m_waitingDestroyTimer += Time.deltaTime;
if(m_waitingDestroyTimer >= m_waitingDestroyTimerMax)
{
if (Debug.isDebugBuild)
Debug.LogWarning("Vehicle Destroyed - m_waitingDestroyTimerMax - (m_enableWaitingDestroyTimer = true) - Vehicle was waiting too long in the one position");
Kill();
}
}
else
{
m_waitingDestroyTimer = 0.0f;
m_stuckDestroyTimer = 0.0f;
}
if(!m_useRoadSpeedLimits && m_velocityMaxOriginal != m_velocityMax)
{
m_returnToOriginalVelocityTimer += Time.deltaTime;
if(m_returnToOriginalVelocityTimer >= m_returnToOriginalVelocityTimerMax)
{
m_velocityMax = m_velocityMaxOriginal;
m_returnToOriginalVelocityTimer = 0.0f;
}
}
if(VehicleHit) // if we are close to a car previously, wait before checking
{
m_waitTimer += Time.deltaTime;
if(m_waitTimer < m_waitTime)
return;
}
if(m_nextNode)
{
bool isOnHighway = false;
if(m_nextNode.IsHighway() && m_nextNode.IsHighwayChangeLaneAccepted() && m_vehicleCheckOvertakeOnHighway && m_nodeHighwaySearch != m_nextNode)
isOnHighway = true;
if(isOnHighway)
{
RaycastHit hitInfo;
VehicleHit = null;
if(Physics.SphereCast( (transform.position + m_vehicleCheckOffset), m_vehicleCheckRadiusOvertakeHighwayOnly, transform.forward, out hitInfo, m_vehicleCheckDistOvertakeHighwayOnly ))
{
TrafficSystemVehicle vehicle = hitInfo.transform.GetComponent<TrafficSystemVehicle>();
if(vehicle)
{
if(vehicle != this && vehicle.VehicleHit != this && vehicle != m_previousVehicleToTryOvertaking)
{
float randChanceToOvertake = 0.0f;
randChanceToOvertake = Random.Range(0.0f, 1.0f);
m_previousVehicleToTryOvertaking = vehicle;
if(randChanceToOvertake <= m_randomChanceToOvertake)
{
TrafficSystemNode node = m_nextNode.GetNextNodeHighway();
if(node)
{
SetNextNode( node );
m_nodeHighwaySearch = m_nextNode;
}
}
}
}
}
RaycastHit[] hitInfoAll = Physics.SphereCastAll( (transform.position + m_vehicleCheckOffset), m_vehicleCheckRadius, transform.forward, m_vehicleCheckDist );
VehicleHit = null;
for(int hIndex = 0; hIndex < hitInfoAll.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfoAll[hIndex].transform.GetComponent<TrafficSystemVehicle>();
if(vehicle)
{
if(vehicle != this && vehicle.VehicleHit != this)
{
StopMoving = true;
VehicleHit = vehicle;
m_velocityMax = VehicleHit.m_velocityMax;
m_waitTimer = 0.0f;
m_waitTime = Random.Range(m_waitTimeMin, m_waitTimeMax);
}
}
}
}
else
{
RaycastHit[] hitInfoAll = Physics.SphereCastAll( (transform.position + m_vehicleCheckOffset), m_vehicleCheckRadius, transform.forward, m_vehicleCheckDist );
VehicleHit = null;
for(int hIndex = 0; hIndex < hitInfoAll.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfoAll[hIndex].transform.GetComponent<TrafficSystemVehicle>();
if(vehicle)
{
if(vehicle != this && vehicle.VehicleHit != this)
{
StopMoving = true;
VehicleHit = vehicle;
m_velocityMax = VehicleHit.m_velocityMax;
m_waitTimer = 0.0f;
m_waitTime = Random.Range(m_waitTimeMin, m_waitTimeMax);
}
}
}
}
if(!VehicleHit && m_enableVehicleCheckMid)
{
RaycastHit[] hitInfo = Physics.SphereCastAll( (transform.position + m_vehicleCheckOffset), (m_vehicleCheckRadius * m_vehicleCheckRadiusMid ), transform.forward, m_vehicleCheckDist - m_vehicleCheckDistMid );
VehicleHit = null;
for(int hIndex = 0; hIndex < hitInfo.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfo[hIndex].transform.GetComponent<TrafficSystemVehicle>();
if(vehicle)
{
if(vehicle != this && vehicle.VehicleHit != this )
{
StopMoving = true;
VehicleHit = vehicle;
m_velocityMax = VehicleHit.m_velocityMax;
m_waitTimer = 0.0f;
m_waitTime = Random.Range(m_waitTimeMin, m_waitTimeMax);
}
}
}
}
}
if(!StopMoving && TrafficLight && !CrashDetected) // determine if there is there is room to move throught the intersection
{
if(TrafficLight.m_status == TrafficSystemTrafficLight.Status.RED)
{
//print ("TrafficLight = RED");
StopMoving = true;
}
else if(CanSeeVehicleViaSphere() && !TrafficLight.IgnoreCanFitAcrossIntersectionCheck())
{
//print ("CanSeeVehicleViaSphere: = TRUE");
StopMoving = true;
}
else if(!CanFitAcrossIntersection() && !TrafficLight.IgnoreCanFitAcrossIntersectionCheck())
{
//print ("CanFitAcrossIntersection: = FALSE");
StopMoving = true;
}
else if(TrafficLight.m_status == TrafficSystemTrafficLight.Status.YELLOW)
{
m_trafficLightYellowEnterDurationTimer += Time.deltaTime;
if(m_trafficLightYellowEnterDurationTimer <= m_trafficLightYellowEnterDuration)
{
DriveThroughLights();
}
else
//print ("TrafficLight = RED OR YELLOW");
StopMoving = true;
}
else if(TrafficLight.m_status == TrafficSystemTrafficLight.Status.GREEN)
{
DriveThroughLights();
}
// print ("TrafficLight: " + TrafficLight);
}
if(!StopMoving && m_nextNode && !CrashDetected)// && !m_pathingStarted)
{
VehicleInSights = CanSeeVehicleViaRay();
float ratio = 1.0f;
if(VehicleInSights)
{
if(VehicleInSights.VehicleInSights && VehicleInSights.VehicleInSights == this)
{
// do nothing as these two cars are facing eachother for unknown reasons so none of them should slow down with this ray detection.
}
else
{
float velocityRatio = 1.0f;
// if(m_velocity > 0.0f)
// velocityRatio = VehicleInSights.m_velocity / m_velocity;
Vector3 dirOfVehicleInSight = transform.position - VehicleInSights.transform.position;
ratio = Mathf.Clamp((dirOfVehicleInSight.magnitude / m_vehicleCheckDistRay), 0.0f, 1.0f);
if(ratio < m_vehicleCheckDistRayMimicSpeedThreshold)
m_velocityMax = VehicleInSights.m_velocityMax;
}
}
if(Accelerate) // are we accelerating?
m_velocity = m_velocity + ((m_accelerationRate * ratio) * Time.deltaTime); // add to the current velocity according while accelerating
// else
// m_velocity = m_velocity - (m_decelerationRate * Time.deltaTime); // subtract from the current velocity while decelerating
float velTmp = m_velocityMax * ratio;
if(velTmp > m_velocity)
m_velocity = m_velocity - ((m_accelerationRate * m_decelerationPercentage) * Time.deltaTime);
else
m_velocity = velTmp;
if(VehicleHit)
m_velocity = VehicleHit.m_velocity; // ensure the velocity is the same as the car in front
else
m_velocity = Mathf.Clamp(m_velocity, m_velocityMin, m_velocityMax); // ensure the velocity never goes out of the min/max boundaries
Vector3 dir = m_nextNode.transform.position;
dir.x += m_lanePosVariation;
dir.z += m_lanePosVariation;
dir = dir - (transform.position + m_offsetPosVal); // find the direction to the next node
Vector3 speed = dir.normalized * m_velocity; // work out how fast we should travel in the desired directoin
for(int rIndex = 0; rIndex < m_lightsRear.Length; rIndex++)
{
if(m_lightsRear[rIndex].gameObject.activeSelf)
m_lightsRear[rIndex].gameObject.SetActive(false);
}
Vector3 wheelAxis = Vector3.zero;
if(m_wheelAxis == AxisType.X)
wheelAxis = new Vector3(1.0f, 0.0f, 0.0f);
else if(m_wheelAxis == AxisType.Y)
wheelAxis = new Vector3(0.0f, 1.0f, 0.0f);
else if(m_wheelAxis == AxisType.Z)
wheelAxis = new Vector3(0.0f, 0.0f, 1.0f);
for(int wIndex = 0; wIndex < m_wheelsFront.Length; wIndex++)
m_wheelsFront[wIndex].transform.Rotate(wheelAxis, m_velocity * m_wheelRotMultiplier);
for(int wIndex = 0; wIndex < m_wheelsRear.Length; wIndex++)
m_wheelsRear[wIndex].transform.Rotate(wheelAxis, m_velocity * m_wheelRotMultiplier);
if(m_rigidbody) // if we have a rigidbody, use the following code to move us
{
m_rigidbody.velocity = speed; // set our rigidbody to this speed to move us by the determined speed
transform.forward = Vector3.Lerp( transform.forward, dir.normalized, m_rotationSpeed * Time.deltaTime ); // rotate our forward directoin over time to face the node we are moving towards
}
else // no rigidbody then use the following code to move us
{
if(m_collider || collider) // it generally is a bad idea to move something with a collider, so we should tell someone about it if this is happening. See Unity Docs for more info: http://docs.unity3d.com/ScriptReference/Collider.html
Debug.LogWarning("Traffic System Warning -> VehicleBase has a collider. You should think about moving the object with a rigidbody instead.");
transform.position += speed * Time.deltaTime; // move us by the determined speed
transform.forward = Vector3.Lerp( transform.forward, dir.normalized, m_rotationSpeed * Time.deltaTime ); // rotate our forward directoin over time to face the node we are moving towards
}
if(dir.magnitude < m_nextNodeThreshold) // if we are close enough to the node we were travelling towards then check for the next one
{
// if(m_nextNode.HasSplineToFollow( this ))
// {
// if(!m_traversePath)
// {
// m_traversePath = true;
// ProcessSpline();
// }
// }
// else
// if(!IsTrafficJamOnUpcomingNodes())
// {
// TrafficSystemNode preNextNode = m_nextNode;
//
// List<TrafficSystemNode> blockedNodes = new List<TrafficSystemNode>();
// for(int nIndex = 0; nIndex < m_nextNode.m_connectedNodes.Count; nIndex++)
// {
// TrafficSystemNode nodeToCheck = m_nextNode.m_connectedNodes[nIndex];
// if(VehicleExistsOnNode(nodeToCheck))
// blockedNodes.Add(nodeToCheck);
// }
//
SetNextNode( m_nextNode.GetNextNode( this, true/*, blockedNodes*/ ) ); // gets the next required node to go to and start the process all over again
//}
}
}
else if(CrashDetected)
{
// don't stop, but don't do anything
}
else if(StopMoving)
{
Stop();
}
if(m_killOnEmptyPath && !m_nextNode)
{
if (Debug.isDebugBuild)
Debug.LogWarning("Vehicle Destroyed - No path node");
Kill();
}
}
public TrafficSystemNode GetNextNode( TrafficSystemVehicle a_vehicle, bool a_checkLocalConnectedNode = true, List<TrafficSystemNode> a_blockedNodes = null )
{
if(m_connectedNodes.Count <= 0 && !m_connectedLocalNode && m_connectedChangeLaneNodes.Count <= 0)
return null;
if(a_checkLocalConnectedNode && m_connectedLocalNode)
return m_connectedLocalNode;
float randomChanceUseOfframp = Random.Range(0.0f, 1.0f);
float randomChanceOfDirChange = Random.Range(0.0f, 1.0f);
if(m_connectedChangeLaneNodes.Count > 0)
{
if(randomChanceOfDirChange <= a_vehicle.m_chanceOfDirChange)
{
TrafficSystemNode node = GetRandomChangeLangeNode();
if(node)
return node;
}
else if(m_connectedNodes.Count <= 0 && !m_connectedLocalNode)
{
TrafficSystemNode node = GetRandomChangeLangeNode();
if(node)
return node;
}
}
TrafficSystemNode offrampNode = null;
for(int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if(node && node.m_roadType == TrafficSystem.RoadType.OFFRAMP)
{
offrampNode = node;
break;
}
}
if(a_vehicle.m_randomLaneChange > 0.0f && m_connectedNodes.Count > 1)
{
float randomChance = Random.Range(0.0f, 1.0f);
if(randomChance <= a_vehicle.m_randomLaneChange)
{
List<int> nodeIndex = new List<int>(m_connectedNodes.Count);
for(int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
nodeIndex.Insert(nIndex, nIndex);
}
TrafficSystemNode sameLaneNode = null;
int count = 0;
while(count < m_connectedNodes.Count)
{
int nIndex = Random.Range(0, nodeIndex.Count);
int lIndex = nodeIndex[nIndex];
TrafficSystemNode node = m_connectedNodes[lIndex];
if(node)
{
bool blockNode = false;
if(a_blockedNodes != null)
{
for(int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if(node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if(!blockNode)
{
if(node.m_lane != m_lane || (node.m_lane == m_lane && node.m_roadType == TrafficSystem.RoadType.OFFRAMP) )
return node;
else
sameLaneNode = node;
}
}
nodeIndex.Remove(nIndex);
count++;
}
if(sameLaneNode)
return sameLaneNode;
}
else
{
for(int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if(node && node.m_lane == m_lane)
{
bool blockNode = false;
if(a_blockedNodes != null)
{
for(int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if(node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if(!blockNode)
{
if(randomChanceUseOfframp <= a_vehicle.m_chanceOfUsingOfframp)
{
if(offrampNode)
return offrampNode;
}
else if(node.IsNormalRoad())
return node;
}
}
}
}
}
TrafficSystemNode nextNodeInOurLane = null;
TrafficSystemNode nextNodeNotInOurLane = null;
for(int nIndex = 0; nIndex < m_connectedNodes.Count; nIndex++)
{
TrafficSystemNode node = m_connectedNodes[nIndex];
if(node)
{
bool blockNode = false;
if(a_blockedNodes != null && m_connectedNodes.Count > 1)
{
for(int cIndex = 0; cIndex < a_blockedNodes.Count; cIndex++)
{
if(node == a_blockedNodes[cIndex])
{
blockNode = true;
break;
}
}
}
if(!blockNode)
{
if(node.m_lane == m_lane)
{
if(randomChanceUseOfframp <= a_vehicle.m_chanceOfUsingOfframp)
{
if(offrampNode)
return offrampNode;
else if(node.IsNormalRoad())
return node;
else
nextNodeInOurLane = node;
}
else if(node.IsNormalRoad())
return node;
else
nextNodeNotInOurLane = node;
}
else
nextNodeNotInOurLane = node;
}
}
}
if(nextNodeInOurLane)
return nextNodeInOurLane;
else
return nextNodeNotInOurLane;
}
public bool VehicleHasFocus( TrafficSystemVehicle a_vehicle )
{
if(m_followCameraScript)
{
if(m_followCameraScript.m_vehicleToFollow == a_vehicle)
return true;
}
return false;
}
public void UnRegisterVehicle(TrafficSystemVehicle a_vehicle)
{
m_spawnedVehicles.Remove(a_vehicle);
RespawnVehicle();
}
public override void Update()
{
if (!TrafficLight)
{
m_trafficLightCoolDown += Time.deltaTime;
}
StopMoving = false;
if (WaitingForTraffic)
{
StopMoving = true;
}
if (CrashDetected)
{
m_timetoWaitAfterCrashTimer += Time.deltaTime;
CrashOverCheck();
}
if (IsStuck())
{
m_stuckDestroyTimer += Time.deltaTime;
if (m_stuckDestroyTimer >= m_stuckDestroyTimerMax)
{
if (Debug.isDebugBuild)
{
Debug.LogWarning("Vehicle Destroyed - m_stuckDestroyTimerMax - Vehicle had unusual behaviour");
}
Kill();
}
}
else
{
m_stuckDestroyTimer = 0.0f;
}
if (!m_useRoadSpeedLimits && m_velocityMaxOriginal != m_velocityMax)
{
m_returnToOriginalVelocityTimer += Time.deltaTime;
if (m_returnToOriginalVelocityTimer >= m_returnToOriginalVelocityTimerMax)
{
m_velocityMax = m_velocityMaxOriginal;
m_returnToOriginalVelocityTimer = 0.0f;
}
}
if (VehicleHit) // if we are close to a car previously, wait before checking
{
m_waitTimer += Time.deltaTime;
if (m_waitTimer < m_waitTime)
{
return;
}
}
if (m_nextNode)
{
RaycastHit[] hitInfoAll = Physics.SphereCastAll((transform.position + m_vehicleCheckOffset), m_vehicleCheckRadius, transform.forward, m_vehicleCheckDist);
VehicleHit = null;
for (int hIndex = 0; hIndex < hitInfoAll.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfoAll[hIndex].transform.GetComponent <TrafficSystemVehicle>();
if (vehicle)
{
if (vehicle != this && vehicle.VehicleHit != this)
{
StopMoving = true;
VehicleHit = vehicle;
m_velocityMax = VehicleHit.m_velocityMax;
m_waitTimer = 0.0f;
m_waitTime = Random.Range(m_waitTimeMin, m_waitTimeMax);
}
}
}
if (!VehicleHit && m_enableVehicleCheckMid)
{
RaycastHit[] hitInfo = Physics.SphereCastAll((transform.position + m_vehicleCheckOffset), (m_vehicleCheckRadius * m_vehicleCheckRadiusMid), transform.forward, m_vehicleCheckDist - m_vehicleCheckDistMid);
VehicleHit = null;
for (int hIndex = 0; hIndex < hitInfo.Length; hIndex++)
{
TrafficSystemVehicle vehicle = hitInfo[hIndex].transform.GetComponent <TrafficSystemVehicle>();
if (vehicle)
{
if (vehicle.VehicleHit != this)
{
StopMoving = true;
VehicleHit = vehicle;
m_velocityMax = VehicleHit.m_velocityMax;
m_waitTimer = 0.0f;
m_waitTime = Random.Range(m_waitTimeMin, m_waitTimeMax);
}
}
}
}
}
if (!StopMoving && !WaitForUserInput && TrafficLight && !CrashDetected) // determine if there is there is room to move throught the intersection
{
if (TrafficLight.m_status == TrafficSystemTrafficLight.Status.RED ||
TrafficLight.m_status == TrafficSystemTrafficLight.Status.YELLOW)
{
// print ("TrafficLight = RED OR YELLOW");
StopMoving = true;
}
else if (CanSeeVehicleViaSphere())
{
// print ("CanSeeVehicleViaSphere: = TRUE");
StopMoving = true;
}
else if (!CanFitAcrossIntersection())
{
// print ("CanFitAcrossIntersection: = FALSE");
StopMoving = true;
}
else if (TrafficLight.m_status == TrafficSystemTrafficLight.Status.GREEN)
{
if (TrafficLight.m_intersection)
{
if (TrafficLight.m_intersection.m_intersectionSystem == TrafficSystemIntersection.IntersectionSystem.SINGLE)
{
// print ("GO!");
TrafficLight = null;
StopMoving = false;
}
else if (TrafficLight.m_intersection.m_intersectionSystem == TrafficSystemIntersection.IntersectionSystem.DUAL)
{
if (IsTurningIntoIncomingTraffic())
{
// print ("IsTurningIntoIncomingTraffic: = TRUE");
StopMoving = true;
}
else
{
// print ("GO!");
TrafficLight = null;
StopMoving = false;
}
}
}
else
{
Debug.LogWarning("Traffic System Traffic Light is missing a parent intersection! See the example traffic system intersection and the structure setup as this is what you need to mimic");
}
}
// print ("TrafficLight: " + TrafficLight);
}
if (!StopMoving && !WaitForUserInput && m_nextNode && !CrashDetected) // && !m_pathingStarted)
{
VehicleInSights = CanSeeVehicleViaRay();
float ratio = 1.0f;
if (VehicleInSights)
{
if (VehicleInSights.VehicleInSights && VehicleInSights.VehicleInSights == this)
{
// do nothing as these two cars are facing eachother for unknown reasons so none of them should slow down with this ray detection.
}
else
{
float velocityRatio = 1.0f;
// if(m_velocity > 0.0f)
// velocityRatio = VehicleInSights.m_velocity / m_velocity;
Vector3 dirOfVehicleInSight = transform.position - VehicleInSights.transform.position;
ratio = Mathf.Clamp((dirOfVehicleInSight.magnitude / m_vehicleCheckDistRay), 0.0f, 1.0f);
if (ratio < m_vehicleCheckDistRayMimicSpeedThreshold)
{
m_velocityMax = VehicleInSights.m_velocityMax;
}
}
}
if (Accelerate) // are we accelerating?
{
m_velocity = m_velocity + ((m_accelerationRate * ratio) * Time.deltaTime); // add to the current velocity according while accelerating
}
float velTmp = m_velocityMax * ratio;
if (velTmp > m_velocity)
{
m_velocity = m_velocity - ((m_accelerationRate * m_decelerationPercentage) * Time.deltaTime);
}
else
{
m_velocity = velTmp;
}
if (VehicleHit)
{
m_velocity = VehicleHit.m_velocity; // ensure the velocity is the same as the car in front
}
else
{
m_velocity = Mathf.Clamp(m_velocity, m_velocityMin, m_velocityMax); // ensure the velocity never goes out of the min/max boundaries
}
Vector3 dir = m_nextNode.transform.position;
dir.x += m_lanePosVariation;
dir.z += m_lanePosVariation;
dir = dir - (transform.position + m_offsetPosVal); // find the direction to the next node
Vector3 speed = dir.normalized * m_velocity; // work out how fast we should travel in the desired directoin
for (int rIndex = 0; rIndex < m_lightsRear.Length; rIndex++)
{
if (m_lightsRear[rIndex].gameObject.activeSelf)
{
m_lightsRear[rIndex].gameObject.SetActive(false);
}
}
Vector3 wheelAxis = Vector3.zero;
if (m_wheelAxis == AxisType.X)
{
wheelAxis = new Vector3(1.0f, 0.0f, 0.0f);
}
else if (m_wheelAxis == AxisType.Y)
{
wheelAxis = new Vector3(0.0f, 1.0f, 0.0f);
}
else if (m_wheelAxis == AxisType.Z)
{
wheelAxis = new Vector3(0.0f, 0.0f, 1.0f);
}
for (int wIndex = 0; wIndex < m_wheelsFront.Length; wIndex++)
{
m_wheelsFront[wIndex].transform.Rotate(wheelAxis, m_velocity * m_wheelRotMultiplier);
}
for (int wIndex = 0; wIndex < m_wheelsRear.Length; wIndex++)
{
m_wheelsRear[wIndex].transform.Rotate(wheelAxis, m_velocity * m_wheelRotMultiplier);
}
float rotSpeed = (m_velocity / m_velocityMax) * m_rotationSpeed;
if (m_rigidbody) // if we have a rigidbody, use the following code to move us
{
m_rigidbody.velocity = speed; // set our rigidbody to this speed to move us by the determined speed
transform.forward = Vector3.Lerp(transform.forward, dir.normalized, rotSpeed * Time.deltaTime); // rotate our forward directoin over time to face the node we are moving towards
}
else // no rigidbody then use the following code to move us
{
if (m_collider || GetComponent <Collider>()) // it generally is a bad idea to move something with a collider, so we should tell someone about it if this is happening. See Unity Docs for more info: http://docs.unity3d.com/ScriptReference/Collider.html
{
Debug.LogWarning("Traffic System Warning -> VehicleBase has a collider. You should think about moving the object with a rigidbody instead.");
}
transform.position += speed * Time.deltaTime; // move us by the determined speed
transform.forward = Vector3.Lerp(transform.forward, dir.normalized, rotSpeed * Time.deltaTime); // rotate our forward directoin over time to face the node we are moving towards
}
if (dir.magnitude < m_nextNodeThreshold) // if we are close enough to the node we were travelling towards then check for the next one
{
if (m_nextNode.IsDirectionChange())
{
WaitForUserInput = true;
}
else
{
SetNextNode(m_nextNode.GetNextNode(this, true /*, blockedNodes*/)); // gets the next required node to go to and start the process all over again
}
ChangeLaneActivated = false;
}
}
else if (CrashDetected)
{
// don't stop, but don't do anything
}
else if (StopMoving || WaitForUserInput)
{
Stop();
}
if (m_killOnEmptyPath && !m_nextNode)
{
if (Debug.isDebugBuild)
{
Debug.LogWarning("Vehicle Destroyed - No path node");
}
Kill();
}
}
void Update()
{
if(Application.isPlaying && m_enableVehicleCamera)
{
if(m_enableVehicleChangeKeyboard)
{
if(Input.GetKeyDown(KeyCode.Comma))
AttachVehicleCameraToPreviousVehicle();
else if(Input.GetKeyDown(KeyCode.Period))
AttachVehicleCameraToNextVehicle();
}
if(m_enableVehicleChangeMouse && Input.GetMouseButtonDown(0) && m_vehicleCamera)
{
Ray ray = m_vehicleCamera.ScreenPointToRay (new Vector3(Input.mousePosition.x,Input. mousePosition.y, 0.0f));
RaycastHit raycastHit;
if(Physics.Raycast(ray, out raycastHit))
{
if(raycastHit.collider.GetComponent<TrafficSystemVehicle>())
m_vehicleToFollow = raycastHit.collider.GetComponent<TrafficSystemVehicle>();
}
}
if(m_vehicleCamera && m_vehicleToFollow)
{
m_vehicleCamera.transform.position = m_vehicleToFollow.transform.position - (m_vehicleToFollow.transform.forward.normalized * m_vehicleCameraOffsetBehind) + new Vector3(0.0f, m_vehicleCameraOffsetAbove, 0.0f);
m_vehicleCamera.transform.forward = Vector3.Slerp( m_vehicleCamera.transform.forward, m_vehicleToFollow.transform.forward + m_vehicleCameraRotation, m_vehicleCameraFaceForwardDelay * Time.deltaTime );
}
}
}
