private ushort CheckForParkingSpaces(Vector3 pos, float angle, int width, int length)
{
Vector2 a = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle));
Vector2 a2 = new Vector2(a.y, 0f - a.x);
a *= (float)width * 4f;
a2 *= (float)length * 4f;
Vector2 vector = VectorUtils.XZ(pos);
Quad2 quad = default(Quad2);
quad.a = vector - a - a2;
quad.b = vector + a - a2;
quad.c = vector + a + a2;
quad.d = vector - a + a2;
BuildingManager instance = Singleton <BuildingManager> .instance;
Vector2 vector3 = quad.Min();
Vector2 vector2 = quad.Max();
int num = Mathf.Max((int)((vector3.x - 72f) / 64f + 135f), 0);
int num2 = Mathf.Max((int)((vector3.y - 72f) / 64f + 135f), 0);
int num3 = Mathf.Min((int)((vector2.x + 72f) / 64f + 135f), 269);
int num4 = Mathf.Min((int)((vector2.y + 72f) / 64f + 135f), 269);
//bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_buildingGrid[i * 270 + j];
int num6 = 0;
while (num5 != 0)
{
BuildingInfo info = instance.m_buildings.m_buffer[num5].Info;
ItemClass.CollisionType collisionType = ItemClass.CollisionType.Zoned;
if ((object)info != null && instance.m_buildings.m_buffer[num5].OverlapQuad(num5, quad, pos.y - 1000f, pos.y + 1000f, collisionType))
{
if (info.m_buildingAI is ParkingSpaceAssetAI)
{
return(num5);
}
}
num5 = instance.m_buildings.m_buffer[num5].m_nextGridBuilding;
if (++num6 >= 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return((ushort)0);
}
public static bool CheckTreeBlocked(Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType, TreeInfo treeInfo)
{
bool _result = false;
if (Singleton <NetManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, treeInfo.m_class.m_layer, 0, 0, 0))
{
_result = true;
}
if (Singleton <BuildingManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, treeInfo.m_class.m_layer, 0, 0, 0))
{
_result = true;
}
return(_result);
}
public static bool TestNodeBuilding(ushort nodeID, BuildingInfo info, Vector3 position, float angle)
{
Vector2 a = new Vector3(Mathf.Cos(angle), Mathf.Sin(angle));
Vector2 a2 = new Vector3(a.y, 0f - a.x);
if (info.m_placementMode == BuildingInfo.PlacementMode.Roadside || info.m_placementMode == BuildingInfo.PlacementMode.PathsideOrGround)
{
a *= (float)info.m_cellWidth * 4f - 0.8f;
a2 *= (float)info.m_cellLength * 4f - 0.8f;
}
else
{
a *= (float)info.m_cellWidth * 4f;
a2 *= (float)info.m_cellLength * 4f;
}
if (info.m_circular)
{
a *= 0.7f;
a2 *= 0.7f;
}
ItemClass.CollisionType collisionType = info.m_buildingAI.GetCollisionType();
Vector2 a3 = VectorUtils.XZ(position);
Quad2 quad = default(Quad2);
quad.a = a3 - a - a2;
quad.b = a3 - a + a2;
quad.c = a3 + a + a2;
quad.d = a3 + a - a2;
float minY = Mathf.Min(position.y, Singleton <TerrainManager> .instance.SampleRawHeightSmooth(position));
float maxY = position.y + info.m_generatedInfo.m_size.y;
if (collisionType == ItemClass.CollisionType.Elevated)
{
minY = position.y + info.m_generatedInfo.m_min.y;
}
if (Singleton <NetManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, info.m_class.m_layer, nodeID, 0, 0, null))
{
return(false);
}
if (Singleton <BuildingManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, info.m_class.m_layer, 0, nodeID, 0, null))
{
return(false);
}
return(true);
}
private static void CheckOverlap(ref TreeInstance tree, uint treeID) //this method reproduces original code for most part to prevent exceptions
{
TreeInfo info = tree.Info;
if (info == null)
{
return;
}
ItemClass.CollisionType collisionType = ((int)tree.m_flags & 32) != 0 ? ItemClass.CollisionType.Elevated : ItemClass.CollisionType.Terrain;
Randomizer randomizer = new Randomizer(treeID);
float num1 = info.m_minScale + (float)((double)randomizer.Int32(10000U) * ((double)info.m_maxScale - (double)info.m_minScale) * 9.99999974737875E-05);
float num2 = info.m_generatedInfo.m_size.y * num1;
Vector3 position = tree.Position;
float minY = position.y;
float maxY = position.y + num2;
float num3 = !tree.Single ? 4.5f : 0.3f;
Quad2 quad = new Quad2();
Vector2 vector2 = VectorUtils.XZ(position);
quad.a = vector2 + new Vector2(-num3, -num3);
quad.b = vector2 + new Vector2(-num3, num3);
quad.c = vector2 + new Vector2(num3, num3);
quad.d = vector2 + new Vector2(num3, -num3);
bool flag = false;
if (Singleton <NetManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, info.m_class.m_layer, (ushort)0, (ushort)0, (ushort)0))
{
flag = true;
}
if (Singleton <BuildingManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, info.m_class.m_layer, (ushort)0, (ushort)0, (ushort)0))
{
flag = true;
}
//begin mod
if (!OptionsWrapper <Options> .Options.unhideAllTreesOnLevelLoading)
{
return;
}
if (tree.GrowState != 0)
{
return;
}
tree.GrowState = 1;
//end mod
}
public static ItemCollisionType CheckAllCollisionsTree(Vector3 worldPosition, TreeInfo treeInfo)
{
ItemCollisionType _result = ItemCollisionType.None;
Vector2 _center = VectorUtils.XZ(worldPosition);
float _radius = 0.5f;
Quad2 _quad = default(Quad2);
_quad.a = _center + new Vector2(-_radius, -_radius);
_quad.b = _center + new Vector2(-_radius, _radius);
_quad.c = _center + new Vector2(_radius, _radius);
_quad.d = _center + new Vector2(_radius, -_radius);
float _minY = worldPosition.y;
float _maxY = worldPosition.y + treeInfo.m_generatedInfo.m_size.y * Mathf.Max(treeInfo.m_maxScale, treeInfo.m_minScale);
ItemClass.CollisionType _collisionType = ItemClass.CollisionType.Terrain;
if (DoesTreeCollideWithProps(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result |= ItemCollisionType.Props;
}
if (DoesTreeCollideWithTrees(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result |= ItemCollisionType.Trees;
}
if (CheckTreeBlocked(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result |= ItemCollisionType.Blocked;
}
if (DoesPositionHaveWater(worldPosition))
{
_result |= ItemCollisionType.Water;
}
if (IsQuadOutOfGameArea(_quad))
{
_result |= ItemCollisionType.GameArea;
}
return(_result);
}
public static bool CheckValidPlacementTreeLite(Vector3 worldPosition, TreeInfo treeInfo)
{
bool _result = true;
Vector2 _center = VectorUtils.XZ(worldPosition);
float _radius = 0.5f;
Quad2 _quad = default(Quad2);
_quad.a = _center + new Vector2(-_radius, -_radius);
_quad.b = _center + new Vector2(-_radius, _radius);
_quad.c = _center + new Vector2(_radius, _radius);
_quad.d = _center + new Vector2(_radius, -_radius);
float _minY = worldPosition.y;
float _maxY = worldPosition.y + treeInfo.m_generatedInfo.m_size.y * Mathf.Max(treeInfo.m_maxScale, treeInfo.m_minScale);
ItemClass.CollisionType _collisionType = ItemClass.CollisionType.Terrain;
if (IsQuadOutOfGameArea(_quad))
{
_result = false;
}
else if (CheckTreeBlocked(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result = false;
}
else if (DoesPositionHaveWater(worldPosition))
{
_result = false;
}
else if (DoesTreeCollideWithTrees(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result = false;
}
else if (DoesTreeCollideWithProps(_quad, _minY, _maxY, _collisionType, treeInfo))
{
_result = false;
}
return(_result);
}
public static bool Prefix(ref NetSegment __instance, ushort segmentID, Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType)
{
if ((__instance.m_flags & (NetSegment.Flags.Created | NetSegment.Flags.Deleted)) != NetSegment.Flags.Created)
{
return(false);
}
NetInfo info = __instance.Info;
if (!info.m_canCollide)
{
return(false);
}
float collisionHalfWidth = info.m_netAI.GetCollisionHalfWidth();
Vector2 vector = quad.Min();
Vector2 vector2 = quad.Max();
Bezier3 bezier = default(Bezier3);
bezier.a = Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].m_position;
bezier.d = Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].m_position;
// NON-STOCK CODE STARTS
if (CSURUtil.IsCSUROffset(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info))
{
var width = (Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info.m_halfWidth + Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info.m_pavementWidth) / 2f;
bool lht = false;
Vector3 direction = __instance.m_startDirection;
if ((__instance.m_flags & NetSegment.Flags.Invert) != 0)
{
lht = true;
}
// normal to the right hand side
Vector3 normal = new Vector3(direction.z, 0, -direction.x).normalized;
bezier.a = bezier.a + (lht ? -width : width) * normal;
}
if (CSURUtil.IsCSUROffset(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].Info))
{
bool lht = false;
var width = (Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].Info.m_halfWidth + Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].Info.m_pavementWidth) / 2f;
Vector3 direction = -__instance.m_endDirection;
if ((__instance.m_flags & NetSegment.Flags.Invert) != 0)
{
lht = true;
}
// normal to the right hand side
Vector3 normal = new Vector3(direction.z, 0, -direction.x).normalized;
bezier.d = bezier.d + (lht ? -width : width) * normal;
}
// NON-STOCK CODE ENDS
NetSegment.CalculateMiddlePoints(bezier.a, __instance.m_startDirection, bezier.d, __instance.m_endDirection, true, true, out bezier.b, out bezier.c);
// NON-STOCK CODE STARTS
float laneOffsetS = 0;
float startOffsetS = 0;
float endOffsetS = 0;
bool IsCSURSLaneS = CSURUtil.IsCSURSLane(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info, ref laneOffsetS, ref startOffsetS, ref endOffsetS);
float laneOffsetE = 0;
float startOffsetE = 0;
float endOffsetE = 0;
bool IsCSURSLaneE = CSURUtil.IsCSURSLane(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].Info, ref laneOffsetE, ref startOffsetE, ref endOffsetE);
Vector3 newBezierA1 = Vector3.zero;
Vector3 newBezierB1 = Vector3.zero;
Vector3 newBezierC1 = Vector3.zero;
Vector3 newBezierD1 = Vector3.zero;
if (IsCSURSLaneS || IsCSURSLaneE)
{
float vehicleLaneNum = CSURUtil.CountCSURSVehicleLanes(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info);
float otherLaneNum = CSURUtil.CountCSURSOtherLanes(Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].Info);
float laneNum = vehicleLaneNum + otherLaneNum;
startOffsetS = startOffsetS * 3.75f - laneNum * 1.875f + 1.875f + otherLaneNum * 3.75f;
endOffsetE = endOffsetE * 3.75f - laneNum * 1.875f + 1.875f + otherLaneNum * 3.75f;
if ((__instance.m_flags & NetSegment.Flags.Invert) != 0)
{
startOffsetS = -startOffsetS;
endOffsetE = -endOffsetE;
}
if (!IsCSURSLaneS)
{
startOffsetS = 0;
}
if (!IsCSURSLaneE)
{
endOffsetE = 0;
}
//EG: before patch: point1-point4 is 1.5*3.75
//After patch, point1-point4 is (1 1.3333 1.6667 2)*3.75
newBezierA1 = bezier.a + (new Vector3(__instance.m_startDirection.z, 0, -__instance.m_startDirection.x).normalized) * (startOffsetS);
Vector3 newBezierBDir = VectorUtils.NormalizeXZ(bezier.Tangent(0.333f));
newBezierB1 = bezier.b + (new Vector3(newBezierBDir.z, 0, -newBezierBDir.x).normalized) * (startOffsetS * 0.667f + endOffsetE * 0.333f);
Vector3 newBezierCDir = VectorUtils.NormalizeXZ(bezier.Tangent(0.667f));
newBezierC1 = bezier.c + (new Vector3(newBezierCDir.z, 0, -newBezierCDir.x).normalized) * (startOffsetS * 0.333f + endOffsetE * 0.667f);
newBezierD1 = bezier.d + (new Vector3(-__instance.m_endDirection.z, 0, __instance.m_endDirection.x).normalized) * (endOffsetE);
bezier.a = newBezierA1;
bezier.b = newBezierB1;
bezier.c = newBezierC1;
bezier.d = newBezierD1;
}
// NON-STOCK CODE ENDS
Vector3 vector3 = bezier.Min() + new Vector3(0f - collisionHalfWidth, info.m_minHeight, 0f - collisionHalfWidth);
Vector3 vector4 = bezier.Max() + new Vector3(collisionHalfWidth, info.m_maxHeight, collisionHalfWidth);
ItemClass.CollisionType collisionType2 = info.m_netAI.GetCollisionType();
if (vector3.x <= vector2.x && vector3.z <= vector2.y && vector.x <= vector4.x && vector.y <= vector4.z && ItemClass.CheckCollisionType(minY, maxY, vector3.y, vector4.y, collisionType, collisionType2))
{
int num = 16;
info.m_netAI.GetTerrainModifyRange(out float start, out float end);
start *= 0.5f;
end = 1f - (1f - end) * 0.5f;
float t = start;
Vector3 vector5 = bezier.Position(t);
Vector3 vector6 = bezier.Tangent(t);
vector6 = new Vector3(0f - vector6.z, 0f, vector6.x).normalized *collisionHalfWidth;
Vector3 a = vector5 + vector6;
Vector3 vector7 = vector5 - vector6;
float endRadius = info.m_netAI.GetEndRadius();
if (info.m_clipSegmentEnds && endRadius != 0f && start == 0f && (Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_startNode].m_flags & (NetNode.Flags.End | NetNode.Flags.Bend | NetNode.Flags.Junction)) != 0)
{
Vector3 vector8 = vector5;
vector8.x += vector6.x * 0.8f - vector6.z * 0.6f * endRadius / collisionHalfWidth;
vector8.z += vector6.z * 0.8f + vector6.x * 0.6f * endRadius / collisionHalfWidth;
Vector3 vector9 = vector5;
vector9.x -= vector6.x * 0.8f + vector6.z * 0.6f * endRadius / collisionHalfWidth;
vector9.z -= vector6.z * 0.8f - vector6.x * 0.6f * endRadius / collisionHalfWidth;
Vector3 d = vector5;
d.x += vector6.x * 0.3f - vector6.z * endRadius / collisionHalfWidth;
d.z += vector6.z * 0.3f + vector6.x * endRadius / collisionHalfWidth;
Vector3 c = vector5;
c.x -= vector6.x * 0.3f + vector6.z * endRadius / collisionHalfWidth;
c.z -= vector6.z * 0.3f - vector6.x * endRadius / collisionHalfWidth;
vector3.y = vector5.y + info.m_minHeight;
vector4.y = vector5.y + info.m_maxHeight;
if (ItemClass.CheckCollisionType(minY, maxY, vector3.y, vector4.y, collisionType, collisionType2))
{
if (quad.Intersect(Quad2.XZ(a, vector7, vector9, vector8)))
{
return(true);
}
if (quad.Intersect(Quad2.XZ(vector8, vector9, c, d)))
{
return(true);
}
}
}
for (int i = 1; i <= num; i++)
{
t = start + (end - start) * (float)i / (float)num;
vector5 = bezier.Position(t);
vector6 = bezier.Tangent(t);
vector6 = new Vector3(0f - vector6.z, 0f, vector6.x).normalized *collisionHalfWidth;
Vector3 vector10 = vector5 + vector6;
Vector3 vector11 = vector5 - vector6;
vector3.y = Mathf.Min(Mathf.Min(a.y, vector10.y), Mathf.Min(vector11.y, vector7.y)) + info.m_minHeight;
vector4.y = Mathf.Max(Mathf.Max(a.y, vector10.y), Mathf.Max(vector11.y, vector7.y)) + info.m_maxHeight;
if (ItemClass.CheckCollisionType(minY, maxY, vector3.y, vector4.y, collisionType, collisionType2) && quad.Intersect(Quad2.XZ(a, vector10, vector11, vector7)))
{
return(true);
}
a = vector10;
vector7 = vector11;
}
if (info.m_clipSegmentEnds && endRadius != 0f && end == 1f && (Singleton <NetManager> .instance.m_nodes.m_buffer[__instance.m_endNode].m_flags & (NetNode.Flags.End | NetNode.Flags.Bend | NetNode.Flags.Junction)) != 0)
{
Vector3 vector12 = vector5;
vector12.x += vector6.x * 0.8f + vector6.z * 0.6f * endRadius / collisionHalfWidth;
vector12.z += vector6.z * 0.8f - vector6.x * 0.6f * endRadius / collisionHalfWidth;
Vector3 vector13 = vector5;
vector13.x -= vector6.x * 0.8f - vector6.z * 0.6f * endRadius / collisionHalfWidth;
vector13.z -= vector6.z * 0.8f + vector6.x * 0.6f * endRadius / collisionHalfWidth;
Vector3 b = vector5;
b.x += vector6.x * 0.3f + vector6.z * endRadius / collisionHalfWidth;
b.z += vector6.z * 0.3f - vector6.x * endRadius / collisionHalfWidth;
Vector3 c2 = vector5;
c2.x -= vector6.x * 0.3f - vector6.z * endRadius / collisionHalfWidth;
c2.z -= vector6.z * 0.3f + vector6.x * endRadius / collisionHalfWidth;
vector3.y = vector5.y + info.m_minHeight;
vector4.y = vector5.y + info.m_maxHeight;
if (ItemClass.CheckCollisionType(minY, maxY, vector3.y, vector4.y, collisionType, collisionType2))
{
if (quad.Intersect(Quad2.XZ(a, vector12, vector13, vector7)))
{
return(true);
}
if (quad.Intersect(Quad2.XZ(vector12, b, c2, vector13)))
{
return(true);
}
}
}
}
return(false);
}
public static bool Prefix(Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType, ItemClass.Layer requireLayers, ItemClass.Layer forbidLayers, ushort ignoreNode1, ushort ignoreNode2, ushort ignoreSegment, ulong[] segmentMask, ref bool __result)
{
NetManager instance = Singleton <NetManager> .instance;
Vector2 vector = quad.Min();
Vector2 vector2 = quad.Max();
int num = Mathf.Max((int)((vector.x - 64f) / 64f + 135f), 0);
int num2 = Mathf.Max((int)((vector.y - 64f) / 64f + 135f), 0);
int num3 = Mathf.Min((int)((vector2.x + 64f) / 64f + 135f), 269);
int num4 = Mathf.Min((int)((vector2.y + 64f) / 64f + 135f), 269);
ushort num5 = 0;
ushort num6 = 0;
if (ignoreSegment != 0)
{
ushort startNode = instance.m_segments.m_buffer[ignoreSegment].m_startNode;
ushort endNode = instance.m_segments.m_buffer[ignoreSegment].m_endNode;
NetNode.Flags flags = instance.m_nodes.m_buffer[startNode].m_flags;
NetNode.Flags flags2 = instance.m_nodes.m_buffer[endNode].m_flags;
if ((flags & NetNode.Flags.Middle) != 0)
{
num5 = startNode;
}
if ((flags2 & NetNode.Flags.Middle) != 0)
{
num6 = endNode;
}
}
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num7 = instance.m_segmentGrid[i * 270 + j];
int num8 = 0;
while (num7 != 0)
{
if (num7 != ignoreSegment && ((long)instance.m_updatedSegments[num7 >> 6] & (1L << (int)num7)) == 0)
{
NetInfo info = instance.m_segments.m_buffer[num7].Info;
if ((object)info != null)
{
ItemClass.Layer collisionLayers = info.m_netAI.GetCollisionLayers();
if ((object)info != null && (requireLayers == ItemClass.Layer.None || (collisionLayers & requireLayers) != 0) && (collisionLayers & forbidLayers) == ItemClass.Layer.None)
{
ushort startNode2 = instance.m_segments.m_buffer[num7].m_startNode;
ushort endNode2 = instance.m_segments.m_buffer[num7].m_endNode;
if (startNode2 != ignoreNode1 && startNode2 != ignoreNode2 && startNode2 != num5 && startNode2 != num6 && endNode2 != ignoreNode1 && endNode2 != ignoreNode2 && endNode2 != num5 && endNode2 != num6)
{
Vector3 position = instance.m_nodes.m_buffer[startNode2].m_position;
Vector3 position2 = instance.m_nodes.m_buffer[endNode2].m_position;
// NON-STOCK CODE STARTS
if (CSURUtil.IsCSUROffset(instance.m_nodes.m_buffer[startNode2].Info))
{
bool lht = false;
if (instance.m_nodes.m_buffer[startNode2].CountSegments() != 0)
{
float collisionHalfWidth = Mathf.Max(3f, (instance.m_nodes.m_buffer[startNode2].Info.m_halfWidth + instance.m_nodes.m_buffer[startNode2].Info.m_pavementWidth) / 2f);
NetSegment mysegment = CSURUtil.GetSameInfoSegment(instance.m_nodes.m_buffer[startNode2]);
Vector3 direction = CSURUtil.CheckNodeEq(mysegment.m_startNode, instance.m_nodes.m_buffer[startNode2]) ? mysegment.m_startDirection : -mysegment.m_endDirection;
if ((mysegment.m_flags & NetSegment.Flags.Invert) != 0)
{
lht = true;
}
// normal to the right hand side
Vector3 normal = new Vector3(direction.z, 0, -direction.x).normalized;
position = position + (lht ? -collisionHalfWidth : collisionHalfWidth) * normal;
}
}
if (CSURUtil.IsCSUROffset(instance.m_nodes.m_buffer[endNode2].Info))
{
bool lht = false;
if (instance.m_nodes.m_buffer[endNode2].CountSegments() != 0)
{
float collisionHalfWidth = Mathf.Max(3f, (instance.m_nodes.m_buffer[endNode2].Info.m_halfWidth + instance.m_nodes.m_buffer[endNode2].Info.m_pavementWidth) / 2f);
NetSegment mysegment = CSURUtil.GetSameInfoSegment(instance.m_nodes.m_buffer[endNode2]);
Vector3 direction = CSURUtil.CheckNodeEq(mysegment.m_startNode, instance.m_nodes.m_buffer[endNode2]) ? mysegment.m_startDirection : -mysegment.m_endDirection;
if ((mysegment.m_flags & NetSegment.Flags.Invert) != 0)
{
lht = true;
}
// normal to the right hand side
Vector3 normal = new Vector3(direction.z, 0, -direction.x).normalized;
position2 = position2 + (lht ? -collisionHalfWidth : collisionHalfWidth) * normal;
}
}
// NON-STOCK CODE ENDS
float num9 = Mathf.Max(Mathf.Max(vector.x - 64f - position.x, vector.y - 64f - position.z), Mathf.Max(position.x - vector2.x - 64f, position.z - vector2.y - 64f));
float num10 = Mathf.Max(Mathf.Max(vector.x - 64f - position2.x, vector.y - 64f - position2.z), Mathf.Max(position2.x - vector2.x - 64f, position2.z - vector2.y - 64f));
if ((num9 < 0f || num10 < 0f) && instance.m_segments.m_buffer[num7].OverlapQuad(num7, quad, minY, maxY, collisionType))
{
if (segmentMask == null)
{
__result = true;
return(false);
}
segmentMask[num7 >> 6] |= (ulong)(1L << (int)num7);
result = true;
}
}
}
}
}
num7 = instance.m_segments.m_buffer[num7].m_nextGridSegment;
if (++num8 >= 36864)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
__result = result;
return(false);
}
public bool OverlapQuad(Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType, ItemClass.Layer layers, ushort ignoreNode1, ushort ignoreNode2, ushort ignoreSegment, ulong[] segmentMask)
{
return(false);
}
private static void ApplyBrush(TreeTool tt)
{
//uint useless1 = 0;
unsafe
{
float single;
float single1;
uint num;
int num1;
Vector3 vector3 = new Vector3();
Randomizer value = (Randomizer)tt.GetType().GetField("m_randomizer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
ToolController toolController = (ToolController)tt.GetType().GetField("m_toolController", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
Vector3 value1 = (Vector3)tt.GetType().GetField("m_mousePosition", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
bool flag = (bool)tt.GetType().GetField("m_mouseLeftDown", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
bool flag1 = (bool)tt.GetType().GetField("m_mouseRightDown", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
TreeInfo treeInfo = (TreeInfo)tt.GetType().GetField("m_treeInfo", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
float[] brushData = toolController.BrushData;
float mBrushSize = tt.m_brushSize * 0.5f;
float single2 = 32f;
int num2 = 540;
TreeInstance[] mBuffer = Singleton <TreeManager> .instance.m_trees.m_buffer;
uint[] mTreeGrid = Singleton <TreeManager> .instance.m_treeGrid;
float mStrength = tt.m_strength;
int num3 = Mathf.Max((int)((value1.x - mBrushSize) / single2 + (float)num2 * 0.5f), 0);
int num4 = Mathf.Max((int)((value1.z - mBrushSize) / single2 + (float)num2 * 0.5f), 0);
int num5 = Mathf.Min((int)((value1.x + mBrushSize) / single2 + (float)num2 * 0.5f), num2 - 1);
int num6 = Mathf.Min((int)((value1.z + mBrushSize) / single2 + (float)num2 * 0.5f), num2 - 1);
for (int i = num4; i <= num6; i++)
{
float mBrushSize1 = (float)(((float)i - (float)num2 * 0.5f + 0.5f) * single2 - value1.z + mBrushSize) / tt.m_brushSize * 64f - 0.5f;
int num7 = Mathf.Clamp(Mathf.FloorToInt(mBrushSize1), 0, 63);
int num8 = Mathf.Clamp(Mathf.CeilToInt(mBrushSize1), 0, 63);
for (int j = num3; j <= num5; j++)
{
float mBrushSize2 = (float)(((float)j - (float)num2 * 0.5f + 0.5f) * single2 - value1.x + mBrushSize) / tt.m_brushSize * 64f - 0.5f;
int num9 = Mathf.Clamp(Mathf.FloorToInt(mBrushSize2), 0, 63);
int num10 = Mathf.Clamp(Mathf.CeilToInt(mBrushSize2), 0, 63);
float single3 = brushData[num7 * 64 + num9];
float single4 = brushData[num7 * 64 + num10];
float single5 = brushData[num8 * 64 + num9];
float single6 = brushData[num8 * 64 + num10];
float single7 = single3 + (float)((single4 - single3) * (mBrushSize2 - (float)num9));
float single8 = single5 + (float)((single6 - single5) * (mBrushSize2 - (float)num9));
float single9 = single7 + (float)((single8 - single7) * (mBrushSize1 - (float)num7));
int num11 = (int)(mStrength * (single9 * 1.2f - 0.2f) * 10000f);
if (flag && tt.m_prefab != null)
{
if (value.Int32(10000) < num11)
{
TreeInfo treeInfo1 = ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) == ItemClass.Availability.None ? tt.m_prefab.GetVariation(ref value) : tt.m_prefab);
vector3.x = ((float)j - (float)num2 * 0.5f) * single2;
vector3.z = ((float)i - (float)num2 * 0.5f) * single2;
vector3.x = vector3.x + (float)(((float)value.Int32(10000) + 0.5f) * (single2 / 10000f));
vector3.z = vector3.z + (float)(((float)value.Int32(10000) + 0.5f) * (single2 / 10000f));
vector3.y = 0f;
vector3.y = Singleton <TerrainManager> .instance.SampleDetailHeight(vector3, out single, out single1);
if (Mathf.Max(Mathf.Abs(single), Mathf.Abs(single1)) < (float)value.Int32(10000) * 5E-05f)
{
float mSize = treeInfo.m_generatedInfo.m_size.y;
float mMinScale = treeInfo.m_minScale;
Randomizer randomizer = new Randomizer(Singleton <TreeManager> .instance.m_trees.NextFreeItem(ref value));
mMinScale = mMinScale + (float)randomizer.Int32(10000) * ((treeInfo.m_maxScale - treeInfo.m_minScale) * 0.0001f);
mSize = mSize * mMinScale;
float single11 = 4.5f;
Vector2 vector2 = VectorUtils.XZ(vector3);
Quad2 quad22 = new Quad2()
{
a = vector2 + new Vector2(-single11, -single11),
b = vector2 + new Vector2(-single11, single11),
c = vector2 + new Vector2(single11, single11),
d = vector2 + new Vector2(single11, -single11)
};
Quad2 quad2 = quad22;
Quad2 quad23 = new Quad2()
{
a = vector2 + new Vector2(-8f, -8f),
b = vector2 + new Vector2(-8f, 8f),
c = vector2 + new Vector2(8f, 8f),
d = vector2 + new Vector2(8f, -8f)
};
Quad2 quad21 = quad23;
float single12 = value1.y - 1000f;
float single13 = value1.y + mSize;
ItemClass.CollisionType collisionType = ItemClass.CollisionType.Terrain;
if (!Singleton <PropManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, 0, 0) && !Singleton <TreeManager> .instance.OverlapQuad(quad21, single12, single13, collisionType, 0, 0) && !Singleton <NetManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, treeInfo1.m_class.m_layer, 0, 0, 0) && !Singleton <BuildingManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, treeInfo1.m_class.m_layer, 0, 0, 0) && !Singleton <TerrainManager> .instance.HasWater(vector2) && !Singleton <GameAreaManager> .instance.QuadOutOfArea(quad2) && !Singleton <TreeManager> .instance.CreateTree(out num, ref value, treeInfo1, vector3, false))
{
}
}
}
}
else if (flag1 || tt.m_prefab == null)
{
uint num12 = mTreeGrid[i * num2 + j];
int num13 = 0;
do
{
if (num12 == 0)
{
goto Label10;
}
uint mNextGridTree = mBuffer[num12].m_nextGridTree;
if (value.Int32(10000) < num11)
{
Singleton <TreeManager> .instance.ReleaseTree(num12);
}
num12 = mNextGridTree;
num1 = num13 + 1;
num13 = num1;
}while (num1 < LimitTreeManager.Helper.TreeLimit);
CODebugBase <LogChannel> .Error(LogChannel.Core, string.Concat("Invalid list detected!\n", Environment.StackTrace));
}
Label10:
;//useless1++;
}
}
}
}
public static bool DoesTreeCollideWithTrees(Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType, TreeInfo treeInfo)
{
bool _result = false;
if (Singleton <TreeManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, 0, 0u))
{
_result = true;
}
return(_result);
}
// ========================================================================== PROP COLLISION ==========================================================================
public static bool DoesPropCollideWithProps(Quad2 quad, float minY, float maxY, ItemClass.CollisionType collisionType, PropInfo propInfo)
{
bool _result = false;
if (Singleton <PropManager> .instance.OverlapQuad(quad, minY, maxY, collisionType, 0, 0))
{
_result = true;
}
return(_result);
}
