|
public static Intersection ( |
||
| a | ||
| b | ||
| return | ||
public override List <GraphNode> GetNodesInRegion(IntRect rect)
{
List <GraphNode> list = ListPool <GraphNode> .Claim();
IntRect b = new IntRect(0, 0, this.width - 1, this.depth - 1);
rect = IntRect.Intersection(rect, b);
if (this.nodes == null || !rect.IsValid() || this.nodes.Length != this.width * this.depth * this.layerCount)
{
return(list);
}
for (int i = 0; i < this.layerCount; i++)
{
int num = i * base.Width * base.Depth;
for (int j = rect.ymin; j <= rect.ymax; j++)
{
int num2 = num + j * base.Width;
for (int k = rect.xmin; k <= rect.xmax; k++)
{
LevelGridNode levelGridNode = this.nodes[num2 + k];
if (levelGridNode != null)
{
list.Add(levelGridNode);
}
}
}
}
return(list);
}
/// <summary>Creates a list for every tile and adds every mesh that touches a tile to the corresponding list</summary>
List <RasterizationMesh>[] PutMeshesIntoTileBuckets(List <RasterizationMesh> meshes, IntRect tileBuckets)
{
var bucketCount = tileBuckets.Width * tileBuckets.Height;
var result = new List <RasterizationMesh> [bucketCount];
var borderExpansion = new Vector3(1, 0, 1) * TileBorderSizeInWorldUnits * 2;
for (int i = 0; i < result.Length; i++)
{
result[i] = ListPool <RasterizationMesh> .Claim();
}
var offset = new Int2(-tileBuckets.xmin, -tileBuckets.ymin);
var clamp = new IntRect(0, 0, tileBuckets.Width - 1, tileBuckets.Height - 1);
for (int i = 0; i < meshes.Count; i++)
{
var mesh = meshes[i];
var bounds = mesh.bounds;
// Expand borderSize voxels on each side
bounds.Expand(borderExpansion);
var rect = GetTouchingTiles(bounds);
rect = IntRect.Intersection(rect.Offset(offset), clamp);
for (int z = rect.ymin; z <= rect.ymax; z++)
{
for (int x = rect.xmin; x <= rect.xmax; x++)
{
result[x + z * tileBuckets.Width].Add(mesh);
}
}
}
return(result);
}
/** Returns a rect containing the indices of all tiles touching the specified bounds.
* \param rect Graph space rectangle (in graph space all tiles are on the XZ plane regardless of graph rotation and other transformations, the first tile has a corner at the origin)
*/
public static IntRect GetTouchingTilesInGraphSpace(this NavmeshBase self, Rect rect)
{
// Calculate world bounds of all affected tiles
var r = new IntRect(Mathf.FloorToInt(rect.xMin / self.TileWorldSizeX), Mathf.FloorToInt(rect.yMin / self.TileWorldSizeZ), Mathf.FloorToInt(rect.xMax / self.TileWorldSizeX), Mathf.FloorToInt(rect.yMax / self.TileWorldSizeZ));
// Clamp to bounds
r = IntRect.Intersection(r, new IntRect(0, 0, self.tileXCount - 1, self.tileZCount - 1));
return(r);
}
/** Returns a rect containing the indices of all tiles touching the specified bounds */
public static IntRect GetTouchingTiles(this NavmeshBase self, Bounds bounds)
{
bounds = self.transform.InverseTransform(bounds);
// Calculate world bounds of all affected tiles
var r = new IntRect(Mathf.FloorToInt(bounds.min.x / self.TileWorldSizeX), Mathf.FloorToInt(bounds.min.z / self.TileWorldSizeZ), Mathf.FloorToInt(bounds.max.x / self.TileWorldSizeX), Mathf.FloorToInt(bounds.max.z / self.TileWorldSizeZ));
// Clamp to bounds
r = IntRect.Intersection(r, new IntRect(0, 0, self.tileXCount - 1, self.tileZCount - 1));
return(r);
}
public override int GetNodesInRegion(IntRect rect, GridNodeBase[] buffer)
{
IntRect b = new IntRect(0, 0, this.width - 1, this.depth - 1);
rect = IntRect.Intersection(rect, b);
if (this.nodes == null || !rect.IsValid() || this.nodes.Length != this.width * this.depth * this.layerCount)
{
return(0);
}
int num = 0;
try
{
for (int i = 0; i < this.layerCount; i++)
{
int num2 = i * base.Width * base.Depth;
for (int j = rect.ymin; j <= rect.ymax; j++)
{
int num3 = num2 + j * base.Width;
for (int k = rect.xmin; k <= rect.xmax; k++)
{
LevelGridNode levelGridNode = this.nodes[num3 + k];
if (levelGridNode != null)
{
buffer[num] = levelGridNode;
num++;
}
}
}
}
}
catch (IndexOutOfRangeException)
{
throw new ArgumentException("Buffer is too small");
}
return(num);
}
/// <summary>Async method for moving the graph</summary>
IEnumerator UpdateGraphCoroutine()
{
// Find the direction that we want to move the graph in.
// Calcuculate this in graph space (where a distance of one is the size of one node)
Vector3 dir = PointToGraphSpace(target.position) - PointToGraphSpace(graph.center);
// Snap to a whole number of nodes
dir.x = Mathf.Round(dir.x);
dir.z = Mathf.Round(dir.z);
dir.y = 0;
// Nothing do to
if (dir == Vector3.zero)
{
yield break;
}
// Number of nodes to offset in each direction
Int2 offset = new Int2(-Mathf.RoundToInt(dir.x), -Mathf.RoundToInt(dir.z));
// Move the center (this is in world units, so we need to convert it back from graph space)
graph.center += graph.transform.TransformVector(dir);
graph.UpdateTransform();
// Cache some variables for easier access
int width = graph.width;
int depth = graph.depth;
GridNodeBase[] nodes;
// Layers are required when handling LayeredGridGraphs
int layers = graph.LayerCount;
var layeredGraph = graph as LayerGridGraph;
if (layeredGraph != null)
{
nodes = layeredGraph.nodes;
}
else
{
nodes = graph.nodes;
}
// Create a temporary buffer required for the calculations
if (buffer == null || buffer.Length != width * depth)
{
buffer = new GridNodeBase[width * depth];
}
// Check if we have moved less than a whole graph width all directions
// If we have moved more than this we can just as well recalculate the whole graph
if (Mathf.Abs(offset.x) <= width && Mathf.Abs(offset.y) <= depth)
{
IntRect recalculateRect = new IntRect(0, 0, offset.x, offset.y);
// If offset.x < 0, adjust the rect
if (recalculateRect.xmin > recalculateRect.xmax)
{
int tmp2 = recalculateRect.xmax;
recalculateRect.xmax = width + recalculateRect.xmin;
recalculateRect.xmin = width + tmp2;
}
// If offset.y < 0, adjust the rect
if (recalculateRect.ymin > recalculateRect.ymax)
{
int tmp2 = recalculateRect.ymax;
recalculateRect.ymax = depth + recalculateRect.ymin;
recalculateRect.ymin = depth + tmp2;
}
// Connections need to be recalculated for the neighbours as well, so we need to expand the rect by 1
var connectionRect = recalculateRect.Expand(1);
// Makes sure the rect stays inside the grid
connectionRect = IntRect.Intersection(connectionRect, new IntRect(0, 0, width, depth));
// Offset each node by the #offset variable
// nodes which would end up outside the graph
// will wrap around to the other side of it
for (int l = 0; l < layers; l++)
{
int layerOffset = l * width * depth;
for (int z = 0; z < depth; z++)
{
int pz = z * width;
int tz = ((z + offset.y + depth) % depth) * width;
for (int x = 0; x < width; x++)
{
buffer[tz + ((x + offset.x + width) % width)] = nodes[layerOffset + pz + x];
}
}
yield return(null);
// Copy the nodes back to the graph
// and set the correct indices
for (int z = 0; z < depth; z++)
{
int pz = z * width;
for (int x = 0; x < width; x++)
{
int newIndex = pz + x;
var node = buffer[newIndex];
if (node != null)
{
node.NodeInGridIndex = newIndex;
}
nodes[layerOffset + newIndex] = node;
}
// Calculate the limits for the region that has been wrapped
// to the other side of the graph
int xmin, xmax;
if (z >= recalculateRect.ymin && z < recalculateRect.ymax)
{
xmin = 0;
xmax = depth;
}
else
{
xmin = recalculateRect.xmin;
xmax = recalculateRect.xmax;
}
for (int x = xmin; x < xmax; x++)
{
var node = buffer[pz + x];
if (node != null)
{
// Clear connections on all nodes that are wrapped and placed on the other side of the graph.
// This is both to clear any custom connections (which do not really make sense after moving the node)
// and to prevent possible exceptions when the node will later (possibly) be destroyed because it was
// not needed anymore (only for layered grid graphs).
node.ClearConnections(false);
}
}
}
yield return(null);
}
// The calculation will only update approximately this number of
// nodes per frame. This is used to keep CPU load per frame low
int yieldEvery = 1000;
// To avoid the update taking too long, make yieldEvery somewhat proportional to the number of nodes that we are going to update
int approxNumNodesToUpdate = Mathf.Max(Mathf.Abs(offset.x), Mathf.Abs(offset.y)) * Mathf.Max(width, depth);
yieldEvery = Mathf.Max(yieldEvery, approxNumNodesToUpdate / 10);
int counter = 0;
// Recalculate the nodes
// Take a look at the image in the docs for the UpdateGraph method
// to see which nodes are being recalculated.
for (int z = 0; z < depth; z++)
{
int xmin, xmax;
if (z >= recalculateRect.ymin && z < recalculateRect.ymax)
{
xmin = 0;
xmax = width;
}
else
{
xmin = recalculateRect.xmin;
xmax = recalculateRect.xmax;
}
for (int x = xmin; x < xmax; x++)
{
graph.RecalculateCell(x, z, false, false);
}
counter += (xmax - xmin);
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
}
for (int z = 0; z < depth; z++)
{
int xmin, xmax;
if (z >= connectionRect.ymin && z < connectionRect.ymax)
{
xmin = 0;
xmax = width;
}
else
{
xmin = connectionRect.xmin;
xmax = connectionRect.xmax;
}
for (int x = xmin; x < xmax; x++)
{
graph.CalculateConnections(x, z);
}
counter += (xmax - xmin);
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
}
yield return(null);
// Calculate all connections for the nodes along the boundary
// of the graph, these always need to be updated
/// <summary>TODO: Optimize to not traverse all nodes in the graph, only those at the edges</summary>
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
if (x == 0 || z == 0 || x == width - 1 || z == depth - 1)
{
graph.CalculateConnections(x, z);
}
}
}
}
else
{
// The calculation will only update approximately this number of
// nodes per frame. This is used to keep CPU load per frame low
int yieldEvery = Mathf.Max(depth * width / 20, 1000);
int counter = 0;
// Just update all nodes
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
graph.RecalculateCell(x, z);
}
counter += width;
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
}
// Recalculate the connections of all nodes
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
graph.CalculateConnections(x, z);
}
counter += width;
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
}
}
}
public new void UpdateArea(GraphUpdateObject o)
{
if (this.nodes == null || this.nodes.Length != this.width * this.depth * this.layerCount)
{
Debug.LogWarning("The Grid Graph is not scanned, cannot update area ");
return;
}
IntRect a;
IntRect a2;
IntRect intRect;
bool flag;
int num;
base.CalculateAffectedRegions(o, out a, out a2, out intRect, out flag, out num);
bool flag2 = o is LayerGridGraphUpdate && ((LayerGridGraphUpdate)o).recalculateNodes;
bool flag3 = (!(o is LayerGridGraphUpdate)) ? (!o.resetPenaltyOnPhysics) : ((LayerGridGraphUpdate)o).preserveExistingNodes;
if (o.trackChangedNodes && flag2)
{
Debug.LogError("Cannot track changed nodes when creating or deleting nodes.\nWill not update LayerGridGraph");
return;
}
IntRect b = new IntRect(0, 0, this.width - 1, this.depth - 1);
IntRect intRect2 = IntRect.Intersection(a2, b);
if (!flag2)
{
for (int i = intRect2.xmin; i <= intRect2.xmax; i++)
{
for (int j = intRect2.ymin; j <= intRect2.ymax; j++)
{
for (int k = 0; k < this.layerCount; k++)
{
o.WillUpdateNode(this.nodes[k * this.width * this.depth + j * this.width + i]);
}
}
}
}
if (o.updatePhysics && !o.modifyWalkability)
{
this.collision.Initialize(base.transform, this.nodeSize);
intRect2 = IntRect.Intersection(intRect, b);
for (int l = intRect2.xmin; l <= intRect2.xmax; l++)
{
for (int m = intRect2.ymin; m <= intRect2.ymax; m++)
{
this.RecalculateCell(l, m, !flag3, false);
}
}
for (int n = intRect2.xmin; n <= intRect2.xmax; n++)
{
for (int num2 = intRect2.ymin; num2 <= intRect2.ymax; num2++)
{
this.CalculateConnections(n, num2);
}
}
}
intRect2 = IntRect.Intersection(a, b);
for (int num3 = intRect2.xmin; num3 <= intRect2.xmax; num3++)
{
for (int num4 = intRect2.ymin; num4 <= intRect2.ymax; num4++)
{
for (int num5 = 0; num5 < this.layerCount; num5++)
{
int num6 = num5 * this.width * this.depth + num4 * this.width + num3;
LevelGridNode levelGridNode = this.nodes[num6];
if (levelGridNode != null)
{
if (flag)
{
levelGridNode.Walkable = levelGridNode.WalkableErosion;
if (o.bounds.Contains((Vector3)levelGridNode.position))
{
o.Apply(levelGridNode);
}
levelGridNode.WalkableErosion = levelGridNode.Walkable;
}
else if (o.bounds.Contains((Vector3)levelGridNode.position))
{
o.Apply(levelGridNode);
}
}
}
}
}
if (flag && num == 0)
{
intRect2 = IntRect.Intersection(a2, b);
for (int num7 = intRect2.xmin; num7 <= intRect2.xmax; num7++)
{
for (int num8 = intRect2.ymin; num8 <= intRect2.ymax; num8++)
{
this.CalculateConnections(num7, num8);
}
}
}
else if (flag && num > 0)
{
IntRect a3 = IntRect.Union(a, intRect).Expand(num);
IntRect a4 = a3.Expand(num);
a3 = IntRect.Intersection(a3, b);
a4 = IntRect.Intersection(a4, b);
for (int num9 = a4.xmin; num9 <= a4.xmax; num9++)
{
for (int num10 = a4.ymin; num10 <= a4.ymax; num10++)
{
for (int num11 = 0; num11 < this.layerCount; num11++)
{
int num12 = num11 * this.width * this.depth + num10 * this.width + num9;
LevelGridNode levelGridNode2 = this.nodes[num12];
if (levelGridNode2 != null)
{
bool walkable = levelGridNode2.Walkable;
levelGridNode2.Walkable = levelGridNode2.WalkableErosion;
if (!a3.Contains(num9, num10))
{
levelGridNode2.TmpWalkable = walkable;
}
}
}
}
}
for (int num13 = a4.xmin; num13 <= a4.xmax; num13++)
{
for (int num14 = a4.ymin; num14 <= a4.ymax; num14++)
{
this.CalculateConnections(num13, num14);
}
}
base.ErodeWalkableArea(a4.xmin, a4.ymin, a4.xmax + 1, a4.ymax + 1);
for (int num15 = a4.xmin; num15 <= a4.xmax; num15++)
{
for (int num16 = a4.ymin; num16 <= a4.ymax; num16++)
{
if (!a3.Contains(num15, num16))
{
for (int num17 = 0; num17 < this.layerCount; num17++)
{
int num18 = num17 * this.width * this.depth + num16 * this.width + num15;
LevelGridNode levelGridNode3 = this.nodes[num18];
if (levelGridNode3 != null)
{
levelGridNode3.Walkable = levelGridNode3.TmpWalkable;
}
}
}
}
}
for (int num19 = a4.xmin; num19 <= a4.xmax; num19++)
{
for (int num20 = a4.ymin; num20 <= a4.ymax; num20++)
{
this.CalculateConnections(num19, num20);
}
}
}
}
// Token: 0x06002430 RID: 9264 RVA: 0x00196841 File Offset: 0x00194A41
private IEnumerator UpdateGraphCoroutine()
{
Vector3 vector = this.PointToGraphSpace(this.target.position) - this.PointToGraphSpace(this.graph.center);
vector.x = Mathf.Round(vector.x);
vector.z = Mathf.Round(vector.z);
vector.y = 0f;
if (vector == Vector3.zero)
{
yield break;
}
Int2 offset = new Int2(-Mathf.RoundToInt(vector.x), -Mathf.RoundToInt(vector.z));
this.graph.center += this.graph.transform.TransformVector(vector);
this.graph.UpdateTransform();
int width = this.graph.width;
int depth = this.graph.depth;
int layers = this.graph.LayerCount;
LayerGridGraph layerGridGraph = this.graph as LayerGridGraph;
GridNodeBase[] nodes;
if (layerGridGraph != null)
{
GridNodeBase[] nodes2 = layerGridGraph.nodes;
nodes = nodes2;
}
else
{
GridNodeBase[] nodes2 = this.graph.nodes;
nodes = nodes2;
}
if (this.buffer == null || this.buffer.Length != width * depth)
{
this.buffer = new GridNodeBase[width * depth];
}
if (Mathf.Abs(offset.x) <= width && Mathf.Abs(offset.y) <= depth)
{
IntRect recalculateRect = new IntRect(0, 0, offset.x, offset.y);
if (recalculateRect.xmin > recalculateRect.xmax)
{
int xmax = recalculateRect.xmax;
recalculateRect.xmax = width + recalculateRect.xmin;
recalculateRect.xmin = width + xmax;
}
if (recalculateRect.ymin > recalculateRect.ymax)
{
int ymax = recalculateRect.ymax;
recalculateRect.ymax = depth + recalculateRect.ymin;
recalculateRect.ymin = depth + ymax;
}
IntRect connectionRect = recalculateRect.Expand(1);
connectionRect = IntRect.Intersection(connectionRect, new IntRect(0, 0, width, depth));
int num7;
for (int i = 0; i < layers; i = num7 + 1)
{
int layerOffset = i * width * depth;
for (int j = 0; j < depth; j++)
{
int num = j * width;
int num2 = (j + offset.y + depth) % depth * width;
for (int k = 0; k < width; k++)
{
this.buffer[num2 + (k + offset.x + width) % width] = nodes[layerOffset + num + k];
}
}
yield return(null);
for (int l = 0; l < depth; l++)
{
int num3 = l * width;
for (int m = 0; m < width; m++)
{
int num4 = num3 + m;
GridNodeBase gridNodeBase = this.buffer[num4];
if (gridNodeBase != null)
{
gridNodeBase.NodeInGridIndex = num4;
}
nodes[layerOffset + num4] = gridNodeBase;
}
int num5;
int num6;
if (l >= recalculateRect.ymin && l < recalculateRect.ymax)
{
num5 = 0;
num6 = depth;
}
else
{
num5 = recalculateRect.xmin;
num6 = recalculateRect.xmax;
}
for (int n = num5; n < num6; n++)
{
GridNodeBase gridNodeBase2 = this.buffer[num3 + n];
if (gridNodeBase2 != null)
{
gridNodeBase2.ClearConnections(false);
}
}
}
yield return(null);
num7 = i;
}
int yieldEvery = 1000;
int num8 = Mathf.Max(Mathf.Abs(offset.x), Mathf.Abs(offset.y)) * Mathf.Max(width, depth);
yieldEvery = Mathf.Max(yieldEvery, num8 / 10);
int counter = 0;
for (int i = 0; i < depth; i = num7 + 1)
{
int num9;
int num10;
if (i >= recalculateRect.ymin && i < recalculateRect.ymax)
{
num9 = 0;
num10 = width;
}
else
{
num9 = recalculateRect.xmin;
num10 = recalculateRect.xmax;
}
for (int num11 = num9; num11 < num10; num11++)
{
this.graph.RecalculateCell(num11, i, false, false);
}
counter += num10 - num9;
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
num7 = i;
}
for (int i = 0; i < depth; i = num7 + 1)
{
int num12;
int num13;
if (i >= connectionRect.ymin && i < connectionRect.ymax)
{
num12 = 0;
num13 = width;
}
else
{
num12 = connectionRect.xmin;
num13 = connectionRect.xmax;
}
for (int num14 = num12; num14 < num13; num14++)
{
this.graph.CalculateConnections(num14, i);
}
counter += num13 - num12;
if (counter > yieldEvery)
{
counter = 0;
yield return(null);
}
num7 = i;
}
yield return(null);
for (int num15 = 0; num15 < depth; num15++)
{
for (int num16 = 0; num16 < width; num16++)
{
if (num16 == 0 || num15 == 0 || num16 == width - 1 || num15 == depth - 1)
{
this.graph.CalculateConnections(num16, num15);
}
}
}
if (!this.floodFill)
{
this.graph.GetNodes(delegate(GraphNode node)
{
node.Area = 1u;
});
}
}
else
{
int counter = Mathf.Max(depth * width / 20, 1000);
int yieldEvery = 0;
int num7;
for (int i = 0; i < depth; i = num7 + 1)
{
for (int num17 = 0; num17 < width; num17++)
{
this.graph.RecalculateCell(num17, i, true, true);
}
yieldEvery += width;
if (yieldEvery > counter)
{
yieldEvery = 0;
yield return(null);
}
num7 = i;
}
for (int i = 0; i < depth; i = num7 + 1)
{
for (int num18 = 0; num18 < width; num18++)
{
this.graph.CalculateConnections(num18, i);
}
yieldEvery += width;
if (yieldEvery > counter)
{
yieldEvery = 0;
yield return(null);
}
num7 = i;
}
}
yield break;
}
public new void UpdateArea(GraphUpdateObject o)
{
if (this.nodes == null || this.nodes.Length != this.width * this.depth * this.layerCount)
{
Debug.LogWarning("The Grid Graph is not scanned, cannot update area ");
return;
}
Bounds bounds = o.bounds;
Vector3 a;
Vector3 a2;
base.GetBoundsMinMax(bounds, this.inverseMatrix, out a, out a2);
int xmin = Mathf.RoundToInt(a.x - 0.5f);
int xmax = Mathf.RoundToInt(a2.x - 0.5f);
int ymin = Mathf.RoundToInt(a.z - 0.5f);
int ymax = Mathf.RoundToInt(a2.z - 0.5f);
IntRect intRect = new IntRect(xmin, ymin, xmax, ymax);
IntRect intRect2 = intRect;
IntRect b = new IntRect(0, 0, this.width - 1, this.depth - 1);
IntRect intRect3 = intRect;
bool flag = o.updatePhysics || o.modifyWalkability;
bool flag2 = o is LayerGridGraphUpdate && ((LayerGridGraphUpdate)o).recalculateNodes;
bool preserveExistingNodes = !(o is LayerGridGraphUpdate) || ((LayerGridGraphUpdate)o).preserveExistingNodes;
int num = (!o.updateErosion) ? 0 : this.erodeIterations;
if (o.trackChangedNodes && flag2)
{
Debug.LogError("Cannot track changed nodes when creating or deleting nodes.\nWill not update LayerGridGraph");
return;
}
if (o.updatePhysics && !o.modifyWalkability && this.collision.collisionCheck)
{
Vector3 a3 = new Vector3(this.collision.diameter, 0f, this.collision.diameter) * 0.5f;
a -= a3 * 1.02f;
a2 += a3 * 1.02f;
intRect3 = new IntRect(Mathf.RoundToInt(a.x - 0.5f), Mathf.RoundToInt(a.z - 0.5f), Mathf.RoundToInt(a2.x - 0.5f), Mathf.RoundToInt(a2.z - 0.5f));
intRect2 = IntRect.Union(intRect3, intRect2);
}
if (flag || num > 0)
{
intRect2 = intRect2.Expand(num + 1);
}
IntRect intRect4 = IntRect.Intersection(intRect2, b);
if (!flag2)
{
for (int i = intRect4.xmin; i <= intRect4.xmax; i++)
{
for (int j = intRect4.ymin; j <= intRect4.ymax; j++)
{
for (int k = 0; k < this.layerCount; k++)
{
o.WillUpdateNode(this.nodes[k * this.width * this.depth + j * this.width + i]);
}
}
}
}
if (o.updatePhysics && !o.modifyWalkability)
{
this.collision.Initialize(this.matrix, this.nodeSize);
intRect4 = IntRect.Intersection(intRect3, b);
bool flag3 = false;
for (int l = intRect4.xmin; l <= intRect4.xmax; l++)
{
for (int m = intRect4.ymin; m <= intRect4.ymax; m++)
{
flag3 |= this.RecalculateCell(l, m, preserveExistingNodes);
}
}
for (int n = intRect4.xmin; n <= intRect4.xmax; n++)
{
for (int num2 = intRect4.ymin; num2 <= intRect4.ymax; num2++)
{
for (int num3 = 0; num3 < this.layerCount; num3++)
{
int num4 = num3 * this.width * this.depth + num2 * this.width + n;
LevelGridNode levelGridNode = this.nodes[num4];
if (levelGridNode != null)
{
this.CalculateConnections(this.nodes, levelGridNode, n, num2, num3);
}
}
}
}
}
intRect4 = IntRect.Intersection(intRect, b);
for (int num5 = intRect4.xmin; num5 <= intRect4.xmax; num5++)
{
for (int num6 = intRect4.ymin; num6 <= intRect4.ymax; num6++)
{
for (int num7 = 0; num7 < this.layerCount; num7++)
{
int num8 = num7 * this.width * this.depth + num6 * this.width + num5;
LevelGridNode levelGridNode2 = this.nodes[num8];
if (levelGridNode2 != null)
{
if (flag)
{
levelGridNode2.Walkable = levelGridNode2.WalkableErosion;
if (o.bounds.Contains((Vector3)levelGridNode2.position))
{
o.Apply(levelGridNode2);
}
levelGridNode2.WalkableErosion = levelGridNode2.Walkable;
}
else if (o.bounds.Contains((Vector3)levelGridNode2.position))
{
o.Apply(levelGridNode2);
}
}
}
}
}
if (flag && num == 0)
{
intRect4 = IntRect.Intersection(intRect2, b);
for (int num9 = intRect4.xmin; num9 <= intRect4.xmax; num9++)
{
for (int num10 = intRect4.ymin; num10 <= intRect4.ymax; num10++)
{
for (int num11 = 0; num11 < this.layerCount; num11++)
{
int num12 = num11 * this.width * this.depth + num10 * this.width + num9;
LevelGridNode levelGridNode3 = this.nodes[num12];
if (levelGridNode3 != null)
{
this.CalculateConnections(this.nodes, levelGridNode3, num9, num10, num11);
}
}
}
}
}
else if (flag && num > 0)
{
IntRect a4 = IntRect.Union(intRect, intRect3).Expand(num);
IntRect a5 = a4.Expand(num);
a4 = IntRect.Intersection(a4, b);
a5 = IntRect.Intersection(a5, b);
for (int num13 = a5.xmin; num13 <= a5.xmax; num13++)
{
for (int num14 = a5.ymin; num14 <= a5.ymax; num14++)
{
for (int num15 = 0; num15 < this.layerCount; num15++)
{
int num16 = num15 * this.width * this.depth + num14 * this.width + num13;
LevelGridNode levelGridNode4 = this.nodes[num16];
if (levelGridNode4 != null)
{
bool walkable = levelGridNode4.Walkable;
levelGridNode4.Walkable = levelGridNode4.WalkableErosion;
if (!a4.Contains(num13, num14))
{
levelGridNode4.TmpWalkable = walkable;
}
}
}
}
}
for (int num17 = a5.xmin; num17 <= a5.xmax; num17++)
{
for (int num18 = a5.ymin; num18 <= a5.ymax; num18++)
{
for (int num19 = 0; num19 < this.layerCount; num19++)
{
int num20 = num19 * this.width * this.depth + num18 * this.width + num17;
LevelGridNode levelGridNode5 = this.nodes[num20];
if (levelGridNode5 != null)
{
this.CalculateConnections(this.nodes, levelGridNode5, num17, num18, num19);
}
}
}
}
this.ErodeWalkableArea(a5.xmin, a5.ymin, a5.xmax + 1, a5.ymax + 1);
for (int num21 = a5.xmin; num21 <= a5.xmax; num21++)
{
for (int num22 = a5.ymin; num22 <= a5.ymax; num22++)
{
if (!a4.Contains(num21, num22))
{
for (int num23 = 0; num23 < this.layerCount; num23++)
{
int num24 = num23 * this.width * this.depth + num22 * this.width + num21;
LevelGridNode levelGridNode6 = this.nodes[num24];
if (levelGridNode6 != null)
{
levelGridNode6.Walkable = levelGridNode6.TmpWalkable;
}
}
}
}
}
for (int num25 = a5.xmin; num25 <= a5.xmax; num25++)
{
for (int num26 = a5.ymin; num26 <= a5.ymax; num26++)
{
for (int num27 = 0; num27 < this.layerCount; num27++)
{
int num28 = num27 * this.width * this.depth + num26 * this.width + num25;
LevelGridNode levelGridNode7 = this.nodes[num28];
if (levelGridNode7 != null)
{
this.CalculateConnections(this.nodes, levelGridNode7, num25, num26, num27);
}
}
}
}
}
}
