Added more code comments

atalantus · atalantus · commit 57d04bd77e09 · 2019-12-12T05:14:38.000+01:00
diff --git a/Assets/Scripts/Level Generation/Cell.cs b/Assets/Scripts/Level Generation/Cell.cs
@@ -19,7 +19,7 @@ public class Cell : MonoBehaviour, IHeapItem<Cell>
         /// <summary>
         /// Was the module object already instantiated
         /// </summary>
-        private bool isCellSet;
+        private bool _isCellSet;
 
         /// <summary>
         /// Holds the indices of the still possible modules
@@ -85,6 +85,7 @@ public void FilterCell(EdgeFilter edgeFilter)
                 RemoveModule(removingModules[i]);
             }
 
+            // Check if the cell has only one possible module left
             CheckSetCell();
         }
 
@@ -150,6 +151,10 @@ public void SimpleRemoveModule(int moduleIndex)
             LevelGenerator.Instance.OrderedCells.UpdateItem(this);
         }
 
+        /// <summary>
+        /// Force assigns this cell one specific module and automatically removes all other possibilities.
+        /// </summary>
+        /// <param name="moduleIndex">The module to assign</param>
         public void SetSpecialModule(int moduleIndex)
         {
             possibleModulesIndices = new List<int> {moduleIndex};
@@ -181,9 +186,12 @@ public void SetSpecialModule(int moduleIndex)
             var newModule = Instantiate(module.moduleGO, transform.position,
                 Quaternion.identity, transform);
 
-            isCellSet = true;
+            _isCellSet = true;
         }
 
+        /// <summary>
+        /// Checks if the cell is solved
+        /// </summary>
         private void CheckSetCell()
         {
             // Only set cell if one final module is left
@@ -200,17 +208,17 @@ private void SetCell()
         {
             //Debug.Log("Set cell!", gameObject);
             
-            if (isCellSet) return;
+            if (_isCellSet) return;
 
             var newModule = Instantiate(ModuleManager.Instance.modules[possibleModulesIndices[0]].moduleGO,
                 transform.position,
                 Quaternion.identity, transform);
 
-            isCellSet = true;
+            _isCellSet = true;
         }
 
         /// <summary>
-        /// Compares two cells.
+        /// Compares two cells using their solved score
         /// </summary>
         /// <param name="other">Cell to compare</param>
         /// <returns></returns>
diff --git a/Assets/Scripts/Level Generation/Grid.cs b/Assets/Scripts/Level Generation/Grid.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace LevelGeneration
 {
@@ -28,7 +29,7 @@ public class Grid : MonoBehaviour
         /// <summary>
         /// Cells matrix ([width, height])
         /// </summary>
-        public Cell[,] _cells;
+        public Cell[,] cells;
 
         /// <summary>
         /// <see cref="LevelGenerator"/>
@@ -47,15 +48,18 @@ private void Awake()
             GenerateGrid();
 
             // Wave-function-collapse algorithm
-            _levelGenerator.GenerateLevelWFC(ref _cells, seed != -1 ? seed : Environment.TickCount);
+            _levelGenerator.GenerateLevelWFC(ref cells, seed != -1 ? seed : Environment.TickCount);
         }
 
+        /// <summary>
+        /// Generates the two-dimensional grid
+        /// </summary>
         public void GenerateGrid()
         {
             if (width > 0 && height > 0)
             {
                 // Generate grid
-                _cells = new Cell[width, height];
+                cells = new Cell[width, height];
 
                 var scale = cellPrefab.transform.localScale;
                 var origin = transform.position;
@@ -73,14 +77,14 @@ public void GenerateGrid()
                     var cellObj = Instantiate(cellPrefab, curPos, Quaternion.identity, gameObject.transform);
                     cellObj.name = $"({i}, {j})";
                     var cell = cellObj.GetComponent<Cell>();
-                    _cells[i, j] = cell;
+                    cells[i, j] = cell;
                 }
 
                 // Assign neighbours for every cell
                 for (int i = 0; i < width; i++)
                 for (int j = 0; j < height; j++)
                 {
-                    var cell = _cells[i, j];
+                    var cell = cells[i, j];
                     for (int k = 0; k < 4; k++)
                     {
                         int x = -1, y = -1;
@@ -112,7 +116,7 @@ public void GenerateGrid()
                         }
                         else
                         {
-                            cell.neighbourCells[k] = _cells[x, y];
+                            cell.neighbourCells[k] = cells[x, y];
                         }
                     }
                 }
@@ -123,6 +127,9 @@ public void GenerateGrid()
             }
         }
 
+        /// <summary>
+        /// Destroys the current grid
+        /// </summary>
         public void RemoveGrid()
         {
             foreach (Transform child in gameObject.transform)
@@ -134,10 +141,10 @@ public void RemoveGrid()
         /// <summary>
         /// Checks if the grid is valid
         /// </summary>
-        /// <returns></returns>
+        /// <returns>true if the grid is valid</returns>
         public bool CheckGrid()
         {
-            var notMatchingCells = _levelGenerator.CheckGeneratedLevel(ref _cells);
+            var notMatchingCells = _levelGenerator.CheckGeneratedLevel(ref cells);
 
             return notMatchingCells.Count == 0;
         }
diff --git a/Assets/Scripts/Level Generation/LevelGenerator.cs b/Assets/Scripts/Level Generation/LevelGenerator.cs
@@ -18,6 +18,9 @@ public class LevelGenerator
         /// </summary>
         public static LevelGenerator Instance => _instance ?? (_instance = new LevelGenerator());
 
+        /// <summary>
+        /// Stores the cells in a heap having the closest cell to being solved as first element
+        /// </summary>
         public Heap<Cell> OrderedCells;
 
         private LevelGenerator()
@@ -26,7 +29,7 @@ private LevelGenerator()
 
         /// <summary>
         /// Wave-function-collapse algorithm
-        /// TODO: Multithreading?
+        /// TODO: Could be multithreaded to increase performance
         /// </summary>
         /// <param name="cells">The grid`s cells</param>
         /// <param name="seed">RNG seed</param>
@@ -51,8 +54,10 @@ public void GenerateLevelWFC(ref Cell[,] cells, int seed)
 
             Debug.LogWarning("Start Wave-function-collapse algorithm");
 
+            // Make sure the level fits our initial constraints
             ApplyInitialConstraints(ref cells);
 
+            // Wave-function-collapse Algorithm
             while (true)
             {
                 //Debug.Log("Starting another iteration! Removing next module.");
@@ -196,7 +201,7 @@ private void BorderOutsideConstraint(ref Cell[,] cells)
         }
 
         /// <summary>
-        /// Initial constraint: Place start and goal module
+        /// Initial constraint: Place one start and one goal module
         /// </summary>
         /// <param name="cells">The grid`s cells</param>
         private void StartGoalConstraint(ref Cell[,] cells)
diff --git a/Assets/Scripts/Other/MainUI.cs b/Assets/Scripts/Other/MainUI.cs
@@ -22,7 +22,7 @@ public void Generate()
 
         grid.RemoveGrid();
         grid.GenerateGrid();
-        LevelGenerator.Instance.GenerateLevelWFC(ref grid._cells, grid.seed != -1 ? grid.seed : Environment.TickCount);
+        LevelGenerator.Instance.GenerateLevelWFC(ref grid.cells, grid.seed != -1 ? grid.seed : Environment.TickCount);
         
         cameraController.AdjustCamera(grid.width, grid.height);
         
diff --git a/README.md b/README.md
@@ -1,15 +1,15 @@
 # Wave-function-collapse algorithm with Unity
-This Unity example project utilizes the wave-function-collapse algorithm to procedurally generate levels.
+This Unity example project utilizes the wave-function-collapse algorithm to procedurally generate levels on a two-dimensional grid.
 
-![Demo image](./images/Demo0.png)
+[![Demo image](./images/Demo0.png)](https://www.atalantus.de/projects/games/wfc/index.html)
 
 ## About this project
 Using Unity version `2019.1.14f1`.
 
-**TODO**
+### [Try it out!](https://www.atalantus.de/projects/games/wfc/index.html)
 
 ## Resources
-Special thanks to [Oskar Stålberg](https://twitter.com/OskSta) for [his talk](https://www.youtube.com/watch?v=0bcZb-SsnrA) about this algorithm and it's implementation in the game Bad North.
+Special credits to [Oskar Stålberg](https://twitter.com/OskSta) for [his talk](https://www.youtube.com/watch?v=0bcZb-SsnrA) about this algorithm and it's implementation in the game Bad North.
 If you want to learn more about the algorithm go check it out.
 
 Other helpful resources about WFC:

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Collections;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using UnityEngine;`
	`5`	`+using UnityEngine.Serialization;`
`5`	`6`
`6`	`7`	`namespace LevelGeneration`
`7`	`8`	`{`
`@@ -28,7 +29,7 @@ public class Grid : MonoBehaviour`
`28`	`29`	`/// <summary>`
`29`	`30`	`/// Cells matrix ([width, height])`
`30`	`31`	`/// </summary>`
`31`		`- public Cell[,] _cells;`
	`32`	`+ public Cell[,] cells;`
`32`	`33`
`33`	`34`	`/// <summary>`
`34`	`35`	`/// <see cref="LevelGenerator"/>`
`@@ -47,15 +48,18 @@ private void Awake()`
`47`	`48`	`GenerateGrid();`
`48`	`49`
`49`	`50`	`// Wave-function-collapse algorithm`
`50`		`- _levelGenerator.GenerateLevelWFC(ref _cells, seed != -1 ? seed : Environment.TickCount);`
	`51`	`+ _levelGenerator.GenerateLevelWFC(ref cells, seed != -1 ? seed : Environment.TickCount);`
`51`	`52`	`}`
`52`	`53`
	`54`	`+ /// <summary>`
	`55`	`+ /// Generates the two-dimensional grid`
	`56`	`+ /// </summary>`
`53`	`57`	`public void GenerateGrid()`
`54`	`58`	`{`
`55`	`59`	`if (width > 0 && height > 0)`
`56`	`60`	`{`
`57`	`61`	`// Generate grid`
`58`		`- _cells = new Cell[width, height];`
	`62`	`+ cells = new Cell[width, height];`
`59`	`63`
`60`	`64`	`var scale = cellPrefab.transform.localScale;`
`61`	`65`	`var origin = transform.position;`
`@@ -73,14 +77,14 @@ public void GenerateGrid()`
`73`	`77`	`var cellObj = Instantiate(cellPrefab, curPos, Quaternion.identity, gameObject.transform);`
`74`	`78`	`cellObj.name = $"({i}, {j})";`
`75`	`79`	`var cell = cellObj.GetComponent<Cell>();`
`76`		`- _cells[i, j] = cell;`
	`80`	`+ cells[i, j] = cell;`
`77`	`81`	`}`
`78`	`82`
`79`	`83`	`// Assign neighbours for every cell`
`80`	`84`	`for (int i = 0; i < width; i++)`
`81`	`85`	`for (int j = 0; j < height; j++)`
`82`	`86`	`{`
`83`		`- var cell = _cells[i, j];`
	`87`	`+ var cell = cells[i, j];`
`84`	`88`	`for (int k = 0; k < 4; k++)`
`85`	`89`	`{`
`86`	`90`	`int x = -1, y = -1;`
`@@ -112,7 +116,7 @@ public void GenerateGrid()`
`112`	`116`	`}`
`113`	`117`	`else`
`114`	`118`	`{`
`115`		`- cell.neighbourCells[k] = _cells[x, y];`
	`119`	`+ cell.neighbourCells[k] = cells[x, y];`
`116`	`120`	`}`
`117`	`121`	`}`
`118`	`122`	`}`
`@@ -123,6 +127,9 @@ public void GenerateGrid()`
`123`	`127`	`}`
`124`	`128`	`}`
`125`	`129`
	`130`	`+ /// <summary>`
	`131`	`+ /// Destroys the current grid`
	`132`	`+ /// </summary>`
`126`	`133`	`public void RemoveGrid()`
`127`	`134`	`{`
`128`	`135`	`foreach (Transform child in gameObject.transform)`
`@@ -134,10 +141,10 @@ public void RemoveGrid()`
`134`	`141`	`/// <summary>`
`135`	`142`	`/// Checks if the grid is valid`
`136`	`143`	`/// </summary>`
`137`		`- /// <returns></returns>`
	`144`	`+ /// <returns>true if the grid is valid</returns>`
`138`	`145`	`public bool CheckGrid()`
`139`	`146`	`{`
`140`		`- var notMatchingCells = _levelGenerator.CheckGeneratedLevel(ref _cells);`
	`147`	`+ var notMatchingCells = _levelGenerator.CheckGeneratedLevel(ref cells);`
`141`	`148`
`142`	`149`	`return notMatchingCells.Count == 0;`
`143`	`150`	`}`