Exemplo n.º 1
0
        private void AddAvoidList(ChallengeMap map, HashSet <PathNode> pathNodeSearchedList, List <PathNode> avoidNodeList, bool includeTopNode = false)
        {
            int index = 0;

            foreach (PathNode node in pathNodeSearchedList)
            {
                if (includeTopNode)
                {
                    if (!avoidNodeList.Contains(node) && node.coordinate_X != map.MaxCountX - 1)
                    {
                        avoidNodeList.Add(node);
                    }
                }
                else
                {
                    if (index > 0)
                    {
                        if (!avoidNodeList.Contains(node) && node.coordinate_X != map.MaxCountX - 1)
                        {
                            avoidNodeList.Add(node);
                        }
                    }
                }

                index++;
            }

            //return avoidNodeList;
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            try
            {
                ChallengeMap map = new ChallengeMap();
                map.Create("map.txt");

                PathFinder pathFinder = new PathFinder();
                pathFinder.SearchPath(map);

                if (pathFinder.CalculatedPath != null && pathFinder.CalculatedPath.Trim() != string.Empty)
                {
                    Console.WriteLine("\n\n");
                    Console.WriteLine("Length Of Calculated Path: " + pathFinder.LengthOfCalculatedPath);
                    Console.WriteLine("Drop Of Calculated Path: " + pathFinder.DropOfCalculatedPath);
                    Console.WriteLine("Calculated Path: " + pathFinder.CalculatedPath);
                }
                else
                {
                    Console.WriteLine("No Possible Path Down!");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.Read();
        }
Exemplo n.º 3
0
        public void SearchPath(ChallengeMap map)
        {
            int[,] mapPath      = new int[map.MaxCountX, map.MaxCountY];
            PathNode[,] pathMap = new PathNode[map.MaxCountX, map.MaxCountY];

            for (int mapIndex_X = 0; mapIndex_X < map.MaxCountX; mapIndex_X++)
            {
                for (int mapIndex_Y = 0; mapIndex_Y < map.MaxCountY; mapIndex_Y++)
                {
                    PathNode node = new PathNode();
                    node.data         = int.Parse(map.challengeMap[mapIndex_X, mapIndex_Y]);
                    node.coordinate_X = mapIndex_X;
                    node.coordinate_Y = mapIndex_Y;

                    pathMap[mapIndex_X, mapIndex_Y] = node;
                }
            }

            List <PathNode> targetNodes = new List <PathNode>();

            targetNodes = findAllStartingNode(map, pathMap);

            List <List <PathNode> > TotalPath_List = findPath(pathMap, map, targetNodes).OrderByDescending(x => x.Count).ToList();

            if (TotalPath_List.Count > 0)
            {
                TotalPath_List = filterTopPaths(TotalPath_List);
                findSteepestNodePath(TotalPath_List);
            }
        }
Exemplo n.º 4
0
 private void GetAllBottleNeckNodes(PathNode[,] pathMap, ChallengeMap map, HashSet <PathNode> bottleNeckNodes)
 {
     for (int mapIndex_X = 0; mapIndex_X < map.MaxCountX; mapIndex_X++)
     {
         for (int mapIndex_Y = 0; mapIndex_Y < map.MaxCountY; mapIndex_Y++)
         {
             if (pathMap[mapIndex_X, mapIndex_Y].data < map.MaxCountX - mapIndex_X)
             {
                 bottleNeckNodes.Add(pathMap[mapIndex_X, mapIndex_Y]);
             }
         }
     }
 }
Exemplo n.º 5
0
        private List <PathNode> findAllStartingNode(ChallengeMap map, PathNode[,] pathMap)
        {
            //x,y,data
            List <PathNode> nodeList = new List <PathNode>();

            List <PathNode> nodeListSameValue = new List <PathNode>();

            for (int mapIndex_X = 0; mapIndex_X < map.MaxCountX; mapIndex_X++)
            {
                PathNode highestNodeValue = new PathNode();

                for (int mapIndex_Y = 0; mapIndex_Y < map.MaxCountY; mapIndex_Y++)
                {
                    if (mapIndex_X < map.MaxCountX - 1)
                    {
                        if (pathMap[mapIndex_X, mapIndex_Y].data > highestNodeValue.data)
                        {
                            highestNodeValue = pathMap[mapIndex_X, mapIndex_Y];

                            nodeListSameValue = new List <PathNode>();
                            nodeListSameValue.Add(highestNodeValue);
                        }
                        else
                        {
                            if (pathMap[mapIndex_X, mapIndex_Y].data == highestNodeValue.data && highestNodeValue.data > 0 || pathMap[mapIndex_X, mapIndex_Y].data >= map.MaxCountX - mapIndex_X && highestNodeValue.data > 0)
                            {
                                nodeListSameValue.Add(pathMap[mapIndex_X, mapIndex_Y]);
                            }
                        }
                    }
                }

                if (highestNodeValue.data > 0 && nodeListSameValue.Count > 0)
                {
                    foreach (PathNode node in nodeListSameValue)
                    {
                        nodeList.Add(node);
                    }

                    nodeListSameValue = new List <PathNode>();
                }
            }

            return(nodeList);
        }
Exemplo n.º 6
0
        private List <PathNode> ClearAvoidNodeListBaseOnDirection(ChallengeMap map, PathNode currentNode, List <PathNode> avoidNodeList, int direction)
        {
            List <PathNode> indexRemoveList = new List <PathNode>();

            int coordinate_X = currentNode.coordinate_X;

            if (direction == Direction.Down)
            {
                coordinate_X = currentNode.coordinate_X + 1;
            }

            for (int index = 0; index < avoidNodeList.Count; index++)
            {
                if (avoidNodeList[index].coordinate_X == coordinate_X)
                {
                    //CHECK CURRENT SCAN DIRECTION
                    switch (direction)
                    {
                    case Direction.Left:
                    {
                        if (currentNode.coordinate_Y > 0)
                        {
                            if (avoidNodeList[index].coordinate_Y < currentNode.coordinate_Y)
                            {
                                indexRemoveList.Add(avoidNodeList[index]);
                                avoidNodeList.Remove(avoidNodeList[index]);
                                break;
                            }
                        }
                        break;
                    }

                    case Direction.Right:
                    {
                        if (currentNode.coordinate_Y < map.MaxCountY - 1)
                        {
                            if (avoidNodeList[index].coordinate_Y > currentNode.coordinate_Y)
                            {
                                indexRemoveList.Add(avoidNodeList[index]);
                                avoidNodeList.Remove(avoidNodeList[index]);
                                break;
                            }
                        }
                        break;
                    }

                    case Direction.Down:
                    {
                        if (avoidNodeList[index].coordinate_Y != currentNode.coordinate_Y && currentNode.coordinate_Y > 0)
                        {
                            if (avoidNodeList[index].coordinate_Y == currentNode.coordinate_Y - 1)
                            {
                                indexRemoveList.Add(avoidNodeList[index]);
                                avoidNodeList.Remove(avoidNodeList[index]);
                            }
                        }
                        else if (avoidNodeList[index].coordinate_Y != currentNode.coordinate_Y && currentNode.coordinate_Y < map.MaxCountY - 1)
                        {
                            if (avoidNodeList[index].coordinate_Y == currentNode.coordinate_Y + 1)
                            {
                                indexRemoveList.Add(avoidNodeList[index]);
                                avoidNodeList.Remove(avoidNodeList[index]);
                            }
                        }


                        break;
                    }
                    }
                }
            }

            return(indexRemoveList);
        }
Exemplo n.º 7
0
        private List <List <PathNode> > findPath(PathNode[,] pathMap, ChallengeMap map, List <PathNode> targetNodes)
        {
            DirectionScanner scanner = new DirectionScanner();

            int nodeCounter = 0;

            //GET ALL BOTTLENECK NODES
            GetAllBottleNeckNodes(pathMap, map, scanner.bottleNeckList);


            List <PathNode> NodeCleared = new List <PathNode>();

            //Scan Twice to properly scan the whole Map
            for (int scanning = 0; scanning < 2; scanning++)
            {
                foreach (PathNode node in targetNodes)
                {
                    nodeCounter++;
                    string valuesCount = (((double)nodeCounter / (targetNodes.Count() * 2)) * 100).ToString();
                    Console.WriteLine(" Scanning ChallengeMap: " + (int)Convert.ToDouble(valuesCount, CultureInfo.InvariantCulture.NumberFormat) + "%");
                    Console.SetCursorPosition(0, 0);

                    scanner.pathNodeSearched = new List <PathNode>();
                    scanner.avoidNodeList    = new List <PathNode>();

                    scanner.pathNodeSearched.Add(pathMap[node.coordinate_X, node.coordinate_Y]);
                    scanner.currentNode = pathMap[node.coordinate_X, node.coordinate_Y];

                    bool hasScanned = false;
                    int  maxcounter = 0;

                    while (true)
                    {
                        if (scanner.bottleNeckList.Contains(scanner.currentNode))
                        {
                            scanner.pathNodeSearched.Remove(scanner.currentNode);
                            scanner.currentNode = scanner.pathNodeSearched[scanner.pathNodeSearched.Count - 1];
                        }


                        //Scanning Left Direction - FirstScan
                        if (scanning == 0)
                        {
                            hasScanned = scanner.ScanLeft(pathMap);

                            //Left Scan
                            if (hasScanned)
                            {
                                NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Left);

                                if (NodeCleared.Count == 0)
                                {
                                    NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Down);
                                }

                                continue;
                            }
                            else
                            {
                                hasScanned = scanner.ScanRight(pathMap, map.MaxCountY);
                            }

                            //Right Scan
                            if (hasScanned)
                            {
                                NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Right);

                                if (NodeCleared.Count == 0)
                                {
                                    NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Down);
                                }

                                continue;
                            }
                        }
                        else //Scanning Right Direction - SecondScan
                        {
                            hasScanned = scanner.ScanRight(pathMap, map.MaxCountY);

                            //Right Scan
                            if (hasScanned)
                            {
                                NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Right);

                                if (NodeCleared.Count == 0)
                                {
                                    NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Down);
                                }

                                continue;
                            }
                            else
                            {
                                hasScanned = scanner.ScanLeft(pathMap);
                            }

                            //Left Scan
                            if (hasScanned)
                            {
                                NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Left);

                                if (NodeCleared.Count == 0)
                                {
                                    NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Down);
                                }

                                continue;
                            }
                        }



                        if (!hasScanned)
                        {
                            hasScanned = scanner.ScanDownward(pathMap, map.MaxCountX);


                            if (NodeCleared.Count() > 0)
                            {
                                //Add All Cleared Nodes in PreviousStage
                                AddAvoidList(map, new HashSet <PathNode>()
                                {
                                    scanner.currentNode
                                }, scanner.avoidNodeList, true);
                                NodeCleared = new List <PathNode>();
                            }

                            if (hasScanned)
                            {
                                NodeCleared = ClearAvoidNodeListBaseOnDirection(map, scanner.currentNode, scanner.avoidNodeList, Direction.Down);
                            }


                            if (hasScanned)
                            {
                                //CHECK IF END OF MAP IS REACHED
                                if (scanner.pathNodeSearched[scanner.pathNodeSearched.Count - 1].coordinate_X == map.MaxCountX - 1)
                                {
                                    if (isPathSearchedAlreadyAdded(scanner.pathNodeInTotalSearched, scanner.pathNodeSearched))
                                    {
                                        break;
                                    }
                                    else
                                    {
                                        scanner.pathNodeInTotalSearched.Add(scanner.pathNodeSearched);
                                    }


                                    AddAvoidList(map, scanner.pathNodeSearched, scanner.avoidNodeList);


                                    scanner.pathNodeSearched = new List <PathNode>();
                                    scanner.currentNode      = pathMap[node.coordinate_X, node.coordinate_Y];

                                    ClearAllAvoidNodeInCurrentXIndex(scanner.currentNode.coordinate_X, map.MaxCountY, scanner.avoidNodeList);

                                    scanner.pathNodeSearched.Add(pathMap[node.coordinate_X, node.coordinate_Y]);
                                }



                                continue;
                            }

                            if (!hasScanned && scanner.currentNode == scanner.pathNodeSearched[0])
                            {
                                maxcounter++;
                                if (maxcounter >= DirectionScanner.CURRENTNODE_MAXCOUNT)
                                {
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            return(scanner.pathNodeInTotalSearched);
        }