public override void Create()
{
Graph = new SparseGraph(false);
for (int i = 0; i < World.Instance.Waypoints.Count; i++)
{
var node = new Node(i) { Position = new Vector2(World.Instance.Waypoints[i].x, World.Instance.Waypoints[i].z) };
Graph.AddNode(node);
//AddNodeObject(node, node.Position);
}
for (int fromIndex = 0; fromIndex < Graph.NumNodes; fromIndex++)
{
Node fromNode = Graph.GetNode(fromIndex);
for (int toIndex = 0; toIndex < Graph.NumNodes; toIndex++)
{
Node toNode = Graph.GetNode(toIndex);
if (IsPathObstructed(fromNode.Position, toNode.Position))
{
continue;
}
var edge =
new Edge(
fromIndex,
toIndex,
(fromNode.Position - toNode.Position).magnitude);
Graph.AddEdge(edge);
//AddEdgeObject(edge, fromNode.Position, toNode.Position);
}
}
}
public double Calculate(SparseGraph <UnityNode, UnityEdge> Graph, int Node1, int Node2)
{
var UnityNode1 = Graph.GetNode(Node1);
var UnityNode2 = Graph.GetNode(Node2);
var Pos1 = UnityNode1.Position;
var Pos2 = UnityNode2.Position;
return(Vector3.Distance(Pos1, Pos2));
}
/// </summary>
public int SearchNonAlloc(Vector3 srcPos, Vector3 destPos, ref Stack <Vector3> pathPos)
{
NavGraphNode destNode = _graph.FindNearNode(destPos);
NavGraphNode srcNode = _graph.FindNearNode(srcPos);
NavGraphNode tempNode = null;
if (null == pathPos)
{
return(0);
}
if (true == this.PossibleLinearMove(srcPos, destPos, GlobalConstants.Layer.Mask.building))
{
if (null != pathPos)
{
pathPos.Clear();
pathPos.Push(destPos);
}
return(1);
}
_searchDFS.Init(_graph, srcNode.Index(), destNode.Index());
List <int> pathList = _searchDFS.GetPathToTarget();
//-------- chamto test --------
// string nodeChaine = "nodeChaine : ";
// foreach (int node in pathList)
// {
// nodeChaine += node + "<-";
// }
// Debug.Log (nodeChaine);
//-------- ------------ --------
pathPos.Clear();
pathPos.Push(destPos);
foreach (int node in pathList)
{
tempNode = _graph.GetNode(node) as NavGraphNode;
pathPos.Push(tempNode.Pos());
}
//pathPos.Push (srcPos);
return(pathPos.Count);
}
void Start()
{
GraphNodePrefabsRoot = transform.GetChild(0);
foreach (var Node in Graph.Nodes)
{
UnityNode GraphNode = (UnityNode)Graph.GetNode(Node.NodeIndex);
Vector3 NodePosition = new Vector3(transform.position.x + Node.Position.x, transform.position.y + Node.Position.y + 0.02f, transform.position.z + Node.Position.z);
if (Node.NodeIndex != (int)ENodeType.InvalidNodeIndex)
{
// Vector3 CubeSize = new Vector3(TileWidth * (1 - TilePadding), .01f, TileHeight * (1 - TilePadding));
Node.GraphNodePrefab = Instantiate(WalkableNodePrefab, NodePosition, Quaternion.identity, GraphNodePrefabsRoot);
// Node.GraphNodePrefab.GetComponent<VisualUnityNode>().UnityNode = Node;
}
else
{
// Node.GraphNodePrefab.GetComponent<GraphNode>().NodeIndex = (int)ENodeType.InvalidNodeIndex;
Node.GraphNodePrefab = Instantiate(UnWalkableNodePrefab, NodePosition, Quaternion.identity, GraphNodePrefabsRoot);
}
}
}
public override void Create()
{
Graph = new SparseGraph(false);
for (int i = 0; i < World.Instance.Waypoints.Count; i++)
{
var node = new Node(i)
{
Position = new Vector2(World.Instance.Waypoints[i].x, World.Instance.Waypoints[i].z)
};
Graph.AddNode(node);
//AddNodeObject(node, node.Position);
}
for (int fromIndex = 0; fromIndex < Graph.NumNodes; fromIndex++)
{
Node fromNode = Graph.GetNode(fromIndex);
for (int toIndex = 0; toIndex < Graph.NumNodes; toIndex++)
{
Node toNode = Graph.GetNode(toIndex);
if (IsPathObstructed(fromNode.Position, toNode.Position))
{
continue;
}
var edge =
new Edge(
fromIndex,
toIndex,
(fromNode.Position - toNode.Position).magnitude);
Graph.AddEdge(edge);
//AddEdgeObject(edge, fromNode.Position, toNode.Position);
}
}
}
public NavGraphNode GetNode(int nodeIndex)
{
return(m_sparseGraph.GetNode(nodeIndex));
}
public override void Create()
{
Graph = new SparseGraph(false);
for (int row = 0; row < rows; row++)
{
for (int column = 0; column < columns; column++)
{
var nodePosition =
new Vector2(
column * cellWidth - cellWidth * (columns - 1) / 2,
row * cellHeight - cellHeight * (rows - 1) / 2);
var node = new Node(row * columns + column) { Position = nodePosition };
int nodeIndex = Graph.AddNode(node);
if (IsPointInObstacle(nodePosition))
{
Graph.GetNode(nodeIndex).Index = Node.INVALID_NODE_INDEX;
}
else
{
//AddNodeObject(node, nodePosition);
}
}
}
for (int nodeIndex = 0; nodeIndex < Graph.NumNodes; nodeIndex++)
{
if (!Graph.IsNodePresent(nodeIndex))
{
continue;
}
Node node = Graph.GetNode(nodeIndex);
int rightIndex = nodeIndex + 1;
if (rightIndex % columns != 0 && Graph.IsNodePresent(rightIndex))
{
Node rightNode = Graph.GetNode(rightIndex);
if (!IsPathObstructed(node.Position, rightNode.Position))
{
var rightEdge = new Edge(nodeIndex, rightIndex, cellWidth);
Graph.AddEdge(rightEdge);
//AddEdgeObject(rightEdge, node.Position, rightNode.Position);
}
}
int downIndex = nodeIndex + columns;
if (downIndex < Graph.NumNodes && Graph.IsNodePresent(downIndex))
{
Node downNode = Graph.GetNode(downIndex);
if (!IsPathObstructed(node.Position, downNode.Position))
{
var downEdge = new Edge(nodeIndex, downIndex, cellHeight);
Graph.AddEdge(downEdge);
//AddEdgeObject(downEdge, node.Position, downNode.Position);
}
}
if (!useDiagonals)
{
continue;
}
int diagIndex = nodeIndex + columns + 1;
if (diagIndex < Graph.NumNodes && diagIndex % columns != 0 &&
Graph.IsNodePresent(diagIndex))
{
Node diagNode = Graph.GetNode(diagIndex);
if (!IsPathObstructed(node.Position, diagNode.Position))
{
var diagEdge = new Edge(nodeIndex, diagIndex, cellDiagonal);
Graph.AddEdge(diagEdge);
//AddEdgeObject(diagEdge, node.Position, diagNode.Position);
}
}
int backDiagIndex = nodeIndex + columns - 1;
if (backDiagIndex < Graph.NumNodes && backDiagIndex % columns != columns - 1 &&
Graph.IsNodePresent(backDiagIndex))
{
Node backDiagNode = Graph.GetNode(backDiagIndex);
if (!IsPathObstructed(node.Position, backDiagNode.Position))
{
var backDiagEdge = new Edge(nodeIndex, backDiagIndex, cellDiagonal);
Graph.AddEdge(backDiagEdge);
//AddEdgeObject(backDiagEdge, node.Position, backDiagNode.Position);
}
}
}
}
//this uses the euclidian distance but adds in an amount of noise to the
//result. You can use this heuristic to provide imperfect paths. This can
//be handy if you find that you frequently have lots of agents all following
//each other in single file to get from one place to another
public static double NoisyEuclidianDistance(SparseGraph G, int nd1, int nd2)
{
return Vector2D.Vec2DDistance(G.GetNode(nd1).Pos, G.GetNode(nd2).Pos) * Utils.RandInRange(0.9f, 1.1f);
}
//calculate the straight line distance from node nd1 to node nd2
public static double EuclidianDistance(SparseGraph G, int nd1, int nd2)
{
return Vector2D.Vec2DDistance(G.GetNode(nd1).Pos, G.GetNode(nd2).Pos);
}
///<summary>
///calculate the straight line distance from node nd1 to node nd2
///</summary>
///<param name="graph"></param>
///<param name="nd1"></param>
///<param name="nd2"></param>
///<returns></returns>
public static float Calculate(SparseGraph graph, int nd1, int nd2)
{
return (graph.GetNode(nd1).Position - graph.GetNode(nd2).Position).Length();
}
//this uses the euclidian distance but adds in an amount of noise to the
//result. You can use this heuristic to provide imperfect paths. This can
//be handy if you find that you frequently have lots of agents all following
//each other in single file to get from one place to another
public static double NoisyEuclidianDistance(SparseGraph G, int nd1, int nd2)
{
return(Vector2D.Vec2DDistance(G.GetNode(nd1).Pos, G.GetNode(nd2).Pos) * Utils.RandInRange(0.9f, 1.1f));
}
//calculate the straight line distance from node nd1 to node nd2
public static double EuclidianDistance(SparseGraph G, int nd1, int nd2)
{
return(Vector2D.Vec2DDistance(G.GetNode(nd1).Pos, G.GetNode(nd2).Pos));
}
public void Render(Graphics objGraphics)
{
//render all the cells
for (int nd = 0; nd < m_Graph.NumNodes(); ++nd)
{
int left = (int)(m_Graph.GetNode(nd).Pos.X - m_dCellWidth / 2.0);
int top = (int)(m_Graph.GetNode(nd).Pos.Y - m_dCellHeight / 2.0);
int right = (int)(1 + m_Graph.GetNode(nd).Pos.X + m_dCellWidth / 2.0);
int bottom = (int)(1 + m_Graph.GetNode(nd).Pos.Y + m_dCellHeight / 2.0);
Rectangle rect = Rectangle.FromLTRB(left, top, right, bottom);
SolidBrush fillBrush = new SolidBrush(Color.Gray);
switch (m_TerrainType[nd])
{
case (int)brush_type.normal:
fillBrush.Color = Color.White;
break;
case (int)brush_type.obstacle:
fillBrush.Color = Color.Black;
break;
case (int)brush_type.water:
fillBrush.Color = Color.DodgerBlue;
break;
case (int)brush_type.mud:
fillBrush.Color = Color.Brown;
break;
default:
fillBrush.Color = Color.White;
break;
}//end switch
objGraphics.FillRectangle(fillBrush, rect);
if (m_bShowTiles)
{
objGraphics.DrawLine(Pens.Gray, rect.Location, new Point(rect.Right, rect.Top));
objGraphics.DrawLine(Pens.Gray, rect.Location, new Point(rect.Left, rect.Bottom));
}
if (nd == m_iTargetCell)
{
rect.Inflate(-4, -4);
objGraphics.FillRectangle(Brushes.Red, rect);
objGraphics.DrawString("T", m_font, Brushes.Black, rect.Right - (int)(rect.Width * 0.75), rect.Y);
}
else if (nd == m_iSourceCell)
{
rect.Inflate(-4, -4);
objGraphics.FillRectangle(Brushes.LightGreen, rect);
objGraphics.DrawString("S", m_font, Brushes.Black, rect.Right - (int)(rect.Width * 0.75), rect.Y);
}
//render dots at the corners of the cells
objGraphics.DrawLine(m_ThickBlack, left, top, left + 1, top + 1);
}
//draw the graph nodes and edges if rqd
if (m_bShowGraph)
{
if (m_Graph.NumNodes() > 0)
{
SparseGraph.NodeIterator NodeItr = new SparseGraph.NodeIterator(m_Graph);
while (NodeItr.MoveNext())
{
objGraphics.DrawEllipse(Pens.LightGray, (int)(NodeItr.Current.Pos.X - 2), (int)(NodeItr.Current.Pos.Y - 2), (int)2 * 2, (int)2 * 2);
SparseGraph.EdgeIterator EdgeItr = new SparseGraph.EdgeIterator(m_Graph, NodeItr.Current.Index);
while (EdgeItr.MoveNext())
{
objGraphics.DrawLine(Pens.LightGray, (int)NodeItr.Current.Pos.X, (int)NodeItr.Current.Pos.Y, (int)m_Graph.GetNode(EdgeItr.Current.To).Pos.X, (int)m_Graph.GetNode(EdgeItr.Current.To).Pos.Y);
}
}
}
}
//draw any tree retrieved from the algorithms
for (int e = 0; e < m_SubTree.Count; ++e)
{
if (!NavGraphEdge.IsNull(m_SubTree[e]))
{
Vector2D from = m_Graph.GetNode(m_SubTree[e].From).Pos;
Vector2D to = m_Graph.GetNode(m_SubTree[e].To).Pos;
objGraphics.DrawLine(Pens.Red, (int)from.X, (int)from.Y, (int)to.X, (int)to.Y);
}
}
//draw the path (if any)
if (m_Path.Count > 0)
{
for (int i = 0; i < m_Path.Count; ++i)
{
if (i > 0)
{
Point start = new Point((int)m_Graph.GetNode(m_Path[i - 1]).Pos.X, (int)m_Graph.GetNode(m_Path[i - 1]).Pos.Y);
Point end = new Point((int)m_Graph.GetNode(m_Path[i]).Pos.X, (int)m_Graph.GetNode(m_Path[i]).Pos.Y);
objGraphics.DrawLine(m_ThickBlue, start, end);
}
}
}
}
public override void Create()
{
Graph = new SparseGraph(false);
for (int row = 0; row < rows; row++)
{
for (int column = 0; column < columns; column++)
{
var nodePosition =
new Vector2(
column * cellWidth - cellWidth * (columns - 1) / 2,
row * cellHeight - cellHeight * (rows - 1) / 2);
var node = new Node(row * columns + column)
{
Position = nodePosition
};
int nodeIndex = Graph.AddNode(node);
if (IsPointInObstacle(nodePosition))
{
Graph.GetNode(nodeIndex).Index = Node.INVALID_NODE_INDEX;
}
else
{
//AddNodeObject(node, nodePosition);
}
}
}
for (int nodeIndex = 0; nodeIndex < Graph.NumNodes; nodeIndex++)
{
if (!Graph.IsNodePresent(nodeIndex))
{
continue;
}
Node node = Graph.GetNode(nodeIndex);
int rightIndex = nodeIndex + 1;
if (rightIndex % columns != 0 && Graph.IsNodePresent(rightIndex))
{
Node rightNode = Graph.GetNode(rightIndex);
if (!IsPathObstructed(node.Position, rightNode.Position))
{
var rightEdge = new Edge(nodeIndex, rightIndex, cellWidth);
Graph.AddEdge(rightEdge);
//AddEdgeObject(rightEdge, node.Position, rightNode.Position);
}
}
int downIndex = nodeIndex + columns;
if (downIndex < Graph.NumNodes && Graph.IsNodePresent(downIndex))
{
Node downNode = Graph.GetNode(downIndex);
if (!IsPathObstructed(node.Position, downNode.Position))
{
var downEdge = new Edge(nodeIndex, downIndex, cellHeight);
Graph.AddEdge(downEdge);
//AddEdgeObject(downEdge, node.Position, downNode.Position);
}
}
if (!useDiagonals)
{
continue;
}
int diagIndex = nodeIndex + columns + 1;
if (diagIndex < Graph.NumNodes && diagIndex % columns != 0 &&
Graph.IsNodePresent(diagIndex))
{
Node diagNode = Graph.GetNode(diagIndex);
if (!IsPathObstructed(node.Position, diagNode.Position))
{
var diagEdge = new Edge(nodeIndex, diagIndex, cellDiagonal);
Graph.AddEdge(diagEdge);
//AddEdgeObject(diagEdge, node.Position, diagNode.Position);
}
}
int backDiagIndex = nodeIndex + columns - 1;
if (backDiagIndex < Graph.NumNodes && backDiagIndex % columns != columns - 1 &&
Graph.IsNodePresent(backDiagIndex))
{
Node backDiagNode = Graph.GetNode(backDiagIndex);
if (!IsPathObstructed(node.Position, backDiagNode.Position))
{
var backDiagEdge = new Edge(nodeIndex, backDiagIndex, cellDiagonal);
Graph.AddEdge(backDiagEdge);
//AddEdgeObject(backDiagEdge, node.Position, backDiagNode.Position);
}
}
}
}