update

Assets/Scripts/GameSetup/Maze/MazeManager.cs

@@ -37,13 +37,25 @@ namespace Hallucinate.GameSetup.Maze
         [PropertyRange(5, 200)]
         [SerializeField] private int depth = 30;
         
-        [BoxGroup("Debug")]
-        [SerializeField] private bool debugMode = true;
+        [BoxGroup("Animation")]
+        [SerializeField] private bool animateGeneration = true;
 
-        [BoxGroup("Debug")]
-        [ShowIf(nameof(debugMode))]
-        [PropertyRange(0.001f, 0.5f)]
-        [SerializeField] private float visualizationInterval = 0.05f;
+        [BoxGroup("Animation")]
+        [ShowIf(nameof(animateGeneration))]
+        [PropertyRange(1, 500)]
+        [LabelText("Generation Speed (Cells/Frame)")]
+        [SerializeField] private int generationSpeed = 50;
+
+        public static int cellsProcessedThisFrame;
+
+        [BoxGroup("Animation")]
+        [ShowIf(nameof(animateGeneration))]
+        public MazeRenderer.CellAnimationType cellAnimationType = MazeRenderer.CellAnimationType.ScaleUp;
+
+        [BoxGroup("Progress")]
+        [ProgressBar(0, 100)]
+        [ShowInInspector, ReadOnly]
+        private float completionPercentage;
 
         [BoxGroup("References")]
         [Required]
@@ -74,6 +86,7 @@ namespace Hallucinate.GameSetup.Maze
 
         private MazeGrid _grid;
         private Coroutine _generationCoroutine;
+        private HashSet<Vector3Int> _modifiedCells = new HashSet<Vector3Int>();
 
         private void Start()
         {
@@ -88,6 +101,25 @@ namespace Hallucinate.GameSetup.Maze
             }
         }
 
+        [ContextMenu("Clear Maze")]
+        [Button("Clear Maze", ButtonSizes.Large)]
+        public void ClearMaze()
+        {
+            if (_generationCoroutine != null)
+            {
+                StopCoroutine(_generationCoroutine);
+                _generationCoroutine = null;
+            }
+
+            if (mazeRenderer != null)
+            {
+                mazeRenderer.Clear();
+            }
+
+            completionPercentage = 0f;
+            _modifiedCells?.Clear();
+        }
+
         [ContextMenu("Regenerate")]
         [Button("Regenerate Maze", ButtonSizes.Large)]
         public void Regenerate()
@@ -109,24 +141,85 @@ namespace Hallucinate.GameSetup.Maze
                 mazes = new MazeGrid[1];
             }
 
-            if (_generationCoroutine != null)
+            ClearMaze();
+
+            mazeRenderer.currentAnimationType = cellAnimationType;
+
+            if (animateGeneration)
             {
-                StopCoroutine(_generationCoroutine);
+                _generationCoroutine = StartCoroutine(GenerateMazeRoutine());
             }
+            else
+            {
+                GenerateMazeInstant();
+            }
+        }
 
-            mazeRenderer.Clear();
+        private void GenerateMazeInstant()
+        {
+            _modifiedCells.Clear();
+            completionPercentage = 0f;
 
-            // Step 1: Initialize all maze floors
             for (int i = 0; i < mazes.Length; i++)
             {
                 mazes[i] = new MazeGrid(width, depth);
                 mazes[i].Level = i;
                 
-                // Generate each floor using the selected algorithm
                 IMazeAlgorithm algorithmForFloor = GetAlgorithm(selectedAlgorithm);
                 algorithmForFloor.Generate(mazes[i]);
             }
 
+            GenerateConnections();
+
+            for (int i = 0; i < mazes.Length; i++)
+            {
+                mazeRenderer.Initialize(mazes[i], mazeContainer, i == 0);
+            }
+            if (mazes.Length > 0) _grid = mazes[0];
+
+            completionPercentage = 100f;
+        }
+
+        private IEnumerator GenerateMazeRoutine()
+        {
+            _modifiedCells.Clear();
+            completionPercentage = 0f;
+
+            for (int i = 0; i < mazes.Length; i++)
+            {
+                mazes[i] = new MazeGrid(width, depth);
+                mazes[i].Level = i;
+                int floorIndex = i;
+
+                mazes[i].OnCellChanged += (x, z, type) => 
+                {
+                    if (type != MazeCellType.Wall)
+                    {
+                        _modifiedCells.Add(new Vector3Int(x, floorIndex, z));
+                        int totalCells = width * depth * mazes.Length;
+                        // Approximate the progress to reach roughly 100% since algorithms don't visit all cells
+                        float fillRatio = 0.6f; 
+                        completionPercentage = Mathf.Clamp((_modifiedCells.Count / ((float)totalCells * fillRatio)) * 100f, 0, 99f);
+                    }
+                };
+
+                mazeRenderer.Initialize(mazes[i], mazeContainer, i == 0);
+                
+                IMazeAlgorithm algorithmForFloor = GetAlgorithm(selectedAlgorithm);
+                cellsProcessedThisFrame = 0;
+                yield return StartCoroutine(algorithmForFloor.GenerateStepByStep(mazes[i], generationSpeed));
+            }
+
+            GenerateConnections();
+
+            if (mazes.Length > 0) _grid = mazes[0];
+
+            completionPercentage = 100f;
+            _generationCoroutine = null;
+        }
+
+        private void GenerateConnections()
+        {
             // Step 2: Create connections between adjacent floors
             for (int i = 0; i < mazes.Length - 1; i++)
             {
@@ -167,35 +260,8 @@ namespace Hallucinate.GameSetup.Maze
                     connectionsMade++;
                 }
             }
-
-            // Step 3: Render all floors
-            if (mazes.Length > 0)
-            {
-                for (int i = 0; i < mazes.Length; i++)
-                {
-                    mazeRenderer.Initialize(mazes[i], mazeContainer, i == 0);
-                }
-                _grid = mazes[0];
-            }
-            else
-            {
-                // _grid = new MazeGrid(width, depth);
-                // mazeRenderer.Initialize(_grid, mazeContainer);
-
-                IMazeAlgorithm algorithm = GetAlgorithm(selectedAlgorithm);
-                
-                if (debugMode)
-                {
-                    _generationCoroutine = StartCoroutine(algorithm.GenerateStepByStep(_grid, visualizationInterval));
-                }
-                else
-                {
-                    algorithm.Generate(_grid);
-                }
-                _grid = new MazeGrid(width, depth);
-                mazeRenderer.Initialize(_grid, mazeContainer);
-            }
         }
+
         private void ShuffleList<T>(List<T> list)
         {
             for (int i = 0; i < list.Count; i++)