Esempio n. 1
0
        private unsafe static void TestNeighbour(NativeArray2D <MapNode> gridCopy, ref MapNode kNeighbour, MapNode *currentNodePtr, NativeList <MapNode> neighbours)
        {
            //If node is open, (eg. already tested previously), we compare the g distances to see if traversing the neighbouring node will be more efficient from this node than its parents node.
            if (kNeighbour.state == NodeState.Open)
            {
                float gDistance     = math.distancesq(kNeighbour.position, kNeighbour.parent->position);
                float tempGDistance = currentNodePtr->g + gDistance;

                if (tempGDistance < kNeighbour.g)
                {
                    MapNode *neighbourPtr = gridCopy.GetPointerToElement(kNeighbour.gridPosition);

                    neighbourPtr->SetParent(currentNodePtr);
                    neighbours.Add(*neighbourPtr);
                }
            }
            //If we're untested, we don't have a parent already, so set parent and add to list.
            else
            {
                MapNode *neighbourPtr = gridCopy.GetPointerToElement(kNeighbour.gridPosition);

                neighbourPtr->SetParent(currentNodePtr);
                neighbourPtr->state = NodeState.Open;
                neighbours.Add(*neighbourPtr);
            }
        }
Esempio n. 2
0
        private static unsafe bool SearchForPath(int2 currentNode, int2 targetNode, NativeArray2D <MapNode> gridCopy)
        {
            MapNode *currentNodePtr = gridCopy.GetPointerToElement(currentNode);

            NativeList <MapNode> passableNeighbours = GetPassableNeighbours(currentNode, gridCopy, currentNodePtr);

            NodeCompare nodeCompare = new NodeCompare();

            passableNeighbours.Sort(nodeCompare);

            currentNodePtr->state = NodeState.Closed;
            for (int i = 0; i < passableNeighbours.Length; ++i)
            {
                MapNode neighbour = passableNeighbours[i];
                currentNodePtr->child = gridCopy.GetPointerToElement(neighbour.gridPosition);

                //Target has been reached.
                if (neighbour.gridPosition.Equals(targetNode))
                {
                    passableNeighbours.Dispose();
                    return(true);
                }

                //Recursively search deeper.
                if (SearchForPath(neighbour.gridPosition, targetNode, gridCopy))
                {
                    passableNeighbours.Dispose();
                    return(true);
                }
            }

            passableNeighbours.Dispose();
            return(false);
        }
Esempio n. 3
0
        public float      f; //Estimated total distance traveled if taking this node in the path.

        public void SetParent(MapNode *newParent)
        {
            if (newParent == null)
            {
                return;
            }

            parent = newParent;
            g      = newParent->g + math.distancesq(position, newParent->position);
            f      = g + h;
        }
Esempio n. 4
0
        private static unsafe NativeList <MapNode> GetPassableNeighbours(int2 currentNode,
                                                                         NativeArray2D <MapNode> gridCopy, MapNode *currentNodePtr)
        {
            NativeList <MapNode> neighbours = new NativeList <MapNode>(8, Allocator.Temp);

            //Find all neighbours on the grid by checking if all surrounding nodes are within grid bounds and are valid nodes to traverse to.
            for (int x = -1; x <= 1; ++x)
            {
                int xIndex = currentNode.x + x;

                if (!gridCopy.CheckXBounds(xIndex))
                {
                    continue;
                }

                for (int y = -1; y <= 1; ++y)
                {
                    if (x == 0 && y == 0)
                    {
                        continue;
                    }

                    int yIndex = currentNode.y + y;

                    if (!gridCopy.CheckYBounds(yIndex))
                    {
                        continue;
                    }

                    MapNode neighbour = gridCopy[xIndex, yIndex];
                    if (neighbour.occupiedBy != OccupiedBy.Nothing || neighbour.state == NodeState.Closed)
                    {
                        continue;
                    }

                    TestNeighbour(gridCopy, ref neighbour, currentNodePtr, neighbours);
                }
            }

            return(neighbours);
        }