Esempio n. 1
0
        private static int Distance(Cell start, List <CellStruct> listCells, HasSomething has, bool checkFirst)
        {
            int tileTraversed = 0;

            for (int i = 0; i < listCells.Count; i++)
            {
                listCells[i].visited = false;
            }

            List <CellStruct> list     = new List <CellStruct>();
            List <CellStruct> copyList = new List <CellStruct>();

            CellStruct firstCell = listCells.FirstOrDefault(c => c.x == start.X && c.y == start.Y);

            firstCell.visited = true;
            list.Add(firstCell);

            while (list.Count != 0)
            {
                copyList.AddRange(list);
                list.Clear();

                foreach (CellStruct node in copyList)
                {
                    if (has(node.x, node.y, listCells))
                    {
                        if (checkFirst && node.x == firstCell.x && node.y == firstCell.y)
                        {
                            return(tileTraversed);
                        }
                        else if (node.x != firstCell.x || node.y != firstCell.y)
                        {
                            return(tileTraversed);
                        }
                    }


                    //west
                    if (HasCellUnvisited(node.x - 1, node.y, listCells))
                    {
                        CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x - 1 && c.y == node.y);
                        openNode.visited = true;
                        list.Add(openNode);
                    }
                    //east
                    if (HasCellUnvisited(node.x + 1, node.y, listCells))
                    {
                        CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x + 1 && c.y == node.y);
                        openNode.visited = true;
                        list.Add(openNode);
                    }
                    //north
                    if (HasCellUnvisited(node.x, node.y - 1, listCells))
                    {
                        CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x && c.y == node.y - 1);
                        openNode.visited = true;
                        list.Add(openNode);
                    }
                    //south
                    if (HasCellUnvisited(node.x, node.y + 1, listCells))
                    {
                        CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x && c.y == node.y + 1);
                        openNode.visited = true;
                        list.Add(openNode);
                    }
                }

                tileTraversed++;
            }
            return(tileTraversed);
        }
Esempio n. 2
0
        private static int FloodFill(Cell startCell, List <Cell> cellsArea, List <CellStruct> listCells, HasSomething has, bool checkFirst)
        {
            int tileTraversed = 0;

            for (int i = 0; i < listCells.Count; i++)
            {
                listCells[i].visited = false;
            }

            if (checkFirst)
            {
                if (has(startCell.X, startCell.Y, listCells))
                {
                    return(0);
                }
            }


            ListQueue <CellStruct> queue     = new ListQueue <CellStruct>();
            CellStruct             firstCell = listCells.FirstOrDefault(c => c.x == startCell.X && c.y == startCell.Y);

            firstCell.visited = true;
            queue.Enqueue(firstCell);

            while (queue.Count != 0)
            {
                CellStruct node = queue.Dequeue();
                tileTraversed++;

                //west
                if (HasCellUnvisited(node.x - 1, node.y, listCells))
                {
                    if (has(node.x - 1, node.y, listCells))
                    {
                        return(tileTraversed);
                    }

                    CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x - 1 && c.y == node.y);
                    openNode.visited = true;
                    queue.Enqueue(openNode);
                }
                //east
                if (HasCellUnvisited(node.x + 1, node.y, listCells))
                {
                    if (has(node.x + 1, node.y, listCells))
                    {
                        return(tileTraversed);
                    }
                    CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x + 1 && c.y == node.y);
                    openNode.visited = true;
                    queue.Enqueue(openNode);
                }
                //north
                if (HasCellUnvisited(node.x, node.y - 1, listCells))
                {
                    if (has(node.x, node.y - 1, listCells))
                    {
                        return(tileTraversed);
                    }
                    CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x && c.y == node.y - 1);
                    openNode.visited = true;
                    queue.Enqueue(openNode);
                }
                //south
                if (HasCellUnvisited(node.x, node.y + 1, listCells))
                {
                    if (has(node.x, node.y + 1, listCells))
                    {
                        return(tileTraversed);
                    }
                    CellStruct openNode = listCells.FirstOrDefault(c => c.x == node.x && c.y == node.y + 1);
                    openNode.visited = true;
                    queue.Enqueue(openNode);
                }
            }
            return(tileTraversed);
        }