四种迷宫生成算法

IceLanguage · IceLanguage · commit 5d637e9bfe8c · 2018-08-31T23:29:13.000+08:00
diff --git a/Assets/Scripts/02-mazeGeneration/Algorithm/DFS.cs b/Assets/Scripts/02-mazeGeneration/Algorithm/DFS.cs
@@ -15,13 +15,13 @@ public class DFS:GenerateMazeAlgoritnm
         private static int count = 0;
 
         //记录上一个区域
-        private static Stack<WallArea> _queue = new Stack<WallArea>();
+        private static Stack<WallArea> _stack= new Stack<WallArea>();
 
         public static MazeWall Generate(MazeWall wall)
         {
             mazeWall = wall;
             count = 0;
-            _queue.Clear();
+            _stack.Clear();
 
             //封闭全部墙壁
             mazeWall.ClosedAllWall();
@@ -31,16 +31,16 @@ public static MazeWall Generate(MazeWall wall)
             //随机选择一个开始区域
             WallArea fistArea = RandChooseBeginArea();
             ++count;
-            _queue.Push(fistArea);
+            _stack.Push(fistArea);
 
             WallArea? curArea = fistArea;
             while (count < maxCount)
             {
                 if (null == curArea)
                 {
                     //退回上一个区域
-                    _queue.Pop();
-                    curArea = _queue.Peek();
+                    _stack.Pop();
+                    curArea = _stack.Peek();
                     continue;
                 }
                 curArea = CheckNearby((WallArea)curArea);
@@ -56,7 +56,7 @@ public static MazeWall Generate(MazeWall wall)
 
 
         /// <summary>
-        /// 检测附近区域是否访问过
+        /// 检测附近区域是否访问过,并随机选择其中一个附件区域打通
         /// </summary>
         private static WallArea? CheckNearby(WallArea area)
         {
@@ -69,7 +69,7 @@ public static MazeWall Generate(MazeWall wall)
             ++count;
             WallArea newarea = nerabyAreas[Random.Range(0, nerabyAreas.Count - 1)];
             mazeWall.OpenArea(area, newarea);
-            _queue.Push(newarea);
+            _stack.Push(newarea);
 
             return newarea;
         }
diff --git a/Assets/Scripts/02-mazeGeneration/Algorithm/GenerateMazeAlgoritnm.cs b/Assets/Scripts/02-mazeGeneration/Algorithm/GenerateMazeAlgoritnm.cs
@@ -19,11 +19,11 @@ protected static WallArea RandChooseBeginArea()
             
             return new WallArea(RandomRowIndex, RandomColIndex);
         }
-
         protected static List<WallArea> GetNearbyArea(WallArea area)
         {
             //获得未访问的邻接区域
             List<WallArea> nerabyAreas = new List<WallArea>();
+            
             if (area.rowLength > 0)
                 if (!mazeWall[area.rowLength - 1, area.colLength])
                     nerabyAreas.Add(new WallArea(area.rowLength - 1, area.colLength));
diff --git a/Assets/Scripts/02-mazeGeneration/Algorithm/Prim.cs b/Assets/Scripts/02-mazeGeneration/Algorithm/Prim.cs
@@ -12,6 +12,7 @@ public class Prim:GenerateMazeAlgoritnm
 
         public static MazeWall Generate(MazeWall wall)
         {
+            mazeWall = wall;
             walls.Clear();
 
             //封闭全部墙壁
@@ -27,21 +28,18 @@ public static MazeWall Generate(MazeWall wall)
                 var _wall = walls[randomIndex];
                 if(checkWall(_wall))
                 {
-                    
-                    if(checkArea(_wall.Key))
+                    mazeWall.OpenArea(_wall.Key, _wall.Value);
+                    if (checkArea(_wall.Key))
                     {
                         AddNerabyWall(_wall.Key);
                     }
                     if (checkArea(_wall.Key))
                     {
                         AddNerabyWall(_wall.Value);
                     }
-                    mazeWall.OpenArea(_wall.Key, _wall.Value);
-                }
-                else
-                {
-                    walls.RemoveAt(randomIndex);
+                    
                 }
+                walls.Remove(_wall);
             }
 
             //随机选择迷宫起点终点
@@ -59,9 +57,13 @@ private static void AddNerabyWall(WallArea area)
         {
             List<WallArea> areas = GetNearbyArea(area);
             for (int i = 0; i < areas.Count; ++i)
-                walls.Add(new KeyValuePair<WallArea, WallArea>(
-                    area, areas[i]
-                    ));
+                walls.Add
+                (
+                    new KeyValuePair<WallArea, WallArea>
+                    (
+                        area, areas[i]
+                    )
+                );
         }
 
         
diff --git a/Assets/Scripts/02-mazeGeneration/Algorithm/RecursiveSegmentation.cs b/Assets/Scripts/02-mazeGeneration/Algorithm/RecursiveSegmentation.cs
@@ -1,6 +1,4 @@
 ﻿using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using UnityEngine;
 
 namespace LinHoweMazeGenerate
@@ -11,7 +9,7 @@ namespace LinHoweMazeGenerate
     public class RecursiveSegmentation
     {
         private static MazeWall mazeWall;
-
+        
         public static MazeWall Generate(MazeWall wall)
         {
             mazeWall = wall;
@@ -70,8 +68,9 @@ private static void RecursiveDivision(
             int randomRow = UnityEngine.Random.Range(rowstart + 1, rowend);
             int randomCol = UnityEngine.Random.Range(colstart + 1, colend);
 
+            
             //随机找到四个分界线上四个洞
-            List< KeyValuePair<WallArea,WallArea>> FourHoles = new List<KeyValuePair<WallArea, WallArea>>();
+            List<KeyValuePair<WallArea,WallArea>> FourHoles = new List<KeyValuePair<WallArea, WallArea>>();
             int index = Random.Range(colstart, randomCol);
             FourHoles.Add(new KeyValuePair<WallArea, WallArea>(
                 new WallArea(randomRow - 1,index),
diff --git a/Assets/Scripts/02-mazeGeneration/DataStructure/MazeWall.cs b/Assets/Scripts/02-mazeGeneration/DataStructure/MazeWall.cs
@@ -119,51 +119,56 @@ public void OpenArea(WallArea area1, WallArea area2)
                     new distroyWall(wall.col, area1.colLength, Mathf.Max(area1.rowLength, area2.rowLength)));
             }
         }
-
+        
         /// <summary>
         /// 打通起点终点的边界墙，起点终点随机
         /// </summary>
         public void RandomOpenStartAndPoint()
         {
-            if(Random.Range(0,2)>1)
-                if(Random.Range(0,2)<1)
+            var arr = new[]
+            {
+                new
                 {
-                    int index = Random.Range(0, RowLength - 1);
-                    while(!row[index,0])
-                        index = Random.Range(0, RowLength - 1);
-                    row[index, 0] = false;
-                    NotificationCenter<distroyWall>.Get().DispatchEvent("distroyWall", 
-                        new distroyWall(wall.row,index,0));
-
-                }
-                else
+                    indexMax = RowLength - 1,
+                    rightIndex = 0,
+                    wall = wall.row,
+                    wallarr = this.row,
+                },
+                new
                 {
-                    int index = Random.Range(0, RowLength - 1);
-                    while (!row[index, RowLength])
-                        index = Random.Range(0, RowLength - 1);
-                    row[index, ColLength] = false;
-                    NotificationCenter<distroyWall>.Get().DispatchEvent("distroyWall",
-                        new distroyWall(wall.row, index, ColLength));
-                }
-            else
-                if (Random.Range(0, 2) < 1)
+                    indexMax = RowLength - 1,
+                    rightIndex = ColLength,
+                    wall = wall.row,
+                    wallarr = this.row,
+                },
+                new
                 {
-                    int index = Random.Range(0, ColLength - 1);
-                    while (!row[index, 0])
-                        index = Random.Range(0, ColLength - 1);
-                    col[index, 0] = false;
-                    NotificationCenter<distroyWall>.Get().DispatchEvent("distroyWall",
-                        new distroyWall(wall.col, index, 0));
-            }
-                else
+                    indexMax = ColLength - 1,
+                    rightIndex = 0,
+                    wall = wall.col,
+                    wallarr = this.col,
+                },
+                new
                 {
-                    int index = Random.Range(0, ColLength - 1);
-                    while (!row[index, RowLength])
-                        index = Random.Range(0, ColLength - 1);
-                    col[index, RowLength] = false;
-                NotificationCenter<distroyWall>.Get().DispatchEvent("distroyWall",
-                        new distroyWall(wall.col, index, RowLength));
+                    indexMax = ColLength - 1,
+                    rightIndex = RowLength,
+                    wall = wall.col,
+                    wallarr = this.col,
+                },
+            };
+            
+            int r = Random.Range(0, 3);
+            var choose = arr[r];
+            int index = Random.Range(0, choose.indexMax);
+            while (!choose.wallarr[index, choose.rightIndex])
+            {
+                index = Random.Range(0, choose.indexMax);
             }
+                
+            choose.wallarr[index, choose.rightIndex] = false;
+            NotificationCenter<distroyWall>.Get().DispatchEvent("distroyWall",
+                new distroyWall(choose.wall, index, choose.rightIndex));
+           
             
         }
     }
diff --git a/Assets/Scripts/Common/DataStructure/UnionFindSet.cs b/Assets/Scripts/Common/DataStructure/UnionFindSet.cs
@@ -30,7 +30,7 @@ public bool Union(int a, int b)
 
     }
 
-    int root(int a)
+    private int root(int a)
     {
         if (parents[a] == a)
             return a;

Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,11 @@ protected static WallArea RandChooseBeginArea()`
`19`	`19`
`20`	`20`	`return new WallArea(RandomRowIndex, RandomColIndex);`
`21`	`21`	`}`
`22`		`-`
`23`	`22`	`protected static List<WallArea> GetNearbyArea(WallArea area)`
`24`	`23`	`{`
`25`	`24`	`//获得未访问的邻接区域`
`26`	`25`	`List<WallArea> nerabyAreas = new List<WallArea>();`
	`26`	`+`
`27`	`27`	`if (area.rowLength > 0)`
`28`	`28`	`if (!mazeWall[area.rowLength - 1, area.colLength])`
`29`	`29`	`nerabyAreas.Add(new WallArea(area.rowLength - 1, area.colLength));`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ public class Prim:GenerateMazeAlgoritnm`
`12`	`12`
`13`	`13`	`public static MazeWall Generate(MazeWall wall)`
`14`	`14`	`{`
	`15`	`+ mazeWall = wall;`
`15`	`16`	`walls.Clear();`
`16`	`17`
`17`	`18`	`//封闭全部墙壁`
`@@ -27,21 +28,18 @@ public static MazeWall Generate(MazeWall wall)`
`27`	`28`	`var _wall = walls[randomIndex];`
`28`	`29`	`if(checkWall(_wall))`
`29`	`30`	`{`
`30`		`-`
`31`		`- if(checkArea(_wall.Key))`
	`31`	`+ mazeWall.OpenArea(_wall.Key, _wall.Value);`
	`32`	`+ if (checkArea(_wall.Key))`
`32`	`33`	`{`
`33`	`34`	`AddNerabyWall(_wall.Key);`
`34`	`35`	`}`
`35`	`36`	`if (checkArea(_wall.Key))`
`36`	`37`	`{`
`37`	`38`	`AddNerabyWall(_wall.Value);`
`38`	`39`	`}`
`39`		`- mazeWall.OpenArea(_wall.Key, _wall.Value);`
`40`		`- }`
`41`		`- else`
`42`		`- {`
`43`		`- walls.RemoveAt(randomIndex);`
	`40`	`+`
`44`	`41`	`}`
	`42`	`+ walls.Remove(_wall);`
`45`	`43`	`}`
`46`	`44`
`47`	`45`	`//随机选择迷宫起点终点`
`@@ -59,9 +57,13 @@ private static void AddNerabyWall(WallArea area)`
`59`	`57`	`{`
`60`	`58`	`List<WallArea> areas = GetNearbyArea(area);`
`61`	`59`	`for (int i = 0; i < areas.Count; ++i)`
`62`		`- walls.Add(new KeyValuePair<WallArea, WallArea>(`
`63`		`- area, areas[i]`
`64`		`- ));`
	`60`	`+ walls.Add`
	`61`	`+ (`
	`62`	`+ new KeyValuePair<WallArea, WallArea>`
	`63`	`+ (`
	`64`	`+ area, areas[i]`
	`65`	`+ )`
	`66`	`+ );`
`65`	`67`	`}`
`66`	`68`
`67`	`69`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public bool Union(int a, int b)`
`30`	`30`
`31`	`31`	`}`
`32`	`32`
`33`		`- int root(int a)`
	`33`	`+ private int root(int a)`
`34`	`34`	`{`
`35`	`35`	`if (parents[a] == a)`
`36`	`36`	`return a;`