private void AddGraphObstacles(Simulator sim, INavmesh ng)
{
int[] uses = new int[3];
Dictionary <int, int> outline = new Dictionary <int, int>();
Dictionary <int, Int3> vertexPositions = new Dictionary <int, Int3>();
HashSet <int> hasInEdge = new HashSet <int>();
ng.GetNodes(delegate(GraphNode _node)
{
TriangleMeshNode triangleMeshNode = _node as TriangleMeshNode;
uses[0] = (uses[1] = (uses[2] = 0));
if (triangleMeshNode != null)
{
for (int i = 0; i < triangleMeshNode.connections.Length; i++)
{
TriangleMeshNode triangleMeshNode2 = triangleMeshNode.connections[i].node as TriangleMeshNode;
if (triangleMeshNode2 != null)
{
int num = triangleMeshNode.SharedEdge(triangleMeshNode2);
if (num != -1)
{
uses[num] = 1;
}
}
}
for (int j = 0; j < 3; j++)
{
if (uses[j] == 0)
{
int i2 = j;
int i3 = (j + 1) % triangleMeshNode.GetVertexCount();
outline[triangleMeshNode.GetVertexIndex(i2)] = triangleMeshNode.GetVertexIndex(i3);
hasInEdge.Add(triangleMeshNode.GetVertexIndex(i3));
vertexPositions[triangleMeshNode.GetVertexIndex(i2)] = triangleMeshNode.GetVertex(i2);
vertexPositions[triangleMeshNode.GetVertexIndex(i3)] = triangleMeshNode.GetVertex(i3);
}
}
}
});
List <Vector3> vertices = ListPool <Vector3> .Claim();
RVONavmesh.CompressContour(outline, hasInEdge, delegate(List <int> chain, bool cycle)
{
for (int i = 0; i < chain.Count; i++)
{
vertices.Add((Vector3)vertexPositions[chain[i]]);
}
this.obstacles.Add(sim.AddObstacle(vertices.ToArray(), this.wallHeight, cycle));
vertices.Clear();
});
ListPool <Vector3> .Release(vertices);
}
private static void MoveFromNode(TriangleMeshNode node, int startEdge, VInt3 srcLoc, VInt3 destLoc, MoveDirectionState state, out VInt3 result)
{
result = srcLoc;
while (node != null)
{
int num;
int num10;
int count = 2;
if (node.IsVertex(srcLoc, out num))
{
int vertexIndex = node.GetVertexIndex(num);
List <TMNodeInfo> nodeInfos = null;
GetAllNodesByVert(ref nodeInfos, node, vertexIndex);
TriangleMeshNode node2 = null;
int vi = -1;
for (int i = 0; i < nodeInfos.Count; i++)
{
TMNodeInfo info = nodeInfos[i];
if ((!checkedNodes.Contains(info.node) && !Polygon.LeftNotColinear(info.v0, info.v2, destLoc)) && Polygon.Left(info.v0, info.v1, destLoc))
{
node2 = info.node;
vi = info.vi;
break;
}
}
if (node2 != null)
{
node = node2;
startEdge = (vi + 1) % 3;
count = 1;
}
else
{
int num6 = -1;
VFactor factor = new VFactor {
nom = -2L,
den = 1L
};
for (int j = 0; j < nodeInfos.Count; j++)
{
TMNodeInfo info2 = nodeInfos[j];
if (!checkedNodes.Contains(info2.node))
{
int num8;
VFactor factor2 = info2.GetCosineAngle(destLoc, state, out num8);
if (factor2 > factor)
{
factor = factor2;
num6 = num8;
node2 = info2.node;
}
}
}
if (node2 != null)
{
MoveAlongEdge(node2, num6, srcLoc, destLoc, state, out result, true);
break;
}
}
}
int edge = -1;
if (startEdge == -1)
{
edge = node.EdgeIntersect(srcLoc, destLoc);
}
else
{
edge = node.EdgeIntersect(srcLoc, destLoc, startEdge, count);
}
if (edge == -1)
{
if (node.ContainsPoint(destLoc))
{
result = destLoc;
if (MoveAxisY)
{
CalculateY(ref result, node);
}
}
else
{
edge = node.GetColinearEdge(srcLoc, destLoc);
if (edge != -1)
{
MoveAlongEdge(node, edge, srcLoc, destLoc, state, out result, true);
}
}
break;
}
TriangleMeshNode neighborByEdge = node.GetNeighborByEdge(edge, out num10);
if (neighborByEdge != null)
{
node = neighborByEdge;
startEdge = num10 + 1;
count = 2;
}
else
{
MoveAlongEdge(node, edge, srcLoc, destLoc, state, out result, true);
break;
}
}
}
public void AddGraphObstacles(Simulator sim, INavmesh ng)
{
if (this.obstacles.Count > 0 && this.lastSim != null && this.lastSim != sim)
{
Debug.LogError("Simulator has changed but some old obstacles are still added for the previous simulator. Deleting previous obstacles.");
this.RemoveObstacles();
}
this.lastSim = sim;
int[] uses = new int[20];
Dictionary <int, int> outline = new Dictionary <int, int>();
Dictionary <int, Int3> vertexPositions = new Dictionary <int, Int3>();
HashSet <int> hasInEdge = new HashSet <int>();
ng.GetNodes(delegate(GraphNode _node)
{
TriangleMeshNode triangleMeshNode = _node as TriangleMeshNode;
uses[0] = (uses[1] = (uses[2] = 0));
if (triangleMeshNode != null)
{
for (int j = 0; j < triangleMeshNode.connections.Length; j++)
{
TriangleMeshNode triangleMeshNode2 = triangleMeshNode.connections[j] as TriangleMeshNode;
if (triangleMeshNode2 != null)
{
int num3 = triangleMeshNode.SharedEdge(triangleMeshNode2);
if (num3 != -1)
{
uses[num3] = 1;
}
}
}
for (int k = 0; k < 3; k++)
{
if (uses[k] == 0)
{
int i2 = k;
int i3 = (k + 1) % triangleMeshNode.GetVertexCount();
outline[triangleMeshNode.GetVertexIndex(i2)] = triangleMeshNode.GetVertexIndex(i3);
hasInEdge.Add(triangleMeshNode.GetVertexIndex(i3));
vertexPositions[triangleMeshNode.GetVertexIndex(i2)] = triangleMeshNode.GetVertex(i2);
vertexPositions[triangleMeshNode.GetVertexIndex(i3)] = triangleMeshNode.GetVertex(i3);
}
}
}
return(true);
});
for (int i = 0; i < 2; i++)
{
bool flag = i == 1;
foreach (int num in new List <int>(outline.Keys))
{
if (flag || !hasInEdge.Contains(num))
{
int key = num;
List <Vector3> list = new List <Vector3>();
list.Add((Vector3)vertexPositions[key]);
while (outline.ContainsKey(key))
{
int num2 = outline[key];
outline.Remove(key);
Vector3 item = (Vector3)vertexPositions[num2];
list.Add(item);
if (num2 == num)
{
break;
}
key = num2;
}
if (list.Count > 1)
{
sim.AddObstacle(list.ToArray(), this.wallHeight, flag);
}
}
}
}
}
// Token: 0x0600001A RID: 26 RVA: 0x00002B84 File Offset: 0x00000F84
public GraphNode ClampAlongNavmesh(Vector3 startPos, GraphNode _startNode, Vector3 endPos, out Vector3 clampedPos)
{
TriangleMeshNode triangleMeshNode = (TriangleMeshNode)_startNode;
clampedPos = endPos;
Stack <TriangleMeshNode> stack = this.tmpStack;
List <TriangleMeshNode> list = this.tmpClosed;
stack.Clear();
list.Clear();
float num = float.PositiveInfinity;
TriangleMeshNode result = null;
Vector3 vector = (startPos + endPos) / 2f;
float num2 = AstarMath.MagnitudeXZ(startPos, endPos) / 2f;
Vector3 vector2 = startPos;
stack.Push(triangleMeshNode);
list.Add(triangleMeshNode);
INavmesh navmesh = AstarData.GetGraph(triangleMeshNode) as INavmesh;
if (navmesh == null)
{
return(triangleMeshNode);
}
while (stack.Count > 0)
{
TriangleMeshNode triangleMeshNode2 = stack.Pop();
int tileIndex = ((RecastGraph)navmesh).GetTileIndex(triangleMeshNode2.GetVertexIndex(0));
Int3[] verts = ((RecastGraph)navmesh).GetTiles()[tileIndex].verts;
int vertexArrayIndex = triangleMeshNode2.GetVertexArrayIndex(triangleMeshNode2.v0);
int vertexArrayIndex2 = triangleMeshNode2.GetVertexArrayIndex(triangleMeshNode2.v1);
int vertexArrayIndex3 = triangleMeshNode2.GetVertexArrayIndex(triangleMeshNode2.v2);
if (NavMeshGraph.ContainsPoint(vertexArrayIndex, vertexArrayIndex2, vertexArrayIndex3, endPos, verts))
{
result = triangleMeshNode2;
vector2 = endPos;
break;
}
int i = 0;
int i2 = 2;
while (i < 3)
{
int vertexIndex = triangleMeshNode2.GetVertexIndex(i2);
int vertexIndex2 = triangleMeshNode2.GetVertexIndex(i);
bool flag = true;
TriangleMeshNode triangleMeshNode3 = null;
for (int j = 0; j < triangleMeshNode2.connections.Length; j++)
{
triangleMeshNode3 = (triangleMeshNode2.connections[j] as TriangleMeshNode);
if (triangleMeshNode3 != null)
{
int k = 0;
int i3 = 2;
while (k < 3)
{
int vertexIndex3 = triangleMeshNode3.GetVertexIndex(i3);
int vertexIndex4 = triangleMeshNode3.GetVertexIndex(k);
if ((vertexIndex3 == vertexIndex && vertexIndex4 == vertexIndex2) || (vertexIndex3 == vertexIndex2 && vertexIndex4 == vertexIndex))
{
flag = false;
break;
}
i3 = k++;
}
if (!flag)
{
break;
}
}
}
if (flag)
{
Vector3 vector3 = AstarMath.NearestPointStrictXZ((Vector3)verts[vertexIndex], (Vector3)verts[vertexIndex2], endPos);
float num3 = AstarMath.MagnitudeXZ(vector3, endPos);
if (num3 < num)
{
vector2 = vector3;
num = num3;
result = triangleMeshNode2;
}
}
else if (!list.Contains(triangleMeshNode3))
{
list.Add(triangleMeshNode3);
Vector3 vector3 = AstarMath.NearestPointStrictXZ((Vector3)verts[vertexIndex], (Vector3)verts[vertexIndex2], vector);
float num3 = AstarMath.MagnitudeXZ(vector3, vector);
if (num3 <= num2)
{
stack.Push(triangleMeshNode3);
}
}
i2 = i++;
}
}
clampedPos = vector2;
return(result);
}
private static void MoveFromNode(TriangleMeshNode node, int startEdge, VInt3 srcLoc, VInt3 destLoc, MoveDirectionState state, out VInt3 result)
{
result = srcLoc;
while (node != null)
{
int count = 2;
int i;
if (node.IsVertex(srcLoc, out i))
{
int vertexIndex = node.GetVertexIndex(i);
List <PathfindingUtility.TMNodeInfo> list = null;
PathfindingUtility.GetAllNodesByVert(ref list, node, vertexIndex);
TriangleMeshNode triangleMeshNode = null;
int num = -1;
for (int j = 0; j < list.get_Count(); j++)
{
PathfindingUtility.TMNodeInfo tMNodeInfo = list.get_Item(j);
if (!PathfindingUtility.checkedNodes.Contains(tMNodeInfo.node) && !Polygon.LeftNotColinear(tMNodeInfo.v0, tMNodeInfo.v2, destLoc) && Polygon.Left(tMNodeInfo.v0, tMNodeInfo.v1, destLoc))
{
triangleMeshNode = tMNodeInfo.node;
num = tMNodeInfo.vi;
break;
}
}
if (triangleMeshNode != null)
{
node = triangleMeshNode;
startEdge = (num + 1) % 3;
count = 1;
}
else
{
int edge = -1;
VFactor b = new VFactor
{
nom = -2L,
den = 1L
};
for (int k = 0; k < list.get_Count(); k++)
{
PathfindingUtility.TMNodeInfo tMNodeInfo2 = list.get_Item(k);
if (!PathfindingUtility.checkedNodes.Contains(tMNodeInfo2.node))
{
int num2;
VFactor cosineAngle = tMNodeInfo2.GetCosineAngle(destLoc, state, out num2);
if (cosineAngle > b)
{
b = cosineAngle;
edge = num2;
triangleMeshNode = tMNodeInfo2.node;
}
}
}
if (triangleMeshNode != null)
{
PathfindingUtility.MoveAlongEdge(triangleMeshNode, edge, srcLoc, destLoc, state, out result, true);
break;
}
}
}
int num3;
if (startEdge == -1)
{
num3 = node.EdgeIntersect(srcLoc, destLoc);
}
else
{
num3 = node.EdgeIntersect(srcLoc, destLoc, startEdge, count);
}
if (num3 == -1)
{
if (node.ContainsPoint(destLoc))
{
result = destLoc;
if (PathfindingUtility.MoveAxisY)
{
PathfindingUtility.CalculateY(ref result, node);
}
}
else
{
num3 = node.GetColinearEdge(srcLoc, destLoc);
if (num3 != -1)
{
PathfindingUtility.MoveAlongEdge(node, num3, srcLoc, destLoc, state, out result, true);
}
}
break;
}
int num4;
TriangleMeshNode neighborByEdge = node.GetNeighborByEdge(num3, out num4);
if (neighborByEdge == null)
{
PathfindingUtility.MoveAlongEdge(node, num3, srcLoc, destLoc, state, out result, true);
break;
}
node = neighborByEdge;
startEdge = num4 + 1;
}
}
// this is a utility function used by IsVisibleOnNavMeshOptimized, before calling this function is should be determined that the line 'from' -> 'to' starts outside
// the triangle, and enters the triangle, this function will then determine if the line exits the triangle
// the exitPoint returned will be on the ground plane
private static bool DoesLineExitTriangle(Vector3 from, Vector3 to, TriangleMeshNode currentTriangle, ref HashSet <TriangleMeshNode> previousTriangles, ref TriangleMeshNode nextTriangle, ref Vector3 exitPoint)
{
if (currentTriangle.ContainsPoint((Int3)to)) // does the line end in this triangle
{
return(false); // the line does not exit this triangle
}
const int NumVerts = 3;
if (null != currentTriangle.connections)
{
for (int connect = 0; connect < currentTriangle.connections.Length; connect++) // go through all our connections
{
TriangleMeshNode other = currentTriangle.connections[connect] as TriangleMeshNode;
int edge = -1;
int otherEdge = -1;
if (other != null && !previousTriangles.Contains(other) && SharedEdge(currentTriangle, other, ref edge, ref otherEdge)) // get the connecting edge
{
bool intersectsEdge = false;
bool intersectsOtherEdge = true;
// check to see if the line enters the other triangle through this edge
exitPoint = VectorMath.SegmentIntersectionPointXZ(from, to, (Vector3)currentTriangle.GetVertex(edge), (Vector3)currentTriangle.GetVertex((edge + 1) % NumVerts), out intersectsEdge);
int tileIndex = (currentTriangle.GetVertexIndex(0) >> RecastGraph.TileIndexOffset) & RecastGraph.TileIndexMask;
int otherTileIndex = (other.GetVertexIndex(0) >> RecastGraph.TileIndexOffset) & RecastGraph.TileIndexMask;
if (tileIndex != otherTileIndex) // if the edjoining triangles are on different tiles, the edges may not match exactly, so we need to be sure that both triangles edges are intersected
{
exitPoint = VectorMath.SegmentIntersectionPointXZ(from, to, (Vector3)other.GetVertex(otherEdge), (Vector3)other.GetVertex((otherEdge + 1) % NumVerts), out intersectsOtherEdge);
}
if (intersectsEdge && intersectsOtherEdge)
{
nextTriangle = other;
return(true);
}
}
}
}
Vector3 prevVertPos = (Vector3)currentTriangle.GetVertex(0);
float farthestIntersectionSqr = -1f;
for (int vert = 1; vert <= NumVerts; ++vert) // go over all the edges, to see which one the line passes out of, so we can calculate the triangle exit point
{
Vector3 vertPos = (Vector3)currentTriangle.GetVertex(vert % NumVerts);
bool intersects = false;
Vector3 potentialExitPoint = VectorMath.SegmentIntersectionPointXZ(from, to, prevVertPos, vertPos, out intersects);
if (intersects)
{
float intersectionSqr = (potentialExitPoint - from).sqrMagnitude;
// we're looking for the farthest intersection, as the nearest intersection would have been the edge intersected when the line entered the triangle
if (intersectionSqr > farthestIntersectionSqr)
{
farthestIntersectionSqr = intersectionSqr;
exitPoint = potentialExitPoint;
}
}
prevVertPos = vertPos;
}
return(farthestIntersectionSqr > 0f);
}
