コード例 #1
0
        private HashSet <Cave> GetConnectionsHashSet(Cave currentCave)
        {
            HashSet <Cave> caveConnections = new HashSet <Cave>();

            // We iterate i number of times through the CaveConnection jagged array,
            // i being the number of caves. Doing this, we can find out what caves can currentCave
            // move to, and we add them to the caveConnection HashSet.
            for (int i = 0; i < CavesGrid.NumberCaves; i++)
            {
                if (CavesGrid.CaveConnections[i][currentCave.CaveNumber - 1] == 1)
                {
                    caveConnections.Add(HashCave.ElementAt(i));
                }
            }
            return(caveConnections);
        }
コード例 #2
0
        public string SearchPath(int startingCave, int finishingCave)
        {
            // We iterate throughout all the caves and assign them a null parent, the cave number, calculate the F cost,
            // and add them to the HashSet HashCave.
            for (int i = 1; i <= finishingCave; i++)
            {
                Cave Cave = GetCaveObject(i);

                Cave.Parent = null;
                Cave.CalculateFCost();
                Cave.CaveNumber = i;
                HashCave.Add(Cave);
            }
            // We then set the starting cave as the first element in the HashSet, and the finishing cave
            // as the last element in the HashSet
            Cave fromCave = HashCave.ElementAt(startingCave - 1);
            Cave toCave   = HashCave.ElementAt(finishingCave - 1);

            // We set the boolean to true to be able to identify the goal cave
            toCave.IsLastCave = true;
            // We set the G Cost of the starting cave to 0, since it has no cost to travel from start cave
            // to start cave. We also calculate the H cost and the F cost.
            fromCave.GCost = 0;
            fromCave.HCost = Euclidean(fromCave, toCave);
            fromCave.CalculateFCost();

            // We initialise the OpenList and add the initial cave to it. We also initialise
            // the ClosedList
            OpenList = new HashSet <Cave> {
                fromCave
            };
            ClosedList = new HashSet <Cave>();

            // Here is where the algorithm takes place.
            // While the OpenList is not empty we will keep running the algorithm. If the OpenList is empty,
            // that means we didn't find a valid path from start to end cave.
            while (OpenList.Count > 0)
            {
                // We set the currentCave as the one with lowest f cost from the OpenList.
                // If the cave with the lowest f cost is the last cave, that means we found a valid path
                // so we call the function CalculatePath passing the last cave parameter in order to
                // track the path backwards, from the last cave to the initial cave
                Cave currentCave = GetLowestFCostCave(OpenList);
                if (currentCave.IsLastCave == true)
                {
                    return(CalculatePath(toCave));
                }

                // If the currentCave is not the last cave, we remove it from the OpenList and
                // add it to the ClosedList, this way we won't have to visit that node again, unless
                // it proves to have a lower f cost than the current cave.
                OpenList.Remove(currentCave);
                ClosedList.Add(currentCave);

                // We search for all the caves that have a connection with the currentCave
                foreach (Cave connectedCave in GetConnectionsHashSet(currentCave))
                {
                    // If the connectedCave is already in the ClosedList, we check if the f cost of the stored version
                    // has a lower or equal f cost, then we discard the currentCave. If no better version has been found, then
                    // we remove it from the ClosedList and set it as a parent of currentCave.
                    if (ClosedList.Contains(connectedCave))
                    {
                        continue;
                    }

                    // We set the travellingCost as the currentCave G cost plus the Euclidean heuristic from the currentCave to the connectedCave
                    double travellingCost = currentCave.GCost + Euclidean(currentCave, connectedCave);

                    // We check if the travellingCost is inferior to the G cost of the connectedCave. If true, we update the G Cost of the connectedCave
                    // to the travellingCost, calculate the H Cost and F Cost of the conectedCave, and set
                    // the currentCave as a pconnectedCave's parent.
                    if (travellingCost < connectedCave.GCost)
                    {
                        connectedCave.GCost = travellingCost;
                        connectedCave.HCost = Euclidean(connectedCave, toCave);
                        connectedCave.CalculateFCost();
                        connectedCave.Parent = currentCave;

                        // If the OpenList doesn't contain the connectedCave, we add it to the OpenList.
                        if (!OpenList.Contains(connectedCave))
                        {
                            OpenList.Add(connectedCave);
                        }
                    }
                }
            }
            // If the OpenList is empty, we return 0 as we didn't find a valid path.
            return("0");
        }