示例#1
0
    public void AddNode(types.RouteNode _r)
    {
        float dist = Vector3.Distance(GetLastNode().GetPosition(), _r.GetPosition());

        segmentLengths.Add(dist);
        nodes.Add(_r);
    }
示例#2
0
 public Route(types.RouteNode _r1, types.RouteNode _r2)
 {
     nodes = new List <types.RouteNode>();
     nodes.Add(_r1);
     nodes.Add(_r2);
     segmentLengths.Add(Vector3.Distance(_r1.GetPosition(), _r2.GetPosition()));
 }
示例#3
0
    public Route FindPath(Structure _origin, Structure _destination)
    {
        // TODO: need to first check to see if on same street as destination, and can just early out and travel straight there!

        checkedNodes = new List <types.RouteNode>();
        List <Route> possibleRoutes = new List <Route>();

        // check to see if you're starting on an intersection already
        Intersection _originIntersection = _origin as Intersection;

        if (_originIntersection != null)
        {
            types.RouteNode routeNodeStart = new types.RouteNode(_origin);
            Route           route          = new Route(routeNodeStart);
            possibleRoutes.Add(route);

            checkedNodes.Add(routeNodeStart);
        }
        else
        {
            foreach (Intersection intersection in _origin.GetPath().GetIntersections())
            {
                types.RouteNode routeNodeStart = new types.RouteNode(_origin);
                types.RouteNode routeNodeEnd   = new types.RouteNode(intersection);
                Route           route          = new Route(routeNodeStart, routeNodeEnd);
                possibleRoutes.Add(route);

                checkedNodes.Add(routeNodeEnd);
            }
        }

        int loopTimeOut = 0;

        while (loopTimeOut < 1000)
        {
            // current shortest path
            float currentShortestDistance = 0.0f;
            int   currentShortestRoute    = -1;

            string distanceCompare = "DIST: ";
            for (int i = 0; i < possibleRoutes.Count; i++)
            {
                distanceCompare += i + " " + possibleRoutes[i] + ":" + possibleRoutes[i].GetDistance() + ", ";
                if (currentShortestRoute == -1 || possibleRoutes[i].GetDistance() < currentShortestDistance)
                {
                    currentShortestDistance = possibleRoutes[i].GetDistance();
                    currentShortestRoute    = i;
                }
            }

            Route shortestRoute = possibleRoutes[currentShortestRoute];

            // if the current shortest route ends in the destination, then return that route
            types.RouteNode n = shortestRoute.GetLastNode();
            if (shortestRoute.GetLastNode().IsSame(_destination))
            {
                return(shortestRoute);
            }

            // take the shortest route found, and check to see if it has path branches
            List <Path> pathsFromThisIntersection = ((Intersection)shortestRoute.GetLastNode().structure).GetPaths();
            // create a duplicate of the route for each possible path it could take
            List <Route> routeClones = new List <Route>();
            foreach (Path path in pathsFromThisIntersection)
            {
                Route routeClone = new Route(shortestRoute);
                routeClones.Add(routeClone);
            }
            // delete the original, since one of its clone will count for it
            possibleRoutes.Remove(shortestRoute);
            // check each route option
            for (int i = 0; i < routeClones.Count; i++)
            {
                // check for destination on current path
                Path thisPath = pathsFromThisIntersection[i];
                if (thisPath.GetStructures().Contains(_destination))
                {
                    routeClones[i].AddNode(new types.RouteNode(_destination));
                    possibleRoutes.Add(routeClones[i]);
                }
                else                   // otherwise add the next intersection to the route
                {
                    Structure       _intersection = ((Intersection)routeClones[i].GetLastNode().structure).GetOppositeIntersection(thisPath);
                    types.RouteNode newRouteNode  = new types.RouteNode(_intersection);

                    bool foundDuplicate = false;
                    foreach (types.RouteNode node in checkedNodes)
                    {
                        // if it's an intersection that's already been found don't add the route
                        if (node.structure == newRouteNode.structure)
                        {
                            foundDuplicate = true;
                        }
                    }

                    if (foundDuplicate)
                    {
                        // don't add route back to possible list
                    }
                    else
                    {
                        checkedNodes.Add(newRouteNode);
                        routeClones[i].AddNode(newRouteNode);
                        possibleRoutes.Add(routeClones[i]);
                    }
                }
            }
            loopTimeOut++;
        }
        Debug.LogError("no possible route found");
        return(null);
    }
示例#4
0
 public Route(types.RouteNode _r1)
 {
     nodes = new List <types.RouteNode>();
     nodes.Add(_r1);
 }