public override MyHighLevelPrimitive GetHighLevelPrimitive(MyNavigationPrimitive myNavigationTriangle)
{
return(m_higherLevelHelper.GetHighLevelNavigationPrimitive(myNavigationTriangle as MyNavigationTriangle));
}
private float Criterion(MyNavigationPrimitive primitive)
{
return(m_destination.PointAdmissibility(primitive.WorldPosition, 2.0f)); // Triangles of large cube blocks will fit into 2m diam. circumsphere
}
private static float HlHeuristic(MyNavigationPrimitive primitive)
{
return((float)Vector3D.RectangularDistance(primitive.WorldPosition, m_pathfindingStatic.m_destinationCenter) * 2.0f);
}
public MyPath <MyNavigationPrimitive> FindPath(MyPathfinding pathfinding, MyNavigationPrimitive startPrimitive)
{
throw new NotImplementedException();
}
private float Heuristic(MyNavigationPrimitive primitive)
{
return((float)Vector3D.Distance(primitive.WorldPosition, m_destinationCenter));
}
private void RefineFoundPath(ref Vector3D begin, ref Vector3D end, MyPath <MyNavigationPrimitive> path)
{
Debug.Assert(MyFakes.ENABLE_PATHFINDING, "Pathfinding is not enabled!");
if (!MyFakes.ENABLE_PATHFINDING)
{
return;
}
if (path == null)
{
Debug.Assert(false, "Path to refine was null!");
return;
}
m_currentPrimitive = path[path.Count - 1].Vertex as MyNavigationPrimitive;
if (m_hlBegin != null && !m_pathNodes.Contains(m_hlBegin))
{
m_hlBegin.Parent.StopObservingPrimitive(m_hlBegin, this);
}
m_hlBegin = m_currentPrimitive.GetHighLevelPrimitive();
if (m_hlBegin != null && !m_pathNodes.Contains(m_hlBegin))
{
m_hlBegin.Parent.ObservePrimitive(m_hlBegin, this);
}
ProfilerShort.Begin("Path refining and post-processing");
IMyNavigationGroup prevGroup = null;
int groupStart = 0;
int groupEnd = 0;
Vector3 prevBegin = default(Vector3);
Vector3 prevEnd = default(Vector3);
for (int i = 0; i < path.Count; ++i)
{
var primitive = path[i].Vertex as MyNavigationPrimitive;
var group = primitive.Group;
if (prevGroup == null)
{
prevGroup = group;
prevBegin = prevGroup.GlobalToLocal(begin);
}
bool lastPrimitive = i == path.Count - 1;
if (group != prevGroup)
{
groupEnd = i - 1;
prevEnd = prevGroup.GlobalToLocal(primitive.WorldPosition);
}
else if (lastPrimitive)
{
groupEnd = i;
prevEnd = prevGroup.GlobalToLocal(end);
}
else
{
continue;
}
int refinedBegin = m_expandedPath.Count;
prevGroup.RefinePath(path, m_expandedPath, ref prevBegin, ref prevEnd, groupStart, groupEnd);
int refinedEnd = m_expandedPath.Count;
for (int j = refinedBegin; j < refinedEnd; ++j)
{
Vector3D position = new Vector3D(m_expandedPath[j]);
position = prevGroup.LocalToGlobal(position);
m_expandedPath[j] = new Vector4D(position, m_expandedPath[j].W);
}
if (lastPrimitive && group != prevGroup)
{
m_expandedPath.Add(new Vector4D(primitive.WorldPosition, m_expandedPath[refinedEnd - 1].W));
}
prevGroup = group;
groupStart = i;
if (m_expandedPath.Count != 0)
{
prevBegin = group.GlobalToLocal(new Vector3D(m_expandedPath[m_expandedPath.Count - 1]));
}
}
m_pathNodePosition++;
//m_expandedPath.RemoveAt(0);
m_expandedPathPosition = 0;
ProfilerShort.End();
}
private static bool ProcessTriangleForHierarchyStatic(MyNavigationPrimitive primitive)
{
MyNavigationTriangle triangle = primitive as MyNavigationTriangle;
return(m_currentHelper.ProcessTriangleForHierarchy(triangle));
}
bool IMyHighLevelComponent.Contains(MyNavigationPrimitive primitive)
{
MyNavigationTriangle triangle = primitive as MyNavigationTriangle;
return((triangle != null) ? (triangle.ComponentIndex == this.m_componentIndex) : false);
}
private void RefineFoundPath(ref Vector3D begin, ref Vector3D end, MyPath <MyNavigationPrimitive> path)
{
if (MyPerGameSettings.EnablePathfinding && (path != null))
{
this.m_currentPrimitive = path[path.Count - 1].Vertex as MyNavigationPrimitive;
if ((this.m_hlBegin != null) && !this.m_pathNodes.Contains(this.m_hlBegin))
{
this.m_hlBegin.Parent.StopObservingPrimitive(this.m_hlBegin, this);
}
this.m_hlBegin = this.m_currentPrimitive.GetHighLevelPrimitive();
if ((this.m_hlBegin != null) && !this.m_pathNodes.Contains(this.m_hlBegin))
{
this.m_hlBegin.Parent.ObservePrimitive(this.m_hlBegin, this);
}
IMyNavigationGroup objB = null;
int num = 0;
int num2 = 0;
Vector3 startPoint = new Vector3();
Vector3 endPoint = new Vector3();
int num3 = 0;
while (true)
{
while (true)
{
if (num3 >= path.Count)
{
this.m_pathNodePosition++;
this.m_expandedPathPosition = 0;
return;
}
MyNavigationPrimitive vertex = path[num3].Vertex as MyNavigationPrimitive;
IMyNavigationGroup group = vertex.Group;
if (objB == null)
{
objB = group;
startPoint = objB.GlobalToLocal(begin);
}
bool flag = num3 == (path.Count - 1);
if (!ReferenceEquals(group, objB))
{
num2 = num3 - 1;
endPoint = objB.GlobalToLocal(vertex.WorldPosition);
}
else
{
if (!flag)
{
break;
}
num2 = num3;
endPoint = objB.GlobalToLocal(end);
}
objB.RefinePath(path, this.m_expandedPath, ref startPoint, ref endPoint, num, num2);
int count = this.m_expandedPath.Count;
int num5 = this.m_expandedPath.Count;
while (true)
{
if (num5 >= count)
{
if (flag && !ReferenceEquals(group, objB))
{
this.m_expandedPath.Add(new Vector4D(vertex.WorldPosition, this.m_expandedPath[count - 1].W));
}
objB = group;
num = num3;
if (this.m_expandedPath.Count != 0)
{
startPoint = group.GlobalToLocal(new Vector3D(this.m_expandedPath[this.m_expandedPath.Count - 1]));
}
break;
}
Vector3D vectord = new Vector3D(this.m_expandedPath[num5]);
vectord = objB.LocalToGlobal((Vector3)vectord);
this.m_expandedPath[num5] = new Vector4D(vectord, this.m_expandedPath[num5].W);
num5++;
}
break;
}
num3++;
}
}
}
private void ExpandPath(Vector3D currentPosition)
{
if (this.m_pathNodePosition >= (this.m_pathNodes.Count - 1))
{
this.GenerateHighLevelPath();
}
if (this.m_pathNodePosition < this.m_pathNodes.Count)
{
MyPath <MyNavigationPrimitive> path = null;
bool flag = false;
this.m_expandedPath.Clear();
if ((this.m_pathNodePosition + 1) < this.m_pathNodes.Count)
{
if (this.m_pathNodes[this.m_pathNodePosition].IsExpanded && this.m_pathNodes[this.m_pathNodePosition + 1].IsExpanded)
{
IMyHighLevelComponent component = this.m_pathNodes[this.m_pathNodePosition].GetComponent();
IMyHighLevelComponent otherComponent = this.m_pathNodes[this.m_pathNodePosition + 1].GetComponent();
path = this.m_pathfinding.FindPath(this.m_currentPrimitive, this.m_goal.PathfindingHeuristic, prim => otherComponent.Contains(prim) ? 0f : float.PositiveInfinity, prim => component.Contains(prim) || otherComponent.Contains(prim), true);
}
}
else if (this.m_pathNodes[this.m_pathNodePosition].IsExpanded)
{
IMyHighLevelComponent component1 = this.m_pathNodes[this.m_pathNodePosition].GetComponent();
path = this.m_pathfinding.FindPath(this.m_currentPrimitive, this.m_goal.PathfindingHeuristic, prim => component1.Contains(prim) ? this.m_goal.TerminationCriterion(prim) : 30f, prim => component1.Contains(prim), true);
if (path != null)
{
if ((path.Count == 0) || !component1.Contains(path[path.Count - 1].Vertex as MyNavigationPrimitive))
{
this.m_goal.IgnoreHighLevel(this.m_pathNodes[this.m_pathNodePosition]);
}
else
{
flag = true;
}
}
}
if ((path != null) && (path.Count != 0))
{
Vector3D end = new Vector3D();
MyNavigationPrimitive vertex = path[path.Count - 1].Vertex as MyNavigationPrimitive;
if (!flag)
{
end = vertex.WorldPosition;
}
else
{
Vector3 bestPoint = (Vector3)this.m_goal.Destination.GetBestPoint(vertex.WorldPosition);
Vector3 localPos = vertex.ProjectLocalPoint(vertex.Group.GlobalToLocal(bestPoint));
end = vertex.Group.LocalToGlobal(localPos);
}
this.RefineFoundPath(ref currentPosition, ref end, path);
if ((((this.m_pathNodes.Count <= 1) & flag) && ((this.m_expandedPath.Count > 0) && (path.Count <= 2))) && !this.m_goal.ShouldReinitPath())
{
Vector4D vectord2 = this.m_expandedPath[this.m_expandedPath.Count - 1];
if (Vector3D.DistanceSquared(currentPosition, end) < ((vectord2.W * vectord2.W) / 256.0))
{
this.m_expandedPath.Clear();
}
}
}
}
}