|
public static NearestPointFactor ( |
||
| lineStart | ||
| lineEnd | ||
| point | ||
| Résultat | float | |
public override Vector3 ClosestPointOnNodeXZ(Vector3 _p)
{
INavmeshHolder navmeshHolder = TriangleMeshNode.GetNavmeshHolder(base.GraphIndex);
Int3 vertex = navmeshHolder.GetVertex(this.v0);
Int3 vertex2 = navmeshHolder.GetVertex(this.v1);
Int3 vertex3 = navmeshHolder.GetVertex(this.v2);
Int3 point = (Int3)_p;
int y = point.y;
vertex.y = 0;
vertex2.y = 0;
vertex3.y = 0;
point.y = 0;
if ((long)(vertex2.x - vertex.x) * (long)(point.z - vertex.z) - (long)(point.x - vertex.x) * (long)(vertex2.z - vertex.z) > 0L)
{
float num = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex, vertex2, point));
return(new Vector3((float)vertex.x + (float)(vertex2.x - vertex.x) * num, (float)y, (float)vertex.z + (float)(vertex2.z - vertex.z) * num) * 0.001f);
}
if ((long)(vertex3.x - vertex2.x) * (long)(point.z - vertex2.z) - (long)(point.x - vertex2.x) * (long)(vertex3.z - vertex2.z) > 0L)
{
float num2 = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex2, vertex3, point));
return(new Vector3((float)vertex2.x + (float)(vertex3.x - vertex2.x) * num2, (float)y, (float)vertex2.z + (float)(vertex3.z - vertex2.z) * num2) * 0.001f);
}
if ((long)(vertex.x - vertex3.x) * (long)(point.z - vertex3.z) - (long)(point.x - vertex3.x) * (long)(vertex.z - vertex3.z) > 0L)
{
float num3 = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex3, vertex, point));
return(new Vector3((float)vertex3.x + (float)(vertex.x - vertex3.x) * num3, (float)y, (float)vertex3.z + (float)(vertex.z - vertex3.z) * num3) * 0.001f);
}
return(_p);
}
public override Vector3 ClosestPointOnNodeXZ(Vector3 _p)
{
// Get the object holding the vertex data for this node
// This is usually a graph or a recast graph tile
INavmeshHolder g = GetNavmeshHolder(GraphIndex);
// Get all 3 vertices for this node
Int3 tp1 = g.GetVertex(v0);
Int3 tp2 = g.GetVertex(v1);
Int3 tp3 = g.GetVertex(v2);
// We need the point as an Int3
Int3 p = (Int3)_p;
// Save the original y coordinate, we will return a point with the same y coordinate
int oy = p.y;
// Assumes the triangle vertices are laid out in (counter?)clockwise order
tp1.y = 0;
tp2.y = 0;
tp3.y = 0;
p.y = 0;
if ((long)(tp2.x - tp1.x) * (long)(p.z - tp1.z) - (long)(p.x - tp1.x) * (long)(tp2.z - tp1.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp1, tp2, p));
return(new Vector3(tp1.x + (tp2.x - tp1.x) * f, oy, tp1.z + (tp2.z - tp1.z) * f) * Int3.PrecisionFactor);
}
else if ((long)(tp3.x - tp2.x) * (long)(p.z - tp2.z) - (long)(p.x - tp2.x) * (long)(tp3.z - tp2.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp2, tp3, p));
return(new Vector3(tp2.x + (tp3.x - tp2.x) * f, oy, tp2.z + (tp3.z - tp2.z) * f) * Int3.PrecisionFactor);
}
else if ((long)(tp1.x - tp3.x) * (long)(p.z - tp3.z) - (long)(p.x - tp3.x) * (long)(tp1.z - tp3.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp3, tp1, p));
return(new Vector3(tp3.x + (tp1.x - tp3.x) * f, oy, tp3.z + (tp1.z - tp3.z) * f) * Int3.PrecisionFactor);
}
else
{
return(_p);
}
/*
* Equivalent to the above, but the above uses manual inlining
* if (!Polygon.Left (tp1, tp2, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp1, tp2, p));
* return new Vector3(tp1.x + (tp2.x-tp1.x)*f, oy, tp1.z + (tp2.z-tp1.z)*f)*Int3.PrecisionFactor;
* } else if (!Polygon.Left (tp2, tp3, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp2, tp3, p));
* return new Vector3(tp2.x + (tp3.x-tp2.x)*f, oy, tp2.z + (tp3.z-tp2.z)*f)*Int3.PrecisionFactor;
* } else if (!Polygon.Left (tp3, tp1, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp3, tp1, p));
* return new Vector3(tp3.x + (tp1.x-tp3.x)*f, oy, tp3.z + (tp1.z-tp3.z)*f)*Int3.PrecisionFactor;
* } else {
* return _p;
* }*/
/* Almost equivalent to the above, but this is slower
* Vector3 tp1 = (Vector3)g.GetVertex(v0);
* Vector3 tp2 = (Vector3)g.GetVertex(v1);
* Vector3 tp3 = (Vector3)g.GetVertex(v2);
* tp1.y = 0;
* tp2.y = 0;
* tp3.y = 0;
* _p.y = 0;
* return Pathfinding.Polygon.ClosestPointOnTriangle (tp1,tp2,tp3,_p);*/
}
public override Vector3 ClosestPointOnNodeXZ(Vector3 _p)
{
INavmeshHolder g = GetNavmeshHolder(GraphIndex);
Int3 tp1 = g.GetVertex(v0);
Int3 tp2 = g.GetVertex(v1);
Int3 tp3 = g.GetVertex(v2);
Int3 p = (Int3)_p;
int oy = p.y;
// Assumes the triangle vertices are laid out in (counter?)clockwise order
tp1.y = 0;
tp2.y = 0;
tp3.y = 0;
p.y = 0;
if ((long)(tp2.x - tp1.x) * (long)(p.z - tp1.z) - (long)(p.x - tp1.x) * (long)(tp2.z - tp1.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp1, tp2, p));
return(new Vector3(tp1.x + (tp2.x - tp1.x) * f, oy, tp1.z + (tp2.z - tp1.z) * f) * Int3.PrecisionFactor);
}
else if ((long)(tp3.x - tp2.x) * (long)(p.z - tp2.z) - (long)(p.x - tp2.x) * (long)(tp3.z - tp2.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp2, tp3, p));
return(new Vector3(tp2.x + (tp3.x - tp2.x) * f, oy, tp2.z + (tp3.z - tp2.z) * f) * Int3.PrecisionFactor);
}
else if ((long)(tp1.x - tp3.x) * (long)(p.z - tp3.z) - (long)(p.x - tp3.x) * (long)(tp1.z - tp3.z) > 0)
{
float f = Mathf.Clamp01(AstarMath.NearestPointFactor(tp3, tp1, p));
return(new Vector3(tp3.x + (tp1.x - tp3.x) * f, oy, tp3.z + (tp1.z - tp3.z) * f) * Int3.PrecisionFactor);
}
else
{
return(_p);
}
/*
* Equivalent to the above, but the above uses manual inlining
* if (!Polygon.Left (tp1, tp2, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp1, tp2, p));
* return new Vector3(tp1.x + (tp2.x-tp1.x)*f, oy, tp1.z + (tp2.z-tp1.z)*f)*Int3.PrecisionFactor;
* } else if (!Polygon.Left (tp2, tp3, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp2, tp3, p));
* return new Vector3(tp2.x + (tp3.x-tp2.x)*f, oy, tp2.z + (tp3.z-tp2.z)*f)*Int3.PrecisionFactor;
* } else if (!Polygon.Left (tp3, tp1, p)) {
* float f = Mathf.Clamp01 (AstarMath.NearestPointFactor (tp3, tp1, p));
* return new Vector3(tp3.x + (tp1.x-tp3.x)*f, oy, tp3.z + (tp1.z-tp3.z)*f)*Int3.PrecisionFactor;
* } else {
* return _p;
* }*/
/* Almost equivalent to the above, but this is slower
* Vector3 tp1 = (Vector3)g.GetVertex(v0);
* Vector3 tp2 = (Vector3)g.GetVertex(v1);
* Vector3 tp3 = (Vector3)g.GetVertex(v2);
* tp1.y = 0;
* tp2.y = 0;
* tp3.y = 0;
* _p.y = 0;
* return Pathfinding.Polygon.ClosestPointOnTriangle (tp1,tp2,tp3,_p);*/
}
public bool FinalInts(Vector3 target, Vector3 closeEdgeConstraint, bool drawGizmos, out Vector3 closest)
{
ints1.Sort();
ints2.Sort();
ints3.Sort();
float a = (float)Math.Atan2(direction.z, direction.x);
Vector3 cross = Vector3.Cross(direction, Vector3.up);
Vector3 p1 = cross * (float)Math.Tan(angle) * limit;
Vector3 pLeft = origin + direction * limit + p1;
Vector3 pRight = origin + direction * limit - p1;
Vector3 pLeft2 = pLeft + new Vector3((float)Math.Cos(a + angle), 0, (float)Math.Sin(a + angle)) * 100;
Vector3 pRight2 = pRight + new Vector3((float)Math.Cos(a - angle), 0, (float)Math.Sin(a - angle)) * 100;
bool anyCloseFound = false;
closest = Vector3.zero;
int IgnoreDirection = Vector3.Dot(closeEdgeConstraint - origin, cross) > 0 ? 2 : 1; //(pRight-(transform.position+velocity)).sqrMagnitude < (pLeft-(transform.position+velocity)).sqrMagnitude ? 2 : 1;//Vector3.Dot (pRight-pLeft,target-pLeft) > 0 ? 1 : 2;
for (int j = 1; j <= 3; j++)
{
if (j == IgnoreDirection)
{
continue;
}
List <IntersectionPair> ints = j == 1 ? ints1 : (j == 2 ? ints2 : ints3);
/*IntersectionState prevInside = ints[0].state;
* if (ints[0].state == IntersectionState.Outside) {
* ints[0].SetState (IntersectionState.Exit);
* }*/
/*for (int i=1;i<ints.Count;i++) {
* Debug.Log ("Intersection at "+j+", "+i+" : "+ints[i].factor);
* prevInside = ints[i].state;
* if (prevInside == IntersectionState.Outside) {
* ints[i].SetState (IntersectionState.Enter);
* } else if (prevInside == IntersectionState.Inside) {
* ints[i].SetState (ints[i].state == IntersectionState.Inside ? IntersectionState.Inside : IntersectionState.Exit);
* }
* }
* if (ints[ints.Count-1].state == IntersectionState.Exit) {
* ints.Add (new IntersectionPair (1,false));
* }*/
Vector3 start = (j == 1 || j == 3 ? pLeft : pRight);
Vector3 end = (j == 1 ? pLeft2 : (j == 2 ? pRight2 : pRight));
float closestFactor = AstarMath.NearestPointFactor(start, end, target);
float closeMin = float.PositiveInfinity;
float closeMax = float.NegativeInfinity;
bool anySegmClose = false;
for (int i = 0; i < ints.Count - (j == 3 ? 1 : 0); i++)
{
if (drawGizmos)
{
Debug.DrawRay(start + (end - start) * ints[i].factor, Vector3.down, ints[i].state == IntersectionState.Outside ? Color.green : Color.red);
}
if (ints[i].state == IntersectionState.Outside && ((i == ints.Count - 1 && (i == 0 || ints[i - 1].state != IntersectionState.Outside)) || (i < ints.Count - 1 && ints[i + 1].state == IntersectionState.Outside)))
{
anySegmClose = true;
float startFactor = ints[i].factor;
float endFactor = i == ints.Count - 1 ? (j == 3 ? 1 : float.PositiveInfinity) : ints[i + 1].factor;
if (drawGizmos)
{
Debug.DrawLine(start + (end - start) * startFactor + Vector3.up, start + (end - start) * Mathf.Clamp01(endFactor) + Vector3.up, Color.green);
}
if (startFactor <= closestFactor && endFactor >= closestFactor)
{
closeMin = closestFactor;
closeMax = closestFactor;
break;
}
else if (endFactor < closestFactor && endFactor > closeMax)
{
closeMax = endFactor;
}
else if (startFactor > closestFactor && startFactor < closeMin)
{
closeMin = startFactor;
}
}
}
if (anySegmClose)
{
//The closest factor
float closeV = closeMin == float.NegativeInfinity ? closeMax : (closeMax == float.PositiveInfinity ? closeMin : (Mathf.Abs(closestFactor - closeMin) < Mathf.Abs(closestFactor - closeMax) ? closeMin : closeMax));
/*if (Mathf.Abs(closestFactor-closeMin) < Mathf.Abs(closestFactor-closeMax)) {
* segmClose = start+ (end-start)*closeMin;
* } else {
* segmClose = start+ (end-start)*closeMax;
* }*/
Vector3 segmClose = start + (end - start) * closeV;
if (!anyCloseFound || (segmClose - target).sqrMagnitude < (closest - target).sqrMagnitude)
{
closest = segmClose;
}
if (drawGizmos)
{
Debug.DrawLine(target, closest, Color.yellow);
}
anyCloseFound = true;
}
}
return(anyCloseFound);
}
public bool FinalInts(Vector3 target, Vector3 closeEdgeConstraint, bool drawGizmos, out Vector3 closest)
{
this.ints1.Sort();
this.ints2.Sort();
this.ints3.Sort();
float num = (float)Math.Atan2((double)this.direction.z, (double)this.direction.x);
Vector3 vector = Vector3.Cross(this.direction, Vector3.up);
Vector3 b = vector * (float)Math.Tan((double)this.angle) * this.limit;
Vector3 vector2 = this.origin + this.direction * this.limit + b;
Vector3 vector3 = this.origin + this.direction * this.limit - b;
Vector3 vector4 = vector2 + new Vector3((float)Math.Cos((double)(num + this.angle)), 0f, (float)Math.Sin((double)(num + this.angle))) * 100f;
Vector3 vector5 = vector3 + new Vector3((float)Math.Cos((double)(num - this.angle)), 0f, (float)Math.Sin((double)(num - this.angle))) * 100f;
bool flag = false;
closest = Vector3.zero;
int num2 = (Vector3.Dot(closeEdgeConstraint - this.origin, vector) <= 0f) ? 1 : 2;
for (int i = 1; i <= 3; i++)
{
if (i != num2)
{
List <LocalAvoidance.IntersectionPair> list = (i != 1) ? ((i != 2) ? this.ints3 : this.ints2) : this.ints1;
Vector3 vector6 = (i != 1 && i != 3) ? vector3 : vector2;
Vector3 vector7 = (i != 1) ? ((i != 2) ? vector3 : vector5) : vector4;
float num3 = AstarMath.NearestPointFactor(vector6, vector7, target);
float num4 = float.PositiveInfinity;
float num5 = float.NegativeInfinity;
bool flag2 = false;
for (int j = 0; j < list.Count - ((i != 3) ? 0 : 1); j++)
{
if (drawGizmos)
{
Debug.DrawRay(vector6 + (vector7 - vector6) * list[j].factor, Vector3.down, (list[j].state != LocalAvoidance.IntersectionState.Outside) ? Color.red : Color.green);
}
if (list[j].state == LocalAvoidance.IntersectionState.Outside && ((j == list.Count - 1 && (j == 0 || list[j - 1].state != LocalAvoidance.IntersectionState.Outside)) || (j < list.Count - 1 && list[j + 1].state == LocalAvoidance.IntersectionState.Outside)))
{
flag2 = true;
float factor = list[j].factor;
float num6 = (j != list.Count - 1) ? list[j + 1].factor : ((i != 3) ? float.PositiveInfinity : 1f);
if (drawGizmos)
{
Debug.DrawLine(vector6 + (vector7 - vector6) * factor + Vector3.up, vector6 + (vector7 - vector6) * Mathf.Clamp01(num6) + Vector3.up, Color.green);
}
if (factor <= num3 && num6 >= num3)
{
num4 = num3;
num5 = num3;
break;
}
if (num6 < num3 && num6 > num5)
{
num5 = num6;
}
else if (factor > num3 && factor < num4)
{
num4 = factor;
}
}
}
if (flag2)
{
float d = (num4 != float.NegativeInfinity) ? ((num5 != float.PositiveInfinity) ? ((Mathf.Abs(num3 - num4) >= Mathf.Abs(num3 - num5)) ? num5 : num4) : num4) : num5;
Vector3 vector8 = vector6 + (vector7 - vector6) * d;
if (!flag || (vector8 - target).sqrMagnitude < (closest - target).sqrMagnitude)
{
closest = vector8;
}
if (drawGizmos)
{
Debug.DrawLine(target, closest, Color.yellow);
}
flag = true;
}
}
}
return(flag);
}
public void Apply(bool forceNewCheck)
{
//TODO
//This function assumes that connections from the n1,n2 nodes never need to be removed in the future (e.g because the nodes move or something)
NNConstraint nn = NNConstraint.None;
nn.distanceXZ = true;
int graph = (int)startNode.GraphIndex;
//Search all graphs but the one which start and end nodes are on
nn.graphMask = ~(1 << graph);
bool same = true;
if (true)
{
NNInfo n1 = AstarPath.active.GetNearest(StartTransform.position, nn);
same &= n1.node == connectedNode1 && n1.node != null;
connectedNode1 = n1.node as MeshNode;
clamped1 = n1.clampedPosition;
if (connectedNode1 != null)
{
Debug.DrawRay((Vector3)connectedNode1.position, Vector3.up * 5, Color.red);
}
}
if (true)
{
NNInfo n2 = AstarPath.active.GetNearest(EndTransform.position, nn);
same &= n2.node == connectedNode2 && n2.node != null;
connectedNode2 = n2.node as MeshNode;
clamped2 = n2.clampedPosition;
if (connectedNode2 != null)
{
Debug.DrawRay((Vector3)connectedNode2.position, Vector3.up * 5, Color.cyan);
}
}
if (connectedNode2 == null || connectedNode1 == null)
{
return;
}
startNode.SetPosition((Int3)StartTransform.position);
endNode.SetPosition((Int3)EndTransform.position);
if (same && !forceNewCheck)
{
return;
}
RemoveConnections(startNode);
RemoveConnections(endNode);
uint cost = (uint)Mathf.RoundToInt(((Int3)(StartTransform.position - EndTransform.position)).costMagnitude * costFactor);
startNode.AddConnection(endNode, cost);
endNode.AddConnection(startNode, cost);
Int3 dir = connectedNode2.position - connectedNode1.position;
for (int a = 0; a < connectedNode1.GetVertexCount(); a++)
{
Int3 va1 = connectedNode1.GetVertex(a);
Int3 va2 = connectedNode1.GetVertex((a + 1) % connectedNode1.GetVertexCount());
if (Int3.DotLong((va2 - va1).Normal2D(), dir) > 0)
{
continue;
}
for (int b = 0; b < connectedNode2.GetVertexCount(); b++)
{
Int3 vb1 = connectedNode2.GetVertex(b);
Int3 vb2 = connectedNode2.GetVertex((b + 1) % connectedNode2.GetVertexCount());
if (Int3.DotLong((vb2 - vb1).Normal2D(), dir) < 0)
{
continue;
}
//Debug.DrawLine ((Vector3)va1, (Vector3)va2, Color.magenta);
//Debug.DrawLine ((Vector3)vb1, (Vector3)vb2, Color.cyan);
//Debug.Break ();
if (Int3.Angle((vb2 - vb1), (va2 - va1)) > (170.0 / 360.0f) * Mathf.PI * 2)
{
float t1 = 0;
float t2 = 1;
t2 = System.Math.Min(t2, AstarMath.NearestPointFactor(va1, va2, vb1));
t1 = System.Math.Max(t1, AstarMath.NearestPointFactor(va1, va2, vb2));
if (t2 < t1)
{
Debug.LogError("Wait wut!? " + t1 + " " + t2 + " " + va1 + " " + va2 + " " + vb1 + " " + vb2 + "\nTODO, fix this error");
}
else
{
Vector3 pa = (Vector3)(va2 - va1) * t1 + (Vector3)va1;
Vector3 pb = (Vector3)(va2 - va1) * t2 + (Vector3)va1;
startNode.portalA = pa;
startNode.portalB = pb;
endNode.portalA = pb;
endNode.portalB = pa;
//Add connections between nodes, or replace old connections if existing
connectedNode1.AddConnection(startNode, (uint)Mathf.RoundToInt(((Int3)(clamped1 - StartTransform.position)).costMagnitude * costFactor));
connectedNode2.AddConnection(endNode, (uint)Mathf.RoundToInt(((Int3)(clamped2 - EndTransform.position)).costMagnitude * costFactor));
startNode.AddConnection(connectedNode1, (uint)Mathf.RoundToInt(((Int3)(clamped1 - StartTransform.position)).costMagnitude * costFactor));
endNode.AddConnection(connectedNode2, (uint)Mathf.RoundToInt(((Int3)(clamped2 - EndTransform.position)).costMagnitude * costFactor));
return;
}
}
}
}
}
// Token: 0x060001D7 RID: 471 RVA: 0x00012314 File Offset: 0x00010714
public void Apply(bool forceNewCheck)
{
NNConstraint none = NNConstraint.None;
none.distanceXZ = true;
int graphIndex = (int)this.startNode.GraphIndex;
none.graphMask = ~(1 << graphIndex);
bool flag = true;
NNInfo nearest = AstarPath.active.GetNearest(this.StartTransform.position, none);
flag &= (nearest.node == this.connectedNode1 && nearest.node != null);
this.connectedNode1 = (nearest.node as MeshNode);
this.clamped1 = nearest.clampedPosition;
if (this.connectedNode1 != null)
{
Debug.DrawRay((Vector3)this.connectedNode1.position, Vector3.up * 5f, Color.red);
}
NNInfo nearest2 = AstarPath.active.GetNearest(this.EndTransform.position, none);
flag &= (nearest2.node == this.connectedNode2 && nearest2.node != null);
this.connectedNode2 = (nearest2.node as MeshNode);
this.clamped2 = nearest2.clampedPosition;
if (this.connectedNode2 != null)
{
Debug.DrawRay((Vector3)this.connectedNode2.position, Vector3.up * 5f, Color.cyan);
}
if (this.connectedNode2 == null || this.connectedNode1 == null)
{
return;
}
this.startNode.SetPosition((Int3)this.StartTransform.position);
this.endNode.SetPosition((Int3)this.EndTransform.position);
if (flag && !forceNewCheck)
{
return;
}
this.RemoveConnections(this.startNode);
this.RemoveConnections(this.endNode);
uint cost = (uint)Mathf.RoundToInt((float)((Int3)(this.StartTransform.position - this.EndTransform.position)).costMagnitude * this.costFactor);
this.startNode.AddConnection(this.endNode, cost);
this.endNode.AddConnection(this.startNode, cost);
Int3 rhs = this.connectedNode2.position - this.connectedNode1.position;
for (int i = 0; i < this.connectedNode1.GetVertexCount(); i++)
{
Int3 vertex = this.connectedNode1.GetVertex(i);
Int3 vertex2 = this.connectedNode1.GetVertex((i + 1) % this.connectedNode1.GetVertexCount());
if (Int3.DotLong((vertex2 - vertex).Normal2D(), rhs) <= 0L)
{
for (int j = 0; j < this.connectedNode2.GetVertexCount(); j++)
{
Int3 vertex3 = this.connectedNode2.GetVertex(j);
Int3 vertex4 = this.connectedNode2.GetVertex((j + 1) % this.connectedNode2.GetVertexCount());
if (Int3.DotLong((vertex4 - vertex3).Normal2D(), rhs) >= 0L)
{
if ((double)Int3.Angle(vertex4 - vertex3, vertex2 - vertex) > 2.9670598109563189)
{
float num = 0f;
float num2 = 1f;
num2 = Math.Min(num2, AstarMath.NearestPointFactor(vertex, vertex2, vertex3));
num = Math.Max(num, AstarMath.NearestPointFactor(vertex, vertex2, vertex4));
if (num2 >= num)
{
Vector3 vector = (Vector3)(vertex2 - vertex) * num + (Vector3)vertex;
Vector3 vector2 = (Vector3)(vertex2 - vertex) * num2 + (Vector3)vertex;
this.startNode.portalA = vector;
this.startNode.portalB = vector2;
this.endNode.portalA = vector2;
this.endNode.portalB = vector;
this.connectedNode1.AddConnection(this.startNode, (uint)Mathf.RoundToInt((float)((Int3)(this.clamped1 - this.StartTransform.position)).costMagnitude * this.costFactor));
this.connectedNode2.AddConnection(this.endNode, (uint)Mathf.RoundToInt((float)((Int3)(this.clamped2 - this.EndTransform.position)).costMagnitude * this.costFactor));
this.startNode.AddConnection(this.connectedNode1, (uint)Mathf.RoundToInt((float)((Int3)(this.clamped1 - this.StartTransform.position)).costMagnitude * this.costFactor));
this.endNode.AddConnection(this.connectedNode2, (uint)Mathf.RoundToInt((float)((Int3)(this.clamped2 - this.EndTransform.position)).costMagnitude * this.costFactor));
return;
}
Debug.LogError(string.Concat(new object[]
{
"Wait wut!? ",
num,
" ",
num2,
" ",
vertex,
" ",
vertex2,
" ",
vertex3,
" ",
vertex4,
"\nTODO, fix this error"
}));
}
}
}
}
}
}