这个是图的搜索，一般分为深度优先和广度优先
1.深度优先，每次进入到一个新的格子，判断周围的格子，然后选定第一个非墙且未走过的路，直到没有路了，退回到有其他选择的节点，递归进行
2.广度优先，每次进入一个新的格子，把周围所有的格子都入栈，然后遍历每个，将每个可能性的周围继续搜索，直到找到目标节点

可以考虑A*算法，效率高，有成熟的算法描述，且网上有很多源代码可用。需要加入的只是对于地图中格子的属性描述（是否障碍物、是否可破环等），并在寻路过程中进行判断。

这个用A*算法。 下面我给您贴上核心代码

A*算法类
/// <summary>
    /// 节点移动方向
    /// </summary>
    public enum CompassDirections
    {
        /// <summary>
        /// 未设置
        /// </summary>
        NotSet = 0,
        /// <summary>
        /// 上移（北）
        /// </summary>
        North = 1,
        /// <summary>
        /// 右上移（东北）
        /// </summary>
        NorthEast = 2,
        /// <summary>
        /// 右移（东）
        /// </summary>
        East = 3,
        /// <summary>
        /// 右下移（东南）
        /// </summary>
        SouthEast = 4,
        /// <summary>
        /// 下移（南）
        /// </summary>
        South = 5,
        /// <summary>
        /// 左下移（西南）
        /// </summary>
        SouthWest = 6,
        /// <summary>
        /// 左移（西）
        /// </summary>
        West = 7,
        /// <summary>
        /// 左上移（西南）
        /// </summary>
        NorthWest = 8
    }

    /// <summary>
    /// A*算法，节点对象
    /// </summary>
    public class AStarPoint
    {
        /// <summary>
        /// 从起点，沿着产生的路径，移动到网格上指定方格的移动耗费。 
        /// </summary>
        public int G = 0;
        /// <summary>
        /// 从网格上那个方格移动到终点B的预估移动耗费。
        /// </summary>
        public int H = 0;

        /// <summary>
        /// X 坐标
        /// </summary>
        public int X
        {
            get { return CurrentPoint.X; }
            set { CurrentPoint.X = value; }
        }
        /// <summary>
        /// Y 坐标
        /// </summary>
        public int Y
        {
            get { return CurrentPoint.Y; }
            set { CurrentPoint.Y = value; }
        }

        /// <summary>
        /// 初始化当前节点的坐标
        /// </summary>
        /// <param name="_x">X坐标</param>
        /// <param name="_y">Y坐标</param>
        public AStarPoint(int _x, int _y)
        {
            CurrentPoint = new Point(_x, _y);
        }

        /// <summary>
        /// 初始化当前节点对象
        /// </summary>
        /// <param name="currentPoint">当前节点</param>
        /// <param name="parentPoint">父节点</param>
        /// <param name="costG">代价G</param>
        /// <param name="costH">代价H</param>
        public AStarPoint(Point currentPoint, AStarPoint parentPoint, int costG, int costH)
        {
            this.CurrentPoint = currentPoint;
            this.ParentPoint = parentPoint;
            this.G = costG;
            this.H = costH;
        }

        /// <summary>
        /// 当前节点
        /// </summary>
        public Point CurrentPoint = new Point(0, 0);
        /// <summary>
        /// 父节点
        /// </summary>
        public AStarPoint ParentPoint = null;

        /// <summary>
        /// F = G + H
        /// </summary>
        public int F
        {
            get
            {
                return this.G + this.H;
            }
        }

        /// <summary>
        /// 重置当前节点的父节点和代价G
        /// </summary>
        /// <param name="parentPoint">父节点</param>
        /// <param name="costG">代价G</param>
        public void ResetParentPoint(AStarPoint parentPoint, int costG)
        {
            this.ParentPoint = parentPoint;
            this.G = costG;
        }
    }