private static bool RayCastNode(ref NetNode node, Segment3 ray, float snapElevation, out float t, out float priority)
{
NetInfo info = node.Info;
float num = (float)node.m_elevation + info.m_netAI.GetSnapElevation();
float t2;
if (info.m_netAI.IsUnderground())
{
t2 = Mathf.Clamp01(Mathf.Abs(snapElevation + num) / 12f);
}
else
{
t2 = Mathf.Clamp01(Mathf.Abs(snapElevation - num) / 12f);
}
float collisionHalfWidth = Mathf.Max(3f, info.m_netAI.GetCollisionHalfWidth());
float num2 = Mathf.Lerp(info.GetMinNodeDistance(), collisionHalfWidth, t2);
if (Segment1.Intersect(ray.a.y, ray.b.y, node.m_position.y, out t))
{
float num3 = Vector3.Distance(ray.Position(t), node.m_position);
if (num3 < num2)
{
priority = Mathf.Max(0f, num3 - collisionHalfWidth);
return(true);
}
}
t = 0f;
priority = 0f;
return(false);
}
private static bool CheckOverlap(Segment3 segment, ushort ignoreVehicle, float maxVelocity)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 vector3_1 = segment.Min();
Vector3 vector3_2 = segment.Max();
int num1 = Mathf.Max((int)(((double)vector3_1.x - 10.0) / 32.0 + 270.0), 0);
int num2 = Mathf.Max((int)(((double)vector3_1.z - 10.0) / 32.0 + 270.0), 0);
int num3 = Mathf.Min((int)(((double)vector3_2.x + 10.0) / 32.0 + 270.0), 539);
int num4 = Mathf.Min((int)(((double)vector3_2.z + 10.0) / 32.0 + 270.0), 539);
bool overlap = false;
for (int index1 = num2; index1 <= num4; ++index1)
{
for (int index2 = num1; index2 <= num3; ++index2)
{
ushort otherID = instance.m_vehicleGrid[index1 * 540 + index2];
int num5 = 0;
while (otherID != (ushort)0)
{
otherID = CheckOverlap(segment, ignoreVehicle, maxVelocity, otherID, ref instance.m_vehicles.m_buffer[(int)otherID], ref overlap);
if (++num5 > 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
}
}
return(overlap);
}
public Quadrilateral(Point3 TopLeftIn, Point3 TopRightIn, Point3 BottomLeftIn, Point3 BottomRightIn)
{
this.TopLeft = TopLeftIn;
this.TopRight = TopRightIn;
this.BottomLeft = BottomLeftIn;
this.BottomRight = BottomRightIn;
Plane3 plane = new Plane3(this.TopLeft, this.TopRight, this.BottomLeft);
//Vector3 ab = new Vector3(new Segment3(this.BottomLeft, this.TopLeft));
//Vector3 ac = new Vector3(new Segment3(this.BottomLeft, this.BottomRight));
//Vector3 normal = Vector3.Cross(ab, ac);
//Vector3 ad = new Vector3(new Segment3(this.BottomLeft, this.TopRight));
//double dotp = Vector3.Dot(ad, normal);
//PetrelLogger.InfoOutputWindow("The dot product of this cell's face is " + System.Convert.ToString(dotp));
if (Plane3Extensions.Contains(plane,this.BottomRight, 1E-7))
{
LeftSegment = new Segment3(this.TopLeft, this.BottomLeft);
RightSegment = new Segment3(this.TopRight, this.BottomRight);
BottomSegment = new Segment3(this.BottomLeft, this.BottomRight);
TopSegment = new Segment3(this.TopLeft, this.TopRight);
CalculateCentroid();
}
else
{ double x = (this.TopLeft.X + this.BottomLeft.X + this.TopRight.X + this.BottomRight.X) / 4.0;
double y = (this.TopLeft.Y + this.BottomLeft.Y + this.TopRight.Y + this.BottomRight.Y) / 4.0;
double z = (this.TopLeft.Z + this.BottomLeft.Z + this.TopRight.Z + this.BottomRight.Z) / 4.0;
this.Centroid = new Point3(x,y,z);
}
}
public override ToolBase.ToolErrors CheckBuildPosition(
ushort relocateID,
ref Vector3 position,
ref float angle,
float waterHeight,
float elevation,
ref Segment3 connectionSegment,
out int productionRate,
out int constructionCost)
{
ToolBase.ToolErrors toolErrors1 = ToolBase.ToolErrors.None;
Vector3 pos;
Vector3 dir;
bool isQuay;
if (this.m_info.m_placementMode == BuildingInfo.PlacementMode.Shoreline &&
BuildingTool.SnapToCanal(position, out pos, out dir, out isQuay, 40f, false))
{
angle = Mathf.Atan2(dir.x, -dir.z);
pos += dir * this.m_quayOffset;
position.x = pos.x;
position.z = pos.z;
if (!isQuay)
{
toolErrors1 |= ToolBase.ToolErrors.ShoreNotFound;
}
}
ToolBase.ToolErrors toolErrors2 = toolErrors1 | base.CheckBuildPosition(relocateID, ref position, ref angle,
waterHeight, elevation, ref connectionSegment, out productionRate, out constructionCost);
return(toolErrors2);
}
//from source code
private static bool CheckOverlap(ushort vehicleID, ref Vehicle vehicleData, Segment3 segment, ushort ignoreVehicle)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 min = segment.Min();
Vector3 max = segment.Max();
int num = Mathf.Max((int)((min.x - 30f) / 32f + 270f), 0);
int num2 = Mathf.Max((int)((min.z - 30f) / 32f + 270f), 0);
int num3 = Mathf.Min((int)((max.x + 30f) / 32f + 270f), 539);
int num4 = Mathf.Min((int)((max.z + 30f) / 32f + 270f), 539);
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid[i * 540 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = SingleTrainTrackAI.CheckOverlap(vehicleID, ref vehicleData, segment, ignoreVehicle, num5, ref instance.m_vehicles.m_buffer[(int)num5], ref result, min, max);
if (++num6 > 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(result);
}
private void OnDrawGizmos()
{
Segment3 segment = CreateSegment3(P0, P1);
Sphere3 sphere = CreateSphere3(Sphere);
bool test = Intersection.TestSegment3Sphere3(ref segment, ref sphere);
Segment3Sphere3Intr info;
bool find = Intersection.FindSegment3Sphere3(ref segment, ref sphere, out info);
FiguresColor();
DrawSegment(ref segment);
DrawSphere(ref sphere);
if (find)
{
ResultsColor();
if (info.IntersectionType == IntersectionTypes.Point)
{
DrawPoint(info.Point0);
}
else if (info.IntersectionType == IntersectionTypes.Segment)
{
DrawSegment(info.Point0, info.Point1);
DrawPoint(info.Point0);
DrawPoint(info.Point1);
}
}
LogInfo(info.IntersectionType);
if (test != find)
{
LogError("test != find");
}
}
//public static Vector3 GetUpPosition(Vector3 r)
//{
// NavMeshHit hitInfo;
// Vector3 r1 = new Vector3(r.x, r.y + 100, r.z);
// if (NavMesh.Raycast(r, r1, out hitInfo, -1))
// {
// r = hitInfo.position;
// }
// else
// {
// //Debug.LogError("GetUpPosition No UpPosition ");
// }
// return r;
//}
private static Vector3 GetClosetPointBySegment1(Vector3 target)
{
var distance = float.MaxValue;
DateTime start = DateTime.Now;
Vector3 r = target;
if (navMeshInfo == null)
{
navMeshInfo = new NavMeshInfo();
}
for (int i = 0; i < navMeshInfo.segments.Count; i++)
{
Segment3 segment = navMeshInfo.segments[i];
Vector3 point = target;
Vector3 closestPoint;
float dist0 = Distance.Point3Segment3(ref point, ref segment, out closestPoint);
if (dist0 < distance)
{
distance = dist0;
r = closestPoint;
}
}
TimeSpan time = DateTime.Now - start;
LogText += (string.Format(
"GetClosetPointBySegment,indices count:{0},distance:{1},closestPoint{2},time:{3}ms ",
navMeshInfo.indicesCount,
distance, r, time.TotalMilliseconds));
return(r);
}
public static float LengthXZ(this Segment3 line)
{
Vector3 _start = new Vector3(line.a.x, 0f, line.a.z);
Vector3 _end = new Vector3(line.b.x, 0f, line.b.z);
return(Vector3.Distance(_start, _end));
}
public void Distance_Separate()
{
var segment = new Segment3();
var sphere = new Sphere();
float distance = 1;
foreach (var center in originPoints3)
{
sphere.center = center;
for (int radius = 1; radius < 12; radius += 10)
{
sphere.radius = radius;
foreach (var direction in directionPoints3)
{
Vector3 origin = sphere.center + direction * (sphere.radius + distance);
Vector3 tangent = GetTangent(direction);
for (int perpendicularAngle = 0; perpendicularAngle < 360; perpendicularAngle += 45)
{
Vector3 segmentDirection = Quaternion.AngleAxis(perpendicularAngle, direction) * tangent;
segment.a = origin;
segment.b = segment.a + segmentDirection * length;
AreEqual_Distance(segment, sphere, distance);
segment.a = origin - segmentDirection;
AreEqual_Distance(segment, sphere, distance);
}
}
}
}
}
public virtual bool Contains(Segment3 ray, out float t)
{
var line = new StraightTrajectory(GetHitPosition(ray, out t), Center);
var contains = !BorderLines.Any(b => Intersection.Intersect(line, b));
return(contains);
}
private void True_IntersectTwoPoints(Segment3 segment, Sphere sphere, Vector3 expectedA, Vector3 expectedB)
{
Assert.True(Intersect.SegmentSphere(segment.a, segment.b, sphere.center, sphere.radius, out IntersectionSegmentSphere intersection), format, segment, sphere);
Assert.AreEqual(IntersectionType.TwoPoints, intersection.type, format, segment, sphere);
AreEqual(intersection.pointA, expectedA);
AreEqual(intersection.pointB, expectedB);
}
public void Distance_OnePoint()
{
var segment = new Segment3();
var sphere = new Sphere(Vector3.zero, 2);
foreach (var center in originPoints3)
{
sphere.center = center;
foreach (var direction in directionPoints3)
{
Vector3 origin = sphere.center + direction * sphere.radius;
Vector3 tangent = GetTangent(direction);
for (int perpendicularAngle = 0; perpendicularAngle < 360; perpendicularAngle += 45)
{
Vector3 segmentDirection = Quaternion.AngleAxis(perpendicularAngle, direction) * tangent;
segment.a = origin;
segment.b = segment.a + segmentDirection * length;
AreEqual_Distance(segment, sphere);
segment.a = origin - segmentDirection;
segment.b = segment.a + segmentDirection * length;
AreEqual_Distance(segment, sphere);
}
segment.a = sphere.center;
segment.b = sphere.center + direction * sphere.radius;
AreEqual_Distance(segment, sphere);
segment.a = sphere.center + direction * 0.5f;
AreEqual_Distance(segment, sphere);
}
}
}
public void ClosestPoints_TwoPoints()
{
var segment = new Segment3();
var sphere = new Sphere();
float offset = 1;
foreach (var center in originPoints3)
{
sphere.center = center;
for (int radius = 1; radius < 12; radius += 10)
{
sphere.radius = radius;
foreach (var direction in directionPoints3)
{
Vector3 point = sphere.center - direction * sphere.radius;
segment.a = sphere.center - direction * sphere.radius;
segment.b = sphere.center + direction * sphere.radius;
AreEqual_ClosestPoints(segment, sphere, point, point);
segment.a = sphere.center - direction * (sphere.radius + offset);
segment.b = sphere.center + direction * (sphere.radius + offset);
AreEqual_ClosestPoints(segment, sphere, point, point);
}
}
}
}
public void Intersect_TwoPoints()
{
var segment = new Segment3();
var sphere = new Sphere();
float offset = 1;
foreach (var center in originPoints3)
{
sphere.center = center;
for (int radius = 1; radius < 12; radius += 10)
{
sphere.radius = radius;
foreach (var direction in directionPoints3)
{
Vector3 point1 = sphere.center - direction * sphere.radius;
Vector3 point2 = sphere.center + direction * sphere.radius;
segment.a = point1;
segment.b = point2;
True_IntersectTwoPoints(segment, sphere, point1, point2);
segment.a = sphere.center - direction * (sphere.radius + offset);
segment.b = sphere.center + direction * (sphere.radius + offset);
True_IntersectTwoPoints(segment, sphere, point1, point2);
}
}
}
}
private void OnDrawGizmos()
{
Segment3 segment = CreateSegment3(P0, P1);
Plane3 polygonPlane = CreatePlane3(PolygonPlane);
Polygon3 polygon = new Polygon3(PolygonPoints.Length, polygonPlane);
for (int i = 0; i < PolygonPoints.Length; ++i)
{
polygon.SetVertexProjected(i, PolygonPoints[i].position);
}
polygon.UpdateEdges();
Segment3Polygon3Intr info;
bool find = Intersection.FindSegment3Polygon3(ref segment, polygon, out info);
FiguresColor();
DrawPolygon(polygon);
DrawSegment(ref segment);
if (find)
{
ResultsColor();
DrawPoint(info.Point);
}
LogInfo(info.IntersectionType);
}
private void OnDrawGizmos()
{
Segment3 segment = CreateSegment3(P0, P1);
Plane3 plane = CreatePlane3(Plane);
IntersectionTypes intersectionType;
bool test = Intersection.TestSegment3Plane3(ref segment, ref plane, out intersectionType);
Segment3Plane3Intr info;
bool find = Intersection.FindSegment3Plane3(ref segment, ref plane, out info);
FiguresColor();
DrawPlane(ref plane, Plane);
DrawSegment(ref segment);
if (find)
{
ResultsColor();
DrawPoint(info.Point);
}
LogInfo(info.IntersectionType + " " + info.SegmentParameter);
if (test != find)
{
LogError("test != find");
}
if (intersectionType != info.IntersectionType)
{
LogError("intersectionType != info.IntersectionType");
}
}
// CHECKME: check if this method allows to make people get away from traffic
private static ushort CheckCitizen(Segment3 segment, float lastLen, float nextLen, ref float maxSpeed, ref bool blocked, float maxBraking, ushort otherID, ref CitizenInstance otherData, Vector3 min, Vector3 max)
{
CitizenInfo info = otherData.Info;
CitizenInstance.Frame lastFrameData = otherData.GetLastFrameData();
Vector3 position = lastFrameData.m_position;
Vector3 b = lastFrameData.m_position + lastFrameData.m_velocity;
Segment3 segment2 = new Segment3(position, b);
Vector3 vector = segment2.Min();
vector.x -= info.m_radius;
vector.z -= info.m_radius;
Vector3 vector2 = segment2.Max();
vector2.x += info.m_radius;
vector2.y += info.m_height;
vector2.z += info.m_radius;
float num;
float num2;
if (min.x < vector2.x + 1f && min.y < vector2.y && min.z < vector2.z + 1f && vector.x < max.x + 1f && vector.y < max.y + 2f && vector.z < max.z + 1f && segment.DistanceSqr(segment2, out num, out num2) < (1f + info.m_radius) * (1f + info.m_radius))
{
float num3 = lastLen + nextLen * num;
if (num3 >= 0.01f)
{
num3 -= 2f;
float b2 = Mathf.Max(1f, CalculateMaxSpeed(num3, 0f, maxBraking));
maxSpeed = Mathf.Min(maxSpeed, b2);
}
}
return(otherData.m_nextGridInstance);
}
private static bool CheckOverlap(Segment3 segment, ushort ignoreVehicle, float maxVelocity)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 vector = segment.Min();
Vector3 vector2 = segment.Max();
int num = Mathf.Max((int)((vector.x - 10f) / 32f + 270f), 0);
int num2 = Mathf.Max((int)((vector.z - 10f) / 32f + 270f), 0);
int num3 = Mathf.Min((int)((vector2.x + 10f) / 32f + 270f), 539);
int num4 = Mathf.Min((int)((vector2.z + 10f) / 32f + 270f), 539);
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid [i * 540 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = CheckOverlap(segment, ignoreVehicle, maxVelocity, num5, ref instance.m_vehicles.m_buffer [(int)num5], ref result);
if (++num6 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(result);
}
private void OnDrawGizmos()
{
Segment3 segment = CreateSegment3(P0, P1);
AAB3 box = CreateAAB3(Box_Point0, Box_Point1);
bool test = Intersection.TestSegment3AAB3(ref segment, ref box);
Segment3AAB3Intr info;
bool find = Intersection.FindSegment3AAB3(ref segment, ref box, out info);
FiguresColor();
DrawSegment(ref segment);
DrawAAB(ref box);
if (find)
{
ResultsColor();
if (info.IntersectionType == IntersectionTypes.Point)
{
DrawPoint(info.Point0);
}
else if (info.IntersectionType == IntersectionTypes.Segment)
{
DrawSegment(info.Point0, info.Point1);
DrawPoint(info.Point0);
DrawPoint(info.Point1);
}
}
LogInfo(info.IntersectionType);
if (test != find)
{
LogError("test != find");
}
}
private void updateBuildingColliders()
{
Vector3 segmentVector;
Segment3 circularScanSegment;
ushort buildingIndex;
Vector3 hitPos = Vector3.zero;
HashSet <ushort> hitBuildings = new HashSet <ushort>();
Building building;
Vector3 buildingPosition;
Quaternion buildingRotation;
for (int i = 0; i < NUM_BUILDING_COLLIDERS; i++)
{
float x = (float)Math.Cos(Mathf.Deg2Rad * (10f * i));
float z = (float)Math.Sin(Mathf.Deg2Rad * (10f * i));
segmentVector = new Vector3(x, 1f, z) * SCAN_DISTANCE;
circularScanSegment = new Segment3(transform.position,
transform.position + segmentVector);
buildingManager.RayCast(circularScanSegment, ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default, Building.Flags.None, out hitPos, out buildingIndex);
if (hitPos != Vector3.zero)
{
building = buildingManager.m_buildings.m_buffer[buildingIndex];
if (!hitBuildings.Contains(buildingIndex) && building.Info.m_class.m_service != ItemClass.Service.Road &&
building.Info.name != "478820060.CableStay32m_Data" && building.Info.name != "BridgePillar.CableStay32m_Data")
{
building.CalculateMeshPosition(out buildingPosition, out buildingRotation);
mBuildingColliders[i].meshCollider.sharedMesh = building.Info.m_mesh;
mBuildingColliders[i].colliderOwner.transform.position = buildingPosition;
mBuildingColliders[i].colliderOwner.transform.rotation = buildingRotation;
hitBuildings.Add(buildingIndex);
}
}
}
}
private void spawnVehicle(Vector3 position, Vector3 rotation, VehicleInfo vehicleInfo)
{
NetManager manager = Singleton <NetManager> .instance;
TerrainManager terrainManager = Singleton <TerrainManager> .instance;
Vector3[] hitPos = new Vector3[2];
ushort nodeIndex;
ushort segmentIndex;
bool rayCastSuccess;
gameObject.transform.parent = (Transform)null;
gameObject.transform.position = position;
gameObject.transform.eulerAngles = new Vector3(rotation.x, rotation.y);
vehicleMesh = vehicleInfo.m_mesh;
gameObject.AddComponent <MeshFilter>().mesh = vehicleMesh;
gameObject.AddComponent <MeshRenderer>().material = vehicleInfo.m_material;
gameObject.SetActive(true);
int numLights = vehicleInfo.m_lightPositions.Length > 1 ? 2 : vehicleInfo.m_lightPositions.Length;
for (int i = 0; i < numLights; i++)
{
Vector3 lightPosition = vehicleInfo.m_lightPositions[i];
GameObject lightObj = new GameObject();
Light light = lightObj.AddComponent <Light>();
lightObj.transform.parent = gameObject.transform;
lightObj.transform.localPosition = lightPosition;
light.type = LightType.Spot;
light.enabled = false;
light.spotAngle = 20f;
light.range = 50f;
light.intensity = 5f;
light.color = Color.white;
mLights.Add(light);
}
this.vehicleRigidBody = gameObject.AddComponent <Rigidbody>();
this.vehicleRigidBody.isKinematic = false;
this.vehicleRigidBody.useGravity = false;
this.vehicleRigidBody.drag = 2f;
this.vehicleRigidBody.angularDrag = 2.5f;
this.vehicleRigidBody.freezeRotation = true;
this.vehicleCollider = gameObject.AddComponent <BoxCollider>();
Segment3 ray = new Segment3(position + new Vector3(0f, 1.5f, 0f), position + new Vector3(0f, -100f, 0f));
rayCastSuccess = manager.RayCast(ray, 0f, ItemClass.Service.Road, ItemClass.Service.PublicTransport, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos[0], out nodeIndex, out segmentIndex);
rayCastSuccess = rayCastSuccess || manager.RayCast(ray, 0f, ItemClass.Service.Beautification, ItemClass.Service.Water, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos[1], out nodeIndex, out segmentIndex);
terrainHeight = terrainManager.SampleDetailHeight(transform.position);
terrainHeight = Mathf.Max(terrainHeight, Mathf.Max(hitPos[0].y, hitPos[1].y));
if (position.y < terrainHeight + 1)
{
transform.position = new Vector3(position.x, terrainHeight, position.z);
}
prevPosition = transform.position;
//calculateSlope();
}
private void True_IntersectPoint(Segment3 segment, Sphere sphere, Vector3 expected)
{
IntersectionSegmentSphere intersection;
Assert.True(Intersect.SegmentSphere(segment.a, segment.b, sphere.center, sphere.radius, out intersection), format, segment, sphere);
Assert.AreEqual(IntersectionType.Point, intersection.type, format, segment, sphere);
AreEqual(intersection.pointA, expected);
}
/// <summary>
/// Interpolates and Extrapolates the position along a parametric line defined by two points.
/// </summary>
/// <param name="segment">Line segment from p0 to p1</param>
/// <param name="t"></param>
/// <returns></returns>
public static Vector3 LinePosition(Segment3 segment, float t)
{
float num = 1 - t;
Vector3 _p0 = segment.a;
Vector3 _p1 = segment.b;
Vector3 result = new Vector3(_p1.x + num * (_p0.x - _p1.x), _p1.y + num * (_p0.y - _p1.y), _p1.z + num * (_p0.z - _p1.z));
return(result);
}
private void AreEqual_ClosestPoints(Segment3 segment, Sphere sphere, Vector3 expectedSegment, Vector3 expectedSphere)
{
Vector3 segmentPoint;
Vector3 centerPoint;
Closest.SegmentSphere(segment.a, segment.b, sphere.center, sphere.radius, out segmentPoint, out centerPoint);
AreEqual(segmentPoint, expectedSegment);
AreEqual(centerPoint, expectedSphere);
}
// Token: 0x06000106 RID: 262 RVA: 0x00005190 File Offset: 0x00003390
public Edge3(Segment3 segment)
{
this.Orientation = Orientation.Forward;
this.CurveOnSurface = null;
this.Curve = new LineCurve3(segment.Origin, segment.Direction);
this.StartParameter = -segment.Extent;
this.EndParameter = segment.Extent;
this.StartVertex = this.Curve.EvalAt(this.StartParameter);
this.EndVertex = this.Curve.EvalAt(this.EndParameter);
}
/// <summary>
/// Constrains Segment to XZ plane.
/// </summary>
/// <param name="bezier"></param>
/// <returns>A bezier curve with y-components set to zero</returns>
public static Segment3 SegmentXZ(Segment3 lineSegment)
{
Segment3 result = new Segment3();
result = lineSegment;
result.a.y = 0f;
result.b.y = 0f;
return(result);
}
public bool Intersects(Segment3 segment)
{
Vector3 direction = segment.V - segment.U;
var length = direction.Normalize();
float near = 0;
float far = length;
return(IntersectsLine(ref segment.U, ref direction, ref near, ref far));
}
public static bool IsTrafficHandSideOf(Segment3 segment, Segment3 ray, float tRay, bool invert)
{
Vector3 segmentVector = segment.b - segment.a;
Vector3 rayVector = ray.Position(tRay) - segment.a;
// Debug.Log($"startnode->endnode: {segmentVector}, startnode->ray: {rayVector}");
float crossProduct = rayVector.x * segmentVector.z - segmentVector.x * rayVector.z;
// Debug.Log($"cross product: {crossProduct}");
return(invert ? crossProduct < 0 : crossProduct > 0);
}
private void RaycastHoverInstance(Ray mouseRay)
{
var input = new ToolBase.RaycastInput(mouseRay, Camera.main.farClipPlane);
Vector3 origin = input.m_ray.origin;
Vector3 normalized = input.m_ray.direction.normalized;
Vector3 vector = input.m_ray.origin + (normalized * input.m_length);
var ray = new Segment3(origin, vector);
VehicleManager.instance.RayCast(ray, 0, 0, out _, out m_hoverVehicle, out m_hoverParkedVehicle);
}
private ushort CheckCollisions(ushort instanceID, ref CitizenInstance citizenData, Segment3 segment, Vector3 min, Vector3 max, ushort otherID, ref CitizenInstance otherData, ref Vector3 pushAmount, ref float pushDivider)
{
if (otherID == instanceID)
{
return(otherData.m_nextGridInstance);
}
if (((citizenData.m_flags | otherData.m_flags) & CitizenInstance.Flags.Transition) == CitizenInstance.Flags.None && (citizenData.m_flags & CitizenInstance.Flags.Underground) != (citizenData.m_flags & CitizenInstance.Flags.Underground))
{
return(otherData.m_nextGridInstance);
}
CitizenInfo info = otherData.Info;
CitizenInstance.Frame lastFrameData = otherData.GetLastFrameData();
Vector3 position = lastFrameData.m_position;
Vector3 b = lastFrameData.m_position + lastFrameData.m_velocity;
Segment3 segment2 = new Segment3(position, b);
Vector3 vector = segment2.Min();
vector.x -= info.m_radius;
vector.z -= info.m_radius;
Vector3 vector2 = segment2.Max();
vector2.x += info.m_radius;
vector2.y += info.m_height;
vector2.z += info.m_radius;
if (min.x < vector2.x && max.x > vector.x && min.z < vector2.z && max.z > vector.z && min.y < vector2.y && max.y > vector.y)
{
float num = this.m_info.m_radius + info.m_radius;
float num3;
float t;
float num2 = segment.DistanceSqr(segment2, out num3, out t);
if (num2 < num * num)
{
float num4 = num - Mathf.Sqrt(num2);
float num5 = 1f - num2 / (num * num);
Vector3 a = segment.Position(num3 * 0.9f);
Vector3 b2 = segment2.Position(t);
a.y = 0f;
b2.y = 0f;
Vector3 vector3 = a - b2;
Vector3 vector4 = new Vector3(segment.b.z - segment.a.z, 0f, segment.a.x - segment.b.x);
if (Vector3.Dot(vector3, vector4) >= 0f)
{
vector3 += vector4;
}
else
{
vector3 -= vector4;
}
pushAmount += vector3.normalized * (num4 * num5);
pushDivider += num5;
}
}
return(otherData.m_nextGridInstance);
}
private static void PrepareSegmentsForCropVisibleTest(CameraModel camera, Interval chordInterval, out Segment2 chord, out Segment2 segment2, out Segment3 segment3)
{
chord = new Segment2(camera.Domain.GetEdge(0).PointAt(0.177), camera.Domain.GetEdge(1).PointAt(0.643));
segment2 = new Segment2(chord.PointAt(chordInterval.Min), chord.PointAt(chordInterval.Max));
var spaceExteriorPoint1 = 2.56 * camera.LineOfSight(segment2.Start);
var spaceExteriorPoint2 = 4.86 * camera.LineOfSight(segment2.End);
segment3 = new Segment3(spaceExteriorPoint1, spaceExteriorPoint2);
}
public static void Render(RenderManager.CameraInfo cameraInfo, GuideLine guideLine)
{
var renderManager = RenderManager.instance;
var minHeight = -1f;
var maxHeight = 1280f;
var direction = guideLine.Origin.Flatten().DirectionTo(guideLine.Intersect.Flatten());
var line = new Segment3(guideLine.Origin, guideLine.Origin + direction*100000f);
renderManager.OverlayEffect.DrawSegment(cameraInfo, Settings.SecondaryColor,
line, guideLine.Width, 0,
minHeight,
maxHeight, true, true);
renderManager.OverlayEffect.DrawSegment(cameraInfo, Settings.SecondaryColor,
line, 0.01f, 8f,
minHeight,
maxHeight, true, true);
}
public static RayHitInfo Raycast(Vector3 startPos, Vector3 endPos)
{
var rayHitInfo = new RayHitInfo();
Segment3 segment = new Segment3(startPos, endPos);
Vector3 direction = (endPos - startPos).normalized;
float length = Vector3.Distance(startPos, endPos);
float closestRayHitDistance = float.MaxValue;
Vector3 tempHitPos;
ushort a;
ushort b;
RaycastHit hit;
Ray ray = new Ray(startPos, endPos - startPos);
if (Physics.Raycast(ray, out hit))
{
closestRayHitDistance = Vector3.SqrMagnitude(startPos - hit.point);
rayHitInfo.rayHit = true;
rayHitInfo.point = hit.point;
rayHitInfo.raycastHit = hit;
if (hit.collider.tag == "Player")
{
rayHitInfo.hitType = RayFlags.Player;
}
else
{
rayHitInfo.hitType = RayFlags.Physics;
}
}
if (Singleton<NetManager>.instance.RayCast(segment, 0f, ItemClass.Service.None, ItemClass.Service.None, ItemClass.SubService.None,
ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.OnGround, NetSegment.Flags.None,
out tempHitPos, out a, out b))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Road;
rayHitInfo.point = tempHitPos;
}
}
if (Singleton<BuildingManager>.instance.RayCast(segment, ItemClass.Service.None,
ItemClass.SubService.None, ItemClass.Layer.Default, Building.Flags.None, out tempHitPos, out a))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Building;
rayHitInfo.point = tempHitPos;
}
}
if (Singleton<PropManager>.instance.RayCast(segment, ItemClass.Service.None,
ItemClass.SubService.None, ItemClass.Layer.Default, PropInstance.Flags.None, out tempHitPos, out a))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Prop;
rayHitInfo.point = tempHitPos;
}
}
if (Singleton<TerrainManager>.instance.RayCast(segment, out tempHitPos))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Terrain;
rayHitInfo.point = tempHitPos;
}
}
uint c;
if (Singleton<TreeManager>.instance.RayCast(segment, ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default, TreeInstance.Flags.None, out tempHitPos,out c))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Tree;
rayHitInfo.point = tempHitPos;
}
}
if (Singleton<CitizenManager>.instance.RayCast(segment, CitizenInstance.Flags.None, out tempHitPos, out a))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Citizen;
rayHitInfo.point = tempHitPos;
rayHitInfo.index = a;
}
}
if (Singleton<VehicleManager>.instance.RayCast(segment, Vehicle.Flags.None, VehicleParked.Flags.All, out tempHitPos, out a, out b))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.Vehicle;
rayHitInfo.point = tempHitPos;
rayHitInfo.index = a != 0 ? a : b;
}
}
if (Singleton<VehicleManager>.instance.RayCast(segment, Vehicle.Flags.All, VehicleParked.Flags.None, out tempHitPos, out a, out b))
{
float distance = Vector3.SqrMagnitude(startPos - tempHitPos);
if (distance < closestRayHitDistance)
{
closestRayHitDistance = distance;
rayHitInfo.rayHit = true;
rayHitInfo.hitType = RayFlags.VehicleParked;
rayHitInfo.point = tempHitPos;
rayHitInfo.index = a != 0 ? a : b;
}
}
return rayHitInfo;
}
protected void CheckCollisions(ushort instanceID, ref CitizenInstance citizenData, Vector3 sourcePos, Vector3 targetPos, ushort buildingID, ref Vector3 pushAmount, ref float pushDivider)
{
Segment3 segment = new Segment3 (sourcePos, targetPos);
Vector3 min = segment.Min ();
min.x -= this.m_info.m_radius;
min.z -= this.m_info.m_radius;
Vector3 max = segment.Max ();
max.x += this.m_info.m_radius;
max.y += this.m_info.m_height;
max.z += this.m_info.m_radius;
CitizenManager instance = Singleton<CitizenManager>.instance;
int num = Mathf.Max ((int)((min.x - 3f) / 8f + 1080f), 0);
int num2 = Mathf.Max ((int)((min.z - 3f) / 8f + 1080f), 0);
int num3 = Mathf.Min ((int)((max.x + 3f) / 8f + 1080f), 2159);
int num4 = Mathf.Min ((int)((max.z + 3f) / 8f + 1080f), 2159);
for (int i = num2; i <= num4; i++) {
for (int j = num; j <= num3; j++) {
ushort num5 = instance.m_citizenGrid [i * 2160 + j];
int num6 = 0;
while (num5 != 0) {
num5 = this.CheckCollisions (instanceID, ref citizenData, segment, min, max, num5, ref instance.m_instances.m_buffer [(int)num5], ref pushAmount, ref pushDivider);
if (++num6 > 65536) {
CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
VehicleManager instance2 = Singleton<VehicleManager>.instance;
int num7 = Mathf.Max ((int)((min.x - 10f) / 32f + 270f), 0);
int num8 = Mathf.Max ((int)((min.z - 10f) / 32f + 270f), 0);
int num9 = Mathf.Min ((int)((max.x + 10f) / 32f + 270f), 539);
int num10 = Mathf.Min ((int)((max.z + 10f) / 32f + 270f), 539);
for (int k = num8; k <= num10; k++) {
for (int l = num7; l <= num9; l++) {
ushort num11 = instance2.m_vehicleGrid [k * 540 + l];
int num12 = 0;
while (num11 != 0) {
num11 = this.CheckCollisions (instanceID, ref citizenData, segment, min, max, num11, ref instance2.m_vehicles.m_buffer [(int)num11], ref pushAmount, ref pushDivider);
if (++num12 > 65536) {
CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
for (int m = num8; m <= num10; m++) {
for (int n = num7; n <= num9; n++) {
ushort num13 = instance2.m_parkedGrid [m * 540 + n];
int num14 = 0;
while (num13 != 0) {
num13 = this.CheckCollisions (instanceID, ref citizenData, segment, min, max, num13, ref instance2.m_parkedVehicles.m_buffer [(int)num13], ref pushAmount, ref pushDivider);
if (++num14 > 65536) {
CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
if (buildingID != 0) {
BuildingManager instance3 = Singleton<BuildingManager>.instance;
BuildingInfo info = instance3.m_buildings.m_buffer [(int)buildingID].Info;
if (info.m_props != null) {
Vector3 position = instance3.m_buildings.m_buffer [(int)buildingID].m_position;
float angle = instance3.m_buildings.m_buffer [(int)buildingID].m_angle;
int length = instance3.m_buildings.m_buffer [(int)buildingID].Length;
Matrix4x4 matrix4x = default(Matrix4x4);
matrix4x.SetTRS (Building.CalculateMeshPosition (info, position, angle, length), Quaternion.AngleAxis (angle * 57.29578f, Vector3.down), Vector3.one);
for (int num15 = 0; num15 < info.m_props.Length; num15++) {
BuildingInfo.Prop prop = info.m_props [num15];
Randomizer randomizer = new Randomizer ((int)buildingID << 6 | prop.m_index);
if (randomizer.Int32 (100u) < prop.m_probability && length >= prop.m_requiredLength) {
Vector3 vector = matrix4x.MultiplyPoint (prop.m_position);
if (vector.x >= min.x - 2f && vector.x <= max.x + 2f) {
if (vector.z >= min.z - 2f && vector.z <= max.z + 2f) {
PropInfo propInfo = prop.m_finalProp;
TreeInfo treeInfo = prop.m_finalTree;
float num16 = 0f;
float num17 = 0f;
if (propInfo != null) {
propInfo = propInfo.GetVariation (ref randomizer);
if (propInfo.m_isMarker || propInfo.m_isDecal || !propInfo.m_hasRenderer) {
goto IL_7D3;
}
num16 = propInfo.m_generatedInfo.m_size.x * 0.5f;
num17 = propInfo.m_generatedInfo.m_size.y;
} else {
if (treeInfo != null) {
treeInfo = treeInfo.GetVariation (ref randomizer);
num16 = (treeInfo.m_generatedInfo.m_size.x + treeInfo.m_generatedInfo.m_size.z) * 0.125f;
num17 = treeInfo.m_generatedInfo.m_size.y;
}
}
if (!prop.m_fixedHeight) {
vector.y = Singleton<TerrainManager>.instance.SampleDetailHeight (vector);
} else {
if (info.m_requireHeightMap) {
vector.y = Singleton<TerrainManager>.instance.SampleDetailHeight (vector) + prop.m_position.y;
}
}
if (vector.y + num17 >= min.y && vector.y <= max.y) {
num16 = this.m_info.m_radius + num16;
float num19;
float num18 = segment.DistanceSqr (vector, out num19);
if (num18 < num16 * num16) {
float num20 = num16 - Mathf.Sqrt (num18);
float num21 = 1f - num18 / (num16 * num16);
Vector3 a = segment.Position (num19 * 0.9f);
a.y = 0f;
vector.y = 0f;
Vector3 vector2 = Vector3.Normalize (a - vector);
Vector3 rhs = Vector3.Normalize (new Vector3 (segment.b.x - segment.a.x, 0f, segment.b.z - segment.a.z));
Vector3 vector3 = new Vector3 (rhs.z, 0f, -rhs.x) * Mathf.Abs (Vector3.Dot (vector2, rhs) * 0.5f);
if (Vector3.Dot (vector2, vector3) >= 0f) {
vector2 += vector3;
} else {
vector2 -= vector3;
}
pushAmount += vector2 * (num20 * num21);
pushDivider += num21;
}
}
}
}
}
IL_7D3:
;
}
}
}
}
void FixedUpdate()
{
m_isGrounded = false;
float terrainHeight = ModTerrainUtil.GetHeight(transform.position.x, transform.position.z);
NetManager netManager = Singleton<NetManager>.instance;
//Segment3 ray = new Segment3(gameObject.transform.position + new Vector3(0f, 1.0f, 0f), gameObject.transform.position - new Vector3(0, 0.1f, 0));
Vector3 hitPos;
Vector3 hitPos2;
ushort nodeIndex;
ushort segmentIndex;
//Need to check fron below up becuse how the way road raycast work
Segment3 ray2 = new Segment3(gameObject.transform.position, gameObject.transform.position - new Vector3(0f, 1.0f, 0f));
Segment3 ray = new Segment3(gameObject.transform.position + new Vector3(0f, 1.5f, 0f), gameObject.transform.position + new Vector3(0f, -100f, 0f));
if ( NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Road, ItemClass.Service.PublicTransport, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos, out nodeIndex, out segmentIndex)
| NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Beautification, ItemClass.Service.Water, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos2, out nodeIndex, out segmentIndex))
{
terrainHeight = Mathf.Max(terrainHeight, Mathf.Max(hitPos.y, hitPos2.y));
}
if (transform.position.y < terrainHeight + 1 && m_velocity.y <= 0)
{
transform.position = new Vector3(transform.position.x, terrainHeight + 1 - TERRAIN_HEIGHT_OFFSET, transform.position.z);
m_velocity.y = Math.Max(0, m_velocity.y);
m_isGrounded = true;
}
RaycastHit rayHit3;
//Move the collider up a bit so it dosen't touch the thing it gonna sweep test aganst
m_sweepTestCollider.transform.position = transform.position + Vector3.up * 0.05f;
if (m_sweepTestRigidbody.SweepTest(Vector3.down, out rayHit3, 0.1f))
{
m_isGrounded = true;
m_velocity.y = Math.Max(0, m_velocity.y);
}
m_sweepTestCollider.transform.position = new Vector3(0, 10000, 0);
if (!m_isGrounded && Physics.CheckSphere(transform.position - new Vector3(0, 1, 0), 0.45f))
{
m_isGrounded = true;
m_velocity.y = Math.Max(0, m_velocity.y);
}
RaycastHit rayHit2;
if (m_rigidBody.SweepTest(Vector3.up, out rayHit2, 0.05f)) //Stops your Y speed when you hit the roof so you fall own directly
{
m_velocity.y = Math.Min(0, m_velocity.y);
}
if (PlayerInput.JumpKey.GetKeyDown() && (m_isGrounded || m_hookHit))
{
if (m_hookHit)
{
m_hookHit = false;
m_hookLineRender.enabled = false;
SendPlayerHookReleased();
}
Jump();
}
float movementSpeed = PlayerInput.WalkKey.GetKey() ? WALK_SPEED : RUN_SPEED;
if (!m_hookHit)
{
int verticalInput = PlayerInput.MoveForwardsKey.GetKey() ? 1 : PlayerInput.MoveBackwardsKey.GetKey() ? -1 : 0;
int horInput = PlayerInput.MoveRightKey.GetKey() ? 1 : PlayerInput.MoveLeftKey.GetKey() ? -1 : 0;
Vector3 inputDir = new Vector3(horInput, 0, verticalInput);
inputDir.Normalize();
m_velocity += transform.rotation * inputDir * movementSpeed * Time.fixedDeltaTime;
m_velocity.x = (m_velocity.x*(1 - GROUND_SLOW));
m_velocity.z = (m_velocity.z*(1 - GROUND_SLOW));
if (!m_isGrounded)
m_velocity.y -= GRAVITY * Time.fixedDeltaTime; //Applys extra gravity becuse the normal one isen't enouch, and don't want to change the global gravity
m_jumpExtraTimer -= Time.fixedDeltaTime;
if (PlayerInput.JumpKey.GetKey())
{
m_jumpExtraTimer = JUMP_INPUT_EXTRA_TIME;
}
if (m_jumpExtraTimer > 0 && m_isGrounded)
{
Jump();
}
if (PlayerInput.JumpKey.GetKey() && m_hookHit)
{
m_hookHit = false;
m_hookLineRender.enabled = false;
SendPlayerHookReleased();
Jump();
}
RaycastHit rayHit;
Vector3 newVelocity = m_velocity;
for (int i = 0; i < 5; i++)
{
Vector3 newDelta = newVelocity * Time.fixedDeltaTime;
m_sweepTestCollider.transform.position = transform.position + -newDelta.normalized * 0.1f;
if (m_sweepTestRigidbody.SweepTest(newDelta.normalized, out rayHit, newDelta.magnitude + 0.1f))
{
m_sweepTestCollider.transform.position = transform.position + new Vector3(0, STEP_SIZE, 0) + -newDelta.normalized * 0.1f;
if (m_isGrounded && !m_sweepTestRigidbody.SweepTest(newDelta.normalized, out rayHit, newDelta.magnitude + 0.1f))
{
float newY = transform.position.y + STEP_SIZE;
m_sweepTestCollider.transform.position = new Vector3(transform.position.x + newDelta.x, transform.position.y + STEP_SIZE, transform.position.z + newDelta.z);
if (m_sweepTestRigidbody.SweepTest(Vector3.down, out rayHit, STEP_SIZE))
{
newY -= rayHit.distance;
}
m_stepNewPosition = new Vector3(transform.position.x + newDelta.x, newY, transform.position.z + newDelta.z);
break;
}
var distanceToPlane = Vector3.Dot(newDelta, rayHit.normal);
Vector3 desiredMotion = (distanceToPlane * rayHit.normal) / Time.fixedDeltaTime;
newVelocity -= desiredMotion;
newVelocity += rayHit.normal*0.001f;
}
m_sweepTestCollider.transform.position = new Vector3(0, -10000, 0);
}
if (PlayerInput.JumpKey.GetKey() && m_lastJumpTimer <= JUMP_EXTRA_HEIGHT_TIME)
{
m_velocity.y = JUMP_FORCE;
}
if (!m_isGrounded)
{
newVelocity.y = newVelocity.y - newVelocity.y * AIR_Y_SLOW * Time.deltaTime;
}
m_velocity = newVelocity;
m_rigidBody.velocity = m_velocity;
}
}
private int GetLineCount(Vector3 stopPosition, Vector3 stopDirection, TransportInfo.TransportType transportType)
{
NetManager instance = Singleton<NetManager>.instance;
TransportManager instance2 = Singleton<TransportManager>.instance;
stopDirection.Normalize();
Segment3 segment = new Segment3(stopPosition - stopDirection * 16f, stopPosition + stopDirection * 16f);
Vector3 vector = segment.Min();
Vector3 vector2 = segment.Max();
int num = Mathf.Max((int)((vector.x - 4f) / 64f + 135f), 0);
int num2 = Mathf.Max((int)((vector.z - 4f) / 64f + 135f), 0);
int num3 = Mathf.Min((int)((vector2.x + 4f) / 64f + 135f), 269);
int num4 = Mathf.Min((int)((vector2.z + 4f) / 64f + 135f), 269);
int num5 = 0;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num6 = instance.m_nodeGrid[i * 270 + j];
int num7 = 0;
while (num6 != 0)
{
ushort transportLine = instance.m_nodes.m_buffer[(int)num6].m_transportLine;
if (transportLine != 0)
{
TransportInfo info = instance2.m_lines.m_buffer[(int)transportLine].Info;
if (info.m_transportType == transportType && (instance2.m_lines.m_buffer[(int)transportLine].m_flags & TransportLine.Flags.Temporary) == TransportLine.Flags.None && segment.DistanceSqr(instance.m_nodes.m_buffer[(int)num6].m_position) < 16f)
{
num5++;
}
}
num6 = instance.m_nodes.m_buffer[(int)num6].m_nextGridNode;
if (++num7 >= 32768)
{
CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return num5;
}
private static bool CheckOverlap(ushort vehicleID, ref Vehicle vehicleData, Segment3 segment, ushort ignoreVehicle)
{
VehicleManager instance = Singleton<VehicleManager>.instance;
Vector3 min = segment.Min ();
Vector3 max = segment.Max ();
int num = Mathf.Max ((int)((min.x - 30f) / 32f + 270f), 0);
int num2 = Mathf.Max ((int)((min.z - 30f) / 32f + 270f), 0);
int num3 = Mathf.Min ((int)((max.x + 30f) / 32f + 270f), 539);
int num4 = Mathf.Min ((int)((max.z + 30f) / 32f + 270f), 539);
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid [i * 540 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = CheckOverlap (vehicleID, ref vehicleData, segment, ignoreVehicle, num5, ref instance.m_vehicles.m_buffer [(int)num5], ref result, min, max);
if (++num6 > 65536)
{
CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return result;
}
private ushort CheckCitizen(ushort vehicleID, ref Vehicle vehicleData, Segment3 segment, float lastLen, float nextLen, ref float maxSpeed, ref bool blocked, float maxBraking, ushort otherID, ref CitizenInstance otherData, Vector3 min, Vector3 max)
{
if ((vehicleData.m_flags & Vehicle.Flags.Transition) == Vehicle.Flags.None && (otherData.m_flags & CitizenInstance.Flags.Transition) == CitizenInstance.Flags.None && (vehicleData.m_flags & Vehicle.Flags.Underground) != Vehicle.Flags.None != ((otherData.m_flags & CitizenInstance.Flags.Underground) != CitizenInstance.Flags.None))
{
return otherData.m_nextGridInstance;
}
CitizenInfo info = otherData.Info;
CitizenInstance.Frame lastFrameData = otherData.GetLastFrameData();
Vector3 position = lastFrameData.m_position;
Vector3 b = lastFrameData.m_position + lastFrameData.m_velocity;
Segment3 segment2 = new Segment3(position, b);
Vector3 vector = segment2.Min();
vector.x -= info.m_radius;
vector.z -= info.m_radius;
Vector3 vector2 = segment2.Max();
vector2.x += info.m_radius;
vector2.y += info.m_height;
vector2.z += info.m_radius;
float num;
float num2;
if (min.x < vector2.x + 1f && min.y < vector2.y && min.z < vector2.z + 1f && vector.x < max.x + 1f && vector.y < max.y + 2f && vector.z < max.z + 1f && segment.DistanceSqr(segment2, out num, out num2) < (1f + info.m_radius) * (1f + info.m_radius))
{
float num3 = lastLen + nextLen * num;
if (num3 >= 0.01f)
{
num3 -= 2f;
float b2 = Mathf.Max(1f, CustomCarAI.CalculateMaxSpeed(num3, 0f, maxBraking));
maxSpeed = Mathf.Min(maxSpeed, b2);
}
}
return otherData.m_nextGridInstance;
}
private static bool CheckOverlap(Segment3 segment, ushort ignoreVehicle)
{
VehicleManager instance = Singleton<VehicleManager>.instance;
Vector3 vector = segment.Min ();
Vector3 vector2 = segment.Max ();
int num = Mathf.Max ((int)((vector.x - 100f) / 320f + 27f), 0);
int num2 = Mathf.Max ((int)((vector.z - 100f) / 320f + 27f), 0);
int num3 = Mathf.Min ((int)((vector2.x + 100f) / 320f + 27f), 53);
int num4 = Mathf.Min ((int)((vector2.z + 100f) / 320f + 27f), 53);
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid2 [i * 54 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = CheckOverlap (segment, ignoreVehicle, num5, ref instance.m_vehicles.m_buffer [(int)num5], ref result);
if (++num6 > 65536)
{
CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return result;
}
private static ushort CheckOverlap(Segment3 segment, ushort ignoreVehicle, ushort otherID, ref Vehicle otherData, ref bool overlap)
{
float num;
float num2;
if ((ignoreVehicle == 0 || (otherID != ignoreVehicle && otherData.m_leadingVehicle != ignoreVehicle && otherData.m_trailingVehicle != ignoreVehicle)) && segment.DistanceSqr (otherData.m_segment, out num, out num2) < 400f)
{
overlap = true;
}
return otherData.m_nextGridVehicle;
}
public override ToolBase.ToolErrors CheckBuildPosition(ushort relocateID, ref Vector3 position, ref float angle, float waterHeight, ref Segment3 connectionSegment, out int productionRate, out int constructionCost)
{
ToolBase.ToolErrors toolErrors = base.CheckBuildPosition(relocateID, ref position, ref angle, waterHeight, ref connectionSegment, out productionRate, out constructionCost);
return toolErrors;
}
private ushort CheckCollisions(ushort instanceID, ref CitizenInstance citizenData, Segment3 segment, Vector3 min, Vector3 max, ushort otherID, ref CitizenInstance otherData, ref Vector3 pushAmount, ref float pushDivider)
{
if (otherID == instanceID)
{
return otherData.m_nextGridInstance;
}
if (((citizenData.m_flags | otherData.m_flags) & CitizenInstance.Flags.Transition) == CitizenInstance.Flags.None && (citizenData.m_flags & CitizenInstance.Flags.Underground) != (citizenData.m_flags & CitizenInstance.Flags.Underground))
{
return otherData.m_nextGridInstance;
}
CitizenInfo info = otherData.Info;
CitizenInstance.Frame lastFrameData = otherData.GetLastFrameData ();
Vector3 position = lastFrameData.m_position;
Vector3 b = lastFrameData.m_position + lastFrameData.m_velocity;
Segment3 segment2 = new Segment3 (position, b);
Vector3 vector = segment2.Min ();
vector.x -= info.m_radius;
vector.z -= info.m_radius;
Vector3 vector2 = segment2.Max ();
vector2.x += info.m_radius;
vector2.y += info.m_height;
vector2.z += info.m_radius;
if (min.x < vector2.x && max.x > vector.x && min.z < vector2.z && max.z > vector.z && min.y < vector2.y && max.y > vector.y)
{
float num = this.m_info.m_radius + info.m_radius;
float num3;
float t;
float num2 = segment.DistanceSqr (segment2, out num3, out t);
if (num2 < num * num)
{
float num4 = num - Mathf.Sqrt (num2);
float num5 = 1f - num2 / (num * num);
Vector3 a = segment.Position (num3 * 0.9f);
Vector3 b2 = segment2.Position (t);
a.y = 0f;
b2.y = 0f;
Vector3 vector3 = a - b2;
Vector3 vector4 = new Vector3 (segment.b.z - segment.a.z, 0f, segment.a.x - segment.b.x);
if (Vector3.Dot (vector3, vector4) >= 0f)
{
vector3 += vector4;
}
else
{
vector3 -= vector4;
}
pushAmount += vector3.normalized * (num4 * num5);
pushDivider += num5;
}
}
return otherData.m_nextGridInstance;
}
public new bool RayCast(Ray ray, float rayLength, out Vector3 hit, out ushort lineIndex, out int stopIndex, out int segmentIndex)
{
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
float num5 = 16f;
float num6 = 9f;
Vector3 vector = Vector3.zero;
Vector3 vector2 = Vector3.zero;
Vector3 origin = ray.origin;
Vector3 normalized = ray.direction.normalized;
Vector3 b = ray.origin + normalized * rayLength;
Segment3 segment = new Segment3(origin, b);
NetManager instance = Singleton<NetManager>.instance;
for (int i = 1; i < 256; i++)
{
if ((this.m_lines.m_buffer[i].m_flags & (TransportLine.Flags.Created | TransportLine.Flags.Temporary)) == TransportLine.Flags.Created && this.m_lines.m_buffer[i].m_bounds.IntersectRay(ray))
{
TransportManager.LineSegment[] array = this.m_lineSegments[i];
Bezier3[] array2 = this.m_lineCurves[i];
ushort stops = this.m_lines.m_buffer[i].m_stops;
ushort num7 = stops;
int num8 = 0;
while (num7 != 0)
{
Vector3 position = instance.m_nodes.m_buffer[(int)num7].m_position;
float num9 = Line3.DistanceSqr(ray.direction, ray.origin - position);
if (num9 < num5)
{
num = i;
num3 = num8;
num5 = num9;
vector = position;
}
if (array.Length > num8 && array[num8].m_bounds.IntersectRay(ray))
{
int curveStart = array[num8].m_curveStart;
int curveEnd = array[num8].m_curveEnd;
for (int j = curveStart; j < curveEnd; j++)
{
Vector3 min = array2[j].Min() - new Vector3(3f, 3f, 3f);
Vector3 max = array2[j].Max() + new Vector3(3f, 3f, 3f);
Bounds bounds = default(Bounds);
bounds.SetMinMax(min, max);
if (bounds.IntersectRay(ray))
{
float t;
float num10;
num9 = array2[j].DistanceSqr(segment, out t, out num10);
if (num9 < num6)
{
num2 = i;
num4 = num8;
num6 = num9;
vector2 = array2[j].Position(t);
}
}
}
}
num7 = TransportLine.GetNextStop(num7);
if (num7 == stops)
{
break;
}
if (++num8 >= 32768)
{
CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
if (num != 0)
{
hit = vector;
lineIndex = (ushort)num;
stopIndex = num3;
segmentIndex = -1;
return true;
}
if (num2 != 0)
{
hit = vector2;
lineIndex = (ushort)num2;
stopIndex = -1;
segmentIndex = num4;
return true;
}
hit = Vector3.zero;
lineIndex = 0;
stopIndex = -1;
segmentIndex = -1;
return false;
}
private ushort CheckCollisions(ushort instanceID, ref CitizenInstance citizenData, Segment3 segment, Vector3 min, Vector3 max, ushort otherID, ref VehicleParked otherData, ref Vector3 pushAmount, ref float pushDivider)
{
VehicleInfo info = otherData.Info;
Vector3 position = otherData.m_position;
Vector3 b = otherData.m_rotation * new Vector3 (0f, 0f, Mathf.Max (0.5f, info.m_generatedInfo.m_size.z * 0.5f - 1f));
Segment3 segment2;
segment2.a = position - b;
segment2.b = position + b;
Vector3 vector = segment2.Min ();
vector.x -= 1f;
vector.z -= 1f;
Vector3 vector2 = segment2.Max ();
vector2.x += 1f;
vector2.y += 1f;
vector2.z += 1f;
if (min.x < vector2.x && max.x > vector.x && min.z < vector2.z && max.z > vector.z && min.y < vector2.y && max.y > vector.y)
{
float num = this.m_info.m_radius + 1f;
float num3;
float t;
float num2 = segment.DistanceSqr (segment2, out num3, out t);
if (num2 < num * num)
{
float num4 = num - Mathf.Sqrt (num2);
float num5 = 1f - num2 / (num * num);
Vector3 a = segment.Position (num3 * 0.9f);
Vector3 b2 = segment2.Position (t);
a.y = 0f;
b2.y = 0f;
Vector3 vector3 = Vector3.Normalize (a - b2);
Vector3 rhs = Vector3.Normalize (new Vector3 (segment.b.x - segment.a.x, 0f, segment.b.z - segment.a.z));
Vector3 vector4 = new Vector3 (rhs.z, 0f, -rhs.x) * Mathf.Abs (Vector3.Dot (vector3, rhs) * 0.5f);
if (Vector3.Dot (vector3, vector4) >= 0f)
{
vector3 += vector4;
}
else
{
vector3 -= vector4;
}
pushAmount += vector3 * (num4 * num5);
pushDivider += num5;
}
}
return otherData.m_nextGridParked;
}
private static ushort CheckOverlap(Segment3 segment, ushort ignoreVehicle, float maxVelocity, ushort otherID, ref Vehicle otherData, ref bool overlap)
{
float num;
float num2;
if ((ignoreVehicle == 0 || (otherID != ignoreVehicle && otherData.m_leadingVehicle != ignoreVehicle && otherData.m_trailingVehicle != ignoreVehicle)) && segment.DistanceSqr (otherData.m_segment, out num, out num2) < 4f)
{
VehicleInfo info = otherData.Info;
if (info.m_vehicleType == VehicleInfo.VehicleType.Bicycle)
{
return otherData.m_nextGridVehicle;
}
if (otherData.GetLastFrameData ().m_velocity.sqrMagnitude < maxVelocity * maxVelocity)
{
overlap = true;
}
}
return otherData.m_nextGridVehicle;
}
// CHECKME: check if this method allows to make people get away from traffic
private static ushort CheckCitizen(Segment3 segment, float lastLen, float nextLen, ref float maxSpeed, ref bool blocked, float maxBraking, ushort otherID, ref CitizenInstance otherData, Vector3 min, Vector3 max)
{
CitizenInfo info = otherData.Info;
CitizenInstance.Frame lastFrameData = otherData.GetLastFrameData();
Vector3 position = lastFrameData.m_position;
Vector3 b = lastFrameData.m_position + lastFrameData.m_velocity;
Segment3 segment2 = new Segment3(position, b);
Vector3 vector = segment2.Min();
vector.x -= info.m_radius;
vector.z -= info.m_radius;
Vector3 vector2 = segment2.Max();
vector2.x += info.m_radius;
vector2.y += info.m_height;
vector2.z += info.m_radius;
float num;
float num2;
if (min.x < vector2.x + 1f && min.y < vector2.y && min.z < vector2.z + 1f && vector.x < max.x + 1f && vector.y < max.y + 2f && vector.z < max.z + 1f && segment.DistanceSqr(segment2, out num, out num2) < (1f + info.m_radius) * (1f + info.m_radius))
{
float num3 = lastLen + nextLen * num;
if (num3 >= 0.01f)
{
num3 -= 2f;
float b2 = Mathf.Max(1f, CalculateMaxSpeed(num3, 0f, maxBraking));
maxSpeed = Mathf.Min(maxSpeed, b2);
}
}
return otherData.m_nextGridInstance;
}
private static ushort CheckOtherVehicle(ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData, ref float maxSpeed, ref bool blocked, ref Vector3 collisionPush, float maxBraking, ushort otherID, ref Vehicle otherData, Vector3 min, Vector3 max, int lodPhysics)
{
if (otherID != vehicleID && vehicleData.m_leadingVehicle != otherID && vehicleData.m_trailingVehicle != otherID)
{
VehicleInfo info = otherData.Info;
if (info.m_vehicleType == VehicleInfo.VehicleType.Bicycle)
{
return otherData.m_nextGridVehicle;
}
Vector3 vector;
Vector3 vector2;
if (lodPhysics >= 2)
{
vector = otherData.m_segment.Min();
vector2 = otherData.m_segment.Max();
}
else
{
vector = Vector3.Min(otherData.m_segment.Min(), otherData.m_targetPos3);
vector2 = Vector3.Max(otherData.m_segment.Max(), otherData.m_targetPos3);
}
if (min.x < vector2.x + 2f && min.y < vector2.y + 2f && min.z < vector2.z + 2f && vector.x < max.x + 2f && vector.y < max.y + 2f && vector.z < max.z + 2f)
{
Vehicle.Frame lastFrameData = otherData.GetLastFrameData();
if (lodPhysics < 2)
{
float num2;
float num3;
float num = vehicleData.m_segment.DistanceSqr(otherData.m_segment, out num2, out num3);
if (num < 4f)
{
Vector3 a = vehicleData.m_segment.Position(0.5f);
Vector3 b = otherData.m_segment.Position(0.5f);
Vector3 lhs = vehicleData.m_segment.b - vehicleData.m_segment.a;
if (Vector3.Dot(lhs, a - b) < 0f)
{
collisionPush -= lhs.normalized * (0.1f - num * 0.025f);
}
else
{
collisionPush += lhs.normalized * (0.1f - num * 0.025f);
}
blocked = true;
}
}
float num4 = frameData.m_velocity.magnitude + 0.01f;
float num5 = lastFrameData.m_velocity.magnitude;
float num6 = num5 * (0.5f + 0.5f * num5 / info.m_braking) + Mathf.Min(1f, num5);
num5 += 0.01f;
float num7 = 0f;
Vector3 vector3 = vehicleData.m_segment.b;
Vector3 lhs2 = vehicleData.m_segment.b - vehicleData.m_segment.a;
for (int i = 0; i < 4; i++)
{
Vector3 vector4 = vehicleData.GetTargetPos(i);
Vector3 vector5 = vector4 - vector3;
if (Vector3.Dot(lhs2, vector5) > 0f)
{
float magnitude = vector5.magnitude;
Segment3 segment = new Segment3(vector3, vector4);
min = segment.Min();
max = segment.Max();
segment.a.y = segment.a.y * 0.5f;
segment.b.y = segment.b.y * 0.5f;
if (magnitude > 0.01f && min.x < vector2.x + 2f && min.y < vector2.y + 2f && min.z < vector2.z + 2f && vector.x < max.x + 2f && vector.y < max.y + 2f && vector.z < max.z + 2f)
{
Vector3 a2 = otherData.m_segment.a;
a2.y *= 0.5f;
float num8;
if (segment.DistanceSqr(a2, out num8) < 4f)
{
float num9 = Vector3.Dot(lastFrameData.m_velocity, vector5) / magnitude;
float num10 = num7 + magnitude * num8;
if (num10 >= 0.01f)
{
num10 -= num9 + 3f;
float num11 = Mathf.Max(0f, CalculateMaxSpeed(num10, num9, maxBraking));
if (num11 < 0.01f)
{
blocked = true;
}
Vector3 rhs = Vector3.Normalize(otherData.m_targetPos0 - (Vector4)otherData.m_segment.a);
float num12 = 1.2f - 1f / ((float)vehicleData.m_blockCounter * 0.02f + 0.5f);
if (Vector3.Dot(vector5, rhs) > num12 * magnitude)
{
maxSpeed = Mathf.Min(maxSpeed, num11);
}
}
break;
}
if (lodPhysics < 2)
{
float num13 = 0f;
float num14 = num6;
Vector3 vector6 = otherData.m_segment.b;
Vector3 lhs3 = otherData.m_segment.b - otherData.m_segment.a;
bool flag = false;
int num15 = 0;
while (num15 < 4 && num14 > 0.1f)
{
Vector3 vector7 = otherData.GetTargetPos(num15);
Vector3 vector8 = Vector3.ClampMagnitude(vector7 - vector6, num14);
if (Vector3.Dot(lhs3, vector8) > 0f)
{
vector7 = vector6 + vector8;
float magnitude2 = vector8.magnitude;
num14 -= magnitude2;
Segment3 segment2 = new Segment3(vector6, vector7);
segment2.a.y = segment2.a.y * 0.5f;
segment2.b.y = segment2.b.y * 0.5f;
if (magnitude2 > 0.01f)
{
float num17;
float num18;
float num16;
if (otherID < vehicleID)
{
num16 = segment2.DistanceSqr(segment, out num17, out num18);
}
else
{
num16 = segment.DistanceSqr(segment2, out num18, out num17);
}
if (num16 < 4f)
{
float num19 = num7 + magnitude * num18;
float num20 = num13 + magnitude2 * num17 + 0.1f;
if (num19 >= 0.01f && num19 * num5 > num20 * num4)
{
float num21 = Vector3.Dot(lastFrameData.m_velocity, vector5) / magnitude;
if (num19 >= 0.01f)
{
num19 -= num21 + 1f + otherData.Info.m_generatedInfo.m_size.z;
float num22 = Mathf.Max(0f, CalculateMaxSpeed(num19, num21, maxBraking));
if (num22 < 0.01f)
{
blocked = true;
}
maxSpeed = Mathf.Min(maxSpeed, num22);
}
}
flag = true;
break;
}
}
lhs3 = vector8;
num13 += magnitude2;
vector6 = vector7;
}
num15++;
}
if (flag)
{
break;
}
}
}
lhs2 = vector5;
num7 += magnitude;
vector3 = vector4;
}
}
}
}
return otherData.m_nextGridVehicle;
}
private ushort CheckOtherVehicle(ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData, ref float maxSpeed, ref bool blocked, float maxBraking, ushort otherID, ref Vehicle otherData, Vector3 min, Vector3 max, int lodPhysics)
{
if (otherID != vehicleID && vehicleData.m_leadingVehicle != otherID && vehicleData.m_trailingVehicle != otherID)
{
Vector3 vector;
Vector3 vector2;
if (lodPhysics >= 1)
{
vector = otherData.m_segment.Min ();
vector2 = otherData.m_segment.Max ();
}
else
{
vector = Vector3.Min (otherData.m_segment.Min (), otherData.m_targetPos3);
vector2 = Vector3.Max (otherData.m_segment.Max (), otherData.m_targetPos3);
}
if (min.x < vector2.x + 2f && min.y < vector2.y + 2f && min.z < vector2.z + 2f && vector.x < max.x + 2f && vector.y < max.y + 2f && vector.z < max.z + 2f)
{
Vehicle.Frame lastFrameData = otherData.GetLastFrameData ();
VehicleInfo info = otherData.Info;
float num = frameData.m_velocity.magnitude + 0.01f;
float num2 = lastFrameData.m_velocity.magnitude;
float num3 = num2 * (0.5f + 0.5f * num2 / info.m_braking) + info.m_generatedInfo.m_size.z * Mathf.Min (0.5f, num2 * 0.1f);
num2 += 0.01f;
float num4 = 0f;
Vector3 vector3 = frameData.m_position;
Vector3 lhs = ((Vector3) vehicleData.m_targetPos3) - frameData.m_position;
for (int i = 1; i < 4; i++)
{
Vector3 vector4 = vehicleData.GetTargetPos (i);
Vector3 vector5 = vector4 - vector3;
if (Vector3.Dot (lhs, vector5) > 0f)
{
float magnitude = vector5.magnitude;
Segment3 segment = new Segment3 (vector3, vector4);
min = segment.Min ();
max = segment.Max ();
segment.a.y = segment.a.y * 0.5f;
segment.b.y = segment.b.y * 0.5f;
if (magnitude > 0.01f && min.x < vector2.x + 2f && min.y < vector2.y + 2f && min.z < vector2.z + 2f && vector.x < max.x + 2f && vector.y < max.y + 2f && vector.z < max.z + 2f)
{
Vector3 a = otherData.m_segment.a;
a.y *= 0.5f;
float num5;
if (segment.DistanceSqr (a, out num5) < 400f)
{
float num6 = Vector3.Dot (lastFrameData.m_velocity, vector5) / magnitude;
float num7 = num4 + magnitude * num5;
if (num7 >= 0.01f)
{
num7 -= num6 + 30f;
float num8 = Mathf.Max (0f, CalculateMaxSpeed (num7, num6, maxBraking));
if (num8 < 0.01f)
{
blocked = true;
}
Vector3 rhs = Vector3.Normalize (((Vector3)otherData.m_targetPos3) - otherData.GetLastFramePosition ());
float num9 = 1.2f - 1f / ((float)vehicleData.m_blockCounter * 0.02f + 0.5f);
if (Vector3.Dot (vector5, rhs) > num9 * magnitude)
{
maxSpeed = Mathf.Min (maxSpeed, num8);
}
}
break;
}
if (lodPhysics == 0)
{
float num10 = 0f;
float num11 = num3;
Vector3 vector6 = otherData.GetLastFramePosition ();
Vector3 lhs2 = ((Vector3)otherData.m_targetPos3) - vector6;
bool flag = false;
int num12 = 1;
while (num12 < 4 && num11 > 0.1f)
{
Vector3 vector7 = otherData.GetTargetPos (num12);
Vector3 vector8 = Vector3.ClampMagnitude (vector7 - vector6, num11);
if (Vector3.Dot (lhs2, vector8) > 0f)
{
vector7 = vector6 + vector8;
float magnitude2 = vector8.magnitude;
num11 -= magnitude2;
Segment3 segment2 = new Segment3 (vector6, vector7);
segment2.a.y = segment2.a.y * 0.5f;
segment2.b.y = segment2.b.y * 0.5f;
if (magnitude2 > 0.01f)
{
float num14;
float num15;
float num13;
if (otherID < vehicleID)
{
num13 = segment2.DistanceSqr (segment, out num14, out num15);
}
else
{
num13 = segment.DistanceSqr (segment2, out num15, out num14);
}
if (num13 < 400f)
{
float num16 = num4 + magnitude * num15;
float num17 = num10 + magnitude2 * num14 + 0.1f;
if (num16 >= 0.01f && num16 * num2 > num17 * num)
{
float num18 = Vector3.Dot (lastFrameData.m_velocity, vector5) / magnitude;
if (num16 >= 0.01f)
{
num16 -= num18 + 10f + otherData.Info.m_generatedInfo.m_size.z;
float num19 = Mathf.Max (0f, CalculateMaxSpeed (num16, num18, maxBraking));
if (num19 < 0.01f)
{
blocked = true;
}
maxSpeed = Mathf.Min (maxSpeed, num19);
}
}
flag = true;
break;
}
}
lhs2 = vector8;
num10 += magnitude2;
vector6 = vector7;
}
num12++;
}
if (flag)
{
break;
}
}
}
lhs = vector5;
num4 += magnitude;
vector3 = vector4;
}
}
}
}
return otherData.m_nextGridVehicle;
}
private static void CheckOtherVehicles(CarAI carAI, ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData, ref float maxSpeed, ref bool blocked, ref Vector3 collisionPush, float maxDistance, float maxBraking, int lodPhysics)
{
Vector3 vector = vehicleData.m_targetPos3 - (Vector4)frameData.m_position;
Vector3 rhs = frameData.m_position + Vector3.ClampMagnitude(vector, maxDistance);
Vector3 min = Vector3.Min(vehicleData.m_segment.Min(), rhs);
Vector3 max = Vector3.Max(vehicleData.m_segment.Max(), rhs);
VehicleManager instance = Singleton<VehicleManager>.instance;
int num = Mathf.Max((int)((min.x - 10f) / 32f + 270f), 0);
int num2 = Mathf.Max((int)((min.z - 10f) / 32f + 270f), 0);
int num3 = Mathf.Min((int)((max.x + 10f) / 32f + 270f), 539);
int num4 = Mathf.Min((int)((max.z + 10f) / 32f + 270f), 539);
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid[i * 540 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = CustomCarAI.CheckOtherVehicle(vehicleID, ref vehicleData, ref frameData, ref maxSpeed, ref blocked, ref collisionPush, maxBraking, num5, ref instance.m_vehicles.m_buffer[(int)num5], min, max, lodPhysics);
if (++num6 > 16384)
{
CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
if (lodPhysics == 0 && (CSLTraffic.Options & OptionsManager.ModOptions.noStopForCrossing) != OptionsManager.ModOptions.noStopForCrossing)
{
CitizenManager instance2 = Singleton<CitizenManager>.instance;
float num7 = 0f;
Vector3 vector2 = vehicleData.m_segment.b;
Vector3 lhs = vehicleData.m_segment.b - vehicleData.m_segment.a;
for (int k = 0; k < 4; k++)
{
Vector3 vector3 = vehicleData.GetTargetPos(k);
Vector3 vector4 = vector3 - vector2;
if (Vector3.Dot(lhs, vector4) > 0f)
{
float magnitude = vector4.magnitude;
if (magnitude > 0.01f)
{
Segment3 segment = new Segment3(vector2, vector3);
min = segment.Min();
max = segment.Max();
int num8 = Mathf.Max((int)((min.x - 3f) / 8f + 1080f), 0);
int num9 = Mathf.Max((int)((min.z - 3f) / 8f + 1080f), 0);
int num10 = Mathf.Min((int)((max.x + 3f) / 8f + 1080f), 2159);
int num11 = Mathf.Min((int)((max.z + 3f) / 8f + 1080f), 2159);
for (int l = num9; l <= num11; l++)
{
for (int m = num8; m <= num10; m++)
{
ushort num12 = instance2.m_citizenGrid[l * 2160 + m];
int num13 = 0;
while (num12 != 0)
{
num12 = CustomCarAI.CheckCitizen(segment, num7, magnitude, ref maxSpeed, ref blocked, maxBraking, num12, ref instance2.m_instances.m_buffer[(int)num12], min, max);
if (++num13 > 65536)
{
CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
lhs = vector4;
num7 += magnitude;
vector2 = vector3;
}
}
}
}
public void CalculateCentroid()
{
Segment3 LeftRightBimedian = new Segment3(this.LeftSegment.MidPoint, this.RightSegment.MidPoint);
Segment3 TopBottomBimedian = new Segment3(this.BottomSegment.MidPoint, this.TopSegment.MidPoint);
this.Centroid = LeftRightBimedian.Intersect(TopBottomBimedian,1E-4);
}
private ushort CheckCollisions(ushort instanceID, ref CitizenInstance citizenData, Segment3 segment, Vector3 min, Vector3 max, ushort otherID, ref Vehicle otherData, ref Vector3 pushAmount, ref float pushDivider)
{
VehicleInfo info = otherData.Info;
if (info.m_vehicleType == VehicleInfo.VehicleType.Bicycle)
{
return otherData.m_nextGridVehicle;
}
if ((otherData.m_flags & Vehicle.Flags.Transition) == Vehicle.Flags.None && (citizenData.m_flags & CitizenInstance.Flags.Transition) == CitizenInstance.Flags.None && (otherData.m_flags & Vehicle.Flags.Underground) != Vehicle.Flags.None != ((citizenData.m_flags & CitizenInstance.Flags.Underground) != CitizenInstance.Flags.None))
{
return otherData.m_nextGridVehicle;
}
Segment3 segment2 = otherData.m_segment;
Vector3 vector = Vector3.Min (segment2.Min (), otherData.m_targetPos1);
vector.x -= 1f;
vector.z -= 1f;
Vector3 vector2 = Vector3.Max (segment2.Max (), otherData.m_targetPos1);
vector2.x += 1f;
vector2.y += 1f;
vector2.z += 1f;
if (min.x < vector2.x && max.x > vector.x && min.z < vector2.z && max.z > vector.z && min.y < vector2.y && max.y > vector.y)
{
float num = this.m_info.m_radius + 1f;
float num3;
float t;
float num2 = segment.DistanceSqr (segment2, out num3, out t);
if (num2 < num * num)
{
float num4 = num - Mathf.Sqrt (num2);
float num5 = 1f - num2 / (num * num);
Vector3 a = segment.Position (num3 * 0.9f);
Vector3 b = segment2.Position (t);
a.y = 0f;
b.y = 0f;
Vector3 vector3 = Vector3.Normalize (a - b);
Vector3 rhs = Vector3.Normalize (new Vector3 (segment.b.x - segment.a.x, 0f, segment.b.z - segment.a.z));
Vector3 vector4 = new Vector3 (rhs.z, 0f, -rhs.x) * Mathf.Abs (Vector3.Dot (vector3, rhs) * 0.5f);
if (Vector3.Dot (vector3, vector4) >= 0f)
{
vector3 += vector4;
}
else
{
vector3 -= vector4;
}
pushAmount += vector3 * (num4 * num5);
pushDivider += num5;
}
float magnitude = otherData.GetLastFrameVelocity ().magnitude;
if (magnitude > 0.1f)
{
float num6 = this.m_info.m_radius + 3f;
segment2.a = segment2.b;
segment2.b += Vector3.ClampMagnitude (((Vector3)otherData.m_targetPos1) - segment2.b, magnitude * 4f);
num2 = segment.DistanceSqr (segment2, out num3, out t);
if (num2 > num * num && num2 < num6 * num6)
{
float num7 = num6 - Mathf.Sqrt (num2);
float num8 = 1f - num2 / (num6 * num6);
Vector3 a2 = segment.Position (num3 * 0.9f);
Vector3 b2 = segment2.Position (t);
a2.y = 0f;
b2.y = 0f;
Vector3 vector5 = a2 - b2;
pushAmount += vector5.normalized * (num7 * num8);
pushDivider += num8;
}
}
}
return otherData.m_nextGridVehicle;
}
void Update()
{
if (onUpdate != null)
{
onUpdate();
}
UpdateCityWalkthrough();
UpdateCameras();
if (Input.GetKeyDown(KeyCode.Escape))
{
OnEscapePressed();
}
if (Input.GetKeyDown(config.toggleFPSCameraHotkey))
{
OnToggleCameraHotkeyPressed();
}
var pos = gameObject.transform.position;
float terrainY = TerrainManager.instance.SampleDetailHeight(gameObject.transform.position);
float waterY = TerrainManager.instance.WaterLevel(new Vector2(gameObject.transform.position.x, gameObject.transform.position.z));
terrainY = Mathf.Max(terrainY, waterY);
if (config.animateTransitions && inModeTransition)
{
transitionT += Time.deltaTime * config.animationSpeed;
gameObject.transform.position = Vector3.Slerp(transitionStartPosition, transitionTargetPosition, transitionT);
gameObject.transform.rotation = Quaternion.Slerp(transitionStartOrientation, transitionTargetOrientation, transitionT);
if (transitionT >= 1.0f)
{
inModeTransition = false;
if (!fpsModeEnabled)
{
instance.controller.enabled = true;
}
}
}
else if (fpsModeEnabled)
{
if (config.snapToGround)
{
Segment3 ray = new Segment3(gameObject.transform.position + new Vector3(0f, 1.5f, 0f), gameObject.transform.position + new Vector3(0f, -1000f, 0f));
Vector3 hitPos;
ushort nodeIndex;
ushort segmentIndex;
Vector3 hitPos2;
if (NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Road, ItemClass.Service.PublicTransport, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos, out nodeIndex, out segmentIndex)
| NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Beautification, ItemClass.Service.Water, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos2, out nodeIndex, out segmentIndex))
{
terrainY = Mathf.Max(terrainY, Mathf.Max(hitPos.y, hitPos2.y));
}
gameObject.transform.position = Vector3.Lerp(gameObject.transform.position, new Vector3(pos.x, terrainY + config.groundOffset, pos.z), 0.9f);
}
float speedFactor = 1.0f;
if (config.limitSpeedGround)
{
speedFactor *= Mathf.Sqrt(terrainY);
speedFactor = Mathf.Clamp(speedFactor, 1.0f, 256.0f);
}
UpdateFpsCamera(speedFactor);
}
else
{
mainCameraPosition = gameObject.transform.position;
mainCameraOrientation = gameObject.transform.rotation;
}
if (config.preventClipGround)
{
Segment3 ray = new Segment3(gameObject.transform.position + new Vector3(0f, 1.5f, 0f), gameObject.transform.position + new Vector3(0f, -1000f, 0f));
Vector3 hitPos;
ushort nodeIndex;
ushort segmentIndex;
Vector3 hitPos2;
if (NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Road, ItemClass.Service.PublicTransport, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos, out nodeIndex, out segmentIndex)
| NetManager.instance.RayCast(ray, 0f, ItemClass.Service.Beautification, ItemClass.Service.Water, ItemClass.SubService.None, ItemClass.SubService.None, ItemClass.Layer.Default, ItemClass.Layer.None, NetNode.Flags.None, NetSegment.Flags.None, out hitPos2, out nodeIndex, out segmentIndex))
{
terrainY = Mathf.Max(terrainY, Mathf.Max(hitPos.y, hitPos2.y));
}
if (transform.position.y < terrainY + config.groundOffset)
{
transform.position = new Vector3(transform.position.x, terrainY + config.groundOffset, transform.position.z);
}
}
}
private static ushort CheckOverlap(ushort vehicleID, ref Vehicle vehicleData, Segment3 segment, ushort ignoreVehicle, ushort otherID, ref Vehicle otherData, ref bool overlap, Vector3 min, Vector3 max)
{
if (ignoreVehicle == 0 || (otherID != ignoreVehicle && otherData.m_leadingVehicle != ignoreVehicle && otherData.m_trailingVehicle != ignoreVehicle))
{
VehicleInfo info = otherData.Info;
if (info.m_vehicleType == VehicleInfo.VehicleType.Bicycle)
{
return otherData.m_nextGridVehicle;
}
if (((vehicleData.m_flags | otherData.m_flags) & Vehicle.Flags.Transition) == Vehicle.Flags.None && (vehicleData.m_flags & Vehicle.Flags.Underground) != (otherData.m_flags & Vehicle.Flags.Underground))
{
return otherData.m_nextGridVehicle;
}
Vector3 vector = Vector3.Min (otherData.m_segment.Min (), otherData.m_targetPos3);
Vector3 vector2 = Vector3.Max (otherData.m_segment.Max (), otherData.m_targetPos3);
if (min.x < vector2.x + 2f && min.y < vector2.y + 2f && min.z < vector2.z + 2f && vector.x < max.x + 2f && vector.y < max.y + 2f && vector.z < max.z + 2f)
{
Vector3 rhs = Vector3.Normalize (segment.b - segment.a);
Vector3 lhs = otherData.m_segment.a - vehicleData.m_segment.b;
Vector3 lhs2 = otherData.m_segment.b - vehicleData.m_segment.b;
if (Vector3.Dot (lhs, rhs) >= 1f || Vector3.Dot (lhs2, rhs) >= 1f)
{
float num2;
float num3;
float num = segment.DistanceSqr (otherData.m_segment, out num2, out num3);
if (num < 4f)
{
overlap = true;
}
Vector3 a = otherData.m_segment.b;
segment.a.y = segment.a.y * 0.5f;
segment.b.y = segment.b.y * 0.5f;
for (int i = 0; i < 4; i++)
{
Vector3 vector3 = otherData.GetTargetPos (i);
Segment3 segment2 = new Segment3 (a, vector3);
segment2.a.y = segment2.a.y * 0.5f;
segment2.b.y = segment2.b.y * 0.5f;
if (segment2.LengthSqr () > 0.01f)
{
num = segment.DistanceSqr (segment2, out num2, out num3);
if (num < 4f)
{
overlap = true;
break;
}
}
a = vector3;
}
}
}
}
return otherData.m_nextGridVehicle;
}
