一、解決問題：

在Unity3d的一些2d遊戲製作上，有時需要敵人在眾多箱子（障礙物）中向主角移動，如果是簡單的移動ai程式碼實現，敵人有可能陷入死衚衕然後左右移動，卡死在衚衕上，為了一個智慧的ai實現，比較常用的是A*演算法，但這裡為了簡便，我們使用了深度搜索的方式進行判斷。所謂深度搜索，一位博主總結得很好，就是“不見棺材不回頭。演算法會朝一個方向進發，直到遇到邊界或者障礙物，才回溯。一般在實現的時候，我們採用遞迴的方式來進行，也可以採用模擬壓棧的方式來實現。”

在這裡的程式碼中，是利用c#的棧，儲存了名為Cell的宮格類，Cell類中包含了周圍四個方向是否有路的資訊，Maze迷宮類中將對每個能走的方向都進行嘗試行走，將能走的路一直走下去，直到走不通為止，此時開始回溯，即使用stack.Pop(),一直退回分支，走下一條路線。舉個例子：當前宮格的北方向【有路】，那麼嘗試向北走一步，走完後把設定此宮格的北方向為【無路】，並把走到的那個宮格的南方向設定為【無路】（都是相對的），就這樣一直走下去，當發現無法到達終點時，開始退回，再次判斷當前宮格的四個方向是否有路，直到退回到最後的分支上，進行下一條路的嘗試行走。

該演算法雖然簡單，但卻在不少地方都需要用到，比如遊戲按鍵刷圖指令碼的地圖判斷的處理部分：例如找色判斷dnf、手遊《永遠的7日之都》的萬神殿地圖部分，只要能直到當前揭示的地圖，就可以算出一條通向boss的道路，然後自動刷圖就完成了一個核心功能。

二、演示效果：

控制檯程式程式碼Program.cs中輸入：

 int[,] maps = new int[,] {
                { 0, 0, 0, 0, 0 },
                { 1, 0, 0, 1, 1 },
                { 0, 0, 0, 1, 0 },
                { 0, 1, 1, 1, 1 },

                { 0, 0, 0, 0, 0 } };

註釋：0代表可通過，1代表不可通過。

執行程式，輸出如下：

2 2 2 0 0
1 2 2 1 1
2 2 2 1 0
2 1 1 1 1
2 2 2 2 2

註釋：2代表為走出的路徑

三、上程式碼：

建立控制檯程式：

Program.cs:

using System;

namespace MazePath
{
    class Program
    {
        static void Main(string[] args)
        {
            //0表示可走，1表示不可走
            int[,] maps = new int[,] {
                { 0, 0, 0, 0, 0 },
                { 1, 0, 0, 1, 1 },
                { 0, 0, 0, 1, 0 },
                { 0, 1, 1, 1, 1 },
                { 0, 0, 0, 0, 0 } };


            Maze maze = new Maze(maps);           
            Console.ReadLine();
        }
    }
}
 

Maze.cs:

using System;
using System.Collections.Generic;


namespace MazePath
{
    class Maze
    {
        Cell[,] cells;
        Stack<Cell> cellStack = new Stack<Cell>();
        int[,] maps;
        int rows;
        int length;

        public Maze(int[,] maps)
        {
            this.maps = maps;
            length = maps.GetLength(1);
            rows = maps.GetLength(0);
            cells = new Cell[rows, length];
            InitCells();
            GetValidPath();
            ConsoleResult();
        }

        public void InitCells()
        {
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    //設定每個格子自身的位置屬性
                    Cell cell = new Cell();
                    cell.SetPos(i, j);

                    cells[i, j] = cell;

                    //-----設定格子的周圍方向屬性---------------
                    //西
                    if ((j - 1) >= 0)
                    {
                        if (maps[i, j - 1] == 0)
                            cells[i, j].SetDirection(Const.WEST, Const.ENABLE);
                        else
                            cells[i, j].SetDirection(Const.WEST, Const.DISABLE);
                    }

                    //東
                    if ((j + 1) < length)
                    {
                        if (maps[i, j + 1] == 0)
                            cells[i, j].SetDirection(Const.EAST, Const.ENABLE);
                        else
                            cells[i, j].SetDirection(Const.EAST, Const.DISABLE);
                    }

                    //北
                    if ((i - 1) >= 0)
                    {
                        if (maps[i - 1, j] == 0)
                            cells[i, j].SetDirection(Const.NORTH, Const.ENABLE);
                        else
                            cells[i, j].SetDirection(Const.NORTH, Const.DISABLE);
                    }

                    //南
                    if ((i + 1) < rows)
                    {
                        if (maps[i + 1, j] == 0)
                            cells[i, j].SetDirection(Const.SOUTH, Const.ENABLE);
                        else
                            cells[i, j].SetDirection(Const.SOUTH, Const.DISABLE);
                    }

                }
            }
        }

        public void GetValidPath()
        {
            int i = 0;int j = 0;
            cellStack.Push(cells[i, j]);
            while (true)
            {
                i = cellStack.Peek().x; j = cellStack.Peek().y;
                if (i == (rows - 1) && j == (length - 1))
                {
                    return;
                }

                //東
                if (cellStack.Peek().GetDirection(Const.EAST)==Const.ENABLE)
                {
                    cells[i, j].SetDirection(Const.EAST, Const.DISABLE);
                    cells[i, j+1].SetDirection(Const.WEST, Const.DISABLE);
                    cellStack.Push(cells[i, j + 1]);
                    continue;
                }
                //西
                if (cellStack.Peek().GetDirection(Const.WEST) == Const.ENABLE)
                {
                    cells[i, j].SetDirection(Const.WEST, Const.DISABLE);
                    cells[i, j + 1].SetDirection(Const.EAST, Const.DISABLE);
                    cellStack.Push(cells[i, j - 1]);
                    continue;
                }
                //北
                if (cellStack.Peek().GetDirection(Const.NORTH) == Const.ENABLE)
                {
                    cells[i, j].SetDirection(Const.NORTH, Const.DISABLE);
                    cells[i - 1, j].SetDirection(Const.SOUTH, Const.DISABLE);
                    cellStack.Push(cells[i-1, j]);
                    continue;
                }
                //南
                if (cellStack.Peek().GetDirection(Const.SOUTH) == Const.ENABLE)
                {
                    cells[i, j].SetDirection(Const.SOUTH, Const.DISABLE);
                    cells[i + 1, j].SetDirection(Const.NORTH, Const.DISABLE);
                    cellStack.Push(cells[i+1, j]);
                    continue;
                }

                cellStack.Pop();

                if (cellStack.Count == 0)
                {
                    Console.WriteLine("根本沒有這個路徑");
                    return;
                }
            }
        }

        public void ConsoleResult()
        {
            while (cellStack.Count != 0)
            {
                int i = cellStack.Peek().x;
                int j = cellStack.Peek().y;
                cellStack.Pop();
                maps[i, j] = 2;
            }

            string s = "";
            for(int i = 0; i < maps.GetLength(0); i++)
            {
                for(int j = 0; j < maps.GetLength(1); j++)
                {
                    s += maps[i, j].ToString()+" ";
                }
                s += "\r\n";
            }
            Console.WriteLine(s);
        }
    }
}

Cell.cs:

namespace MazePath
{
    class Cell
    {
        public int x;
        public int y;
        //directon 索引0-3分別是東西南北，預設為0表示不可走，1則表示可走
        private int[] directions = new int[4];

        public void SetPos(int x,int y)
        {
            this.x = x;
            this.y = y;
        }

        public bool IsEnable(int index)
        {
            return directions[index]==1;
        }
        public void SetDirection(int index,int result)
        {
            directions[index] = result;
        }
        public int GetDirection(int index)
        {
            return directions[index];
        }
    }
}

Const.cs:

namespace MazePath
{
    public static class Const
    {
        public const int EAST = 0;   //東
        public const int WEST = 1;   //西
        public const int SOUTH = 2;  //南
        public const int NORTH = 3;  //北

        public const int ENABLE = 1;
        public const int DISABLE = 0;

    }
}