Added spatial partition pattern

Author: Habrador

Assets/Patterns/19. Spatial Partition/Grid/Ground.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Ground
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.5283019, g: 0.5283019, b: 0.5283019, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/Patterns/19. Spatial Partition/Grid/Ground.mat.meta

@@ -5,18 +5,70 @@
 namespace SpatialPartition.Grid
 {
     //Implementation of the Spatial Partion pattern from the book Game Programming Patterns
+    //The units change color if the can fight each other, and that color remains for some time to see that its working
     public class GameController : MonoBehaviour
     {
+        //Drags
+        public GameObject battlefieldObj;
+
+        public Unit unitPrefab;
+
+        public Transform unitParentTrans;
+
+        //Private
+        private Grid grid;
+
+        //The number of units we start with
+        private const int NUMBER_OF_UNITS = 100;
+
+        //To keep track of all units so we can move them
+        private HashSet<Unit> allUnits = new HashSet<Unit>();
+
+
 
         void Start()
         {
+            grid = new Grid();
+
+
+            //Make the battlefield the same size as the grid
+            float battlefieldWidth = Grid.NUM_CELLS * Grid.CELL_SIZE;
 
+            battlefieldObj.transform.localScale = new Vector3(battlefieldWidth, 1f, battlefieldWidth);
+
+            //The grid starts at origo, so we need to change position as well
+            battlefieldObj.transform.position = new Vector3(battlefieldWidth * 0.5f, 0f, battlefieldWidth * 0.5f);
+
+
+            //Add units within the grid at random positions
+            for (int i = 0; i < NUMBER_OF_UNITS; i++)
+            {
+                float randomX = Random.Range(0f, battlefieldWidth);
+                float randomZ = Random.Range(0f, battlefieldWidth);
+
+                Vector3 randomPos = new Vector3(randomX, 0f, randomZ);
+
+                Unit newUnit = Instantiate(unitPrefab, parent: unitParentTrans) as Unit;
+
+                //Init the unit which will also add it to the grid
+                newUnit.InitUnit(grid, randomPos);
+
+                allUnits.Add(newUnit);
+            }
         }
 
 
+
         void Update()
         {
+            //Move all units
+            foreach (Unit unit in allUnits)
+            {
+                unit.Move(Time.deltaTime);
+            }
 
+            //Units attack each other
+            grid.HandleMelee();
         }
     }
 }

Assets/Patterns/19. Spatial Partition/Grid/Scripts/GameController.cs

@@ -9,12 +9,12 @@ public class Grid
     {
         public const int NUM_CELLS = 10;
 
-        public const int CELL_SIZE = 20;
+        public const int CELL_SIZE = 5;
 
         private Unit[,] cells = new Unit[NUM_CELLS, NUM_CELLS];
 
-        //If two units are within this distance they can attack each other
-        private const float ATTACK_DISTANCE = 0.5f;
+        //How many units do we have on the grid, which should be faster than to iterate through all cells and count them
+        public int unitCount { get; private set; }
 
 
 
@@ -34,7 +34,7 @@ public Grid()
 
         //Add unit to grid
         //This is also used when a unit already on the grid is moving into a new cell
-        public void Add(Unit newUnit)
+        public void Add(Unit newUnit, bool isNewUnit = false)
         {
             //Determine which grid cell it's in
             Vector2Int cellPos = ConvertFromWorldToCell(newUnit.transform.position);
@@ -53,23 +53,25 @@ public void Add(Unit newUnit)
 
                 nextUnit.prev = newUnit;
             }
+
+            if (isNewUnit)
+            {
+                unitCount += 1;
+            }
         }
 
 
 
-        //Move a unit on the grid
-        public void Move(Unit unit, Vector3 newPos)
+        //Move a unit on the grid = see if it has changed cell
+        //Make sure newPos is a valid position inside of the grid
+        public void Move(Unit unit, Vector3 oldPos, Vector3 newPos)
         {
-            //See what cell it was in
-            Vector2Int oldCellPos = ConvertFromWorldToCell(unit.transform.position);
+            //See what cell it was in before we assign the new position
+            Vector2Int oldCellPos = ConvertFromWorldToCell(oldPos);
 
             //See which cell it's moving to
             Vector2Int newCellPos = ConvertFromWorldToCell(newPos);
 
-            //TODO: Validate if this is a valid cell pos
-            
-            unit.transform.position = newPos;
-
             //If it didn't change cell, we are done
             if (oldCellPos.x == newCellPos.x && oldCellPos.y == newCellPos.y)
             {
@@ -114,8 +116,15 @@ public Vector2Int ConvertFromWorldToCell(Vector3 pos)
         {
             //Dividing coordinate by cell size converts from world space to cell space
             //Casting to int converts from cell space to cell index
-            int cellX = (int)(pos.x / CELL_SIZE);
-            int cellY = (int)(pos.z / CELL_SIZE); //z instead of y because y is up in Unity's coordinate system
+            //int cellX = (int)(pos.x / CELL_SIZE);
+            //int cellY = (int)(pos.z / CELL_SIZE); //z instead of y because y is up in Unity's coordinate system
+
+            //Casting to int in C# doesnt work in same way as in C++ so we have to use FloorToInt instead
+            //It works like this if cell size is 2:
+            //pos.x is 1.8, then cellX will be 1.8/2 = 0.9 -> 0
+            //pos.x is 2.1, then cellX will be 2.1/2 = 1.05 -> 1
+            int cellX = Mathf.FloorToInt(pos.x / CELL_SIZE);
+            int cellY = Mathf.FloorToInt(pos.z / CELL_SIZE); //z instead of y because y is up in Unity's coordinate system
 
             Vector2Int cellPos = new Vector2Int(cellX, cellY);
 
@@ -124,6 +133,23 @@ public Vector2Int ConvertFromWorldToCell(Vector3 pos)
 
 
 
+        //Test if a position is a valid position (= is inside of the grid)
+        public bool IsPosValid(Vector3 pos)
+        {
+            Vector2Int cellPos = ConvertFromWorldToCell(pos);
+
+            if (cellPos.x >= 0 && cellPos.x < NUM_CELLS && cellPos.y >= 0 && cellPos.y < NUM_CELLS)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+
+
         //
         // Fighting
         //
@@ -136,17 +162,17 @@ public void HandleMelee()
             {
                 for (int y = 0; y < NUM_CELLS; y++)
                 {
-                    HandleCell(new Vector2Int(x, y));
+                    HandleCell(x, y);
                 }
             }
         }
 
 
 
         //Handles fight for a single cell
-        private void HandleCell(Vector2Int cellPos)
+        private void HandleCell(int x, int y)
         {
-            Unit unit = cells[cellPos.x, cellPos.y];
+            Unit unit = cells[x, y];
 
             //Make each unit fight all other units once in this cell
             //It works like this: If the units in the cell are linked like: A-B-C-D
@@ -164,21 +190,21 @@ private void HandleCell(Vector2Int cellPos)
                 //But we cant check all 8 cells because then some units might fight each other two times, so we only check half (it doesnt matter which half)
                 //We also have to check that there's a surrounding cell because the current cell might be the border
                 //This assumes attack distance is less than cell size, or we might have to check more cells
-                if (cellPos.x > 0 && cellPos.y > 0)
+                if (x > 0 && y > 0)
                 {
-                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y - 1]);
+                    HandleUnit(unit, cells[x - 1, y - 1]);
                 }
-                if (cellPos.x > 0)
+                if (x > 0)
                 {
-                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y - 0]);
+                    HandleUnit(unit, cells[x - 1, y - 0]);
                 }
-                if (cellPos.y > 0)
+                if (y > 0)
                 {
-                    HandleUnit(unit, cells[cellPos.x - 0, cellPos.y - 1]);
+                    HandleUnit(unit, cells[x - 0, y - 1]);
                 }
-                if (cellPos.x > 0 && cellPos.y < NUM_CELLS - 1)
+                if (x > 0 && y < NUM_CELLS - 1)
                 {
-                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y + 1]);
+                    HandleUnit(unit, cells[x - 1, y + 1]);
                 }
 
                 unit = unit.next;
@@ -187,13 +213,13 @@ private void HandleCell(Vector2Int cellPos)
 
 
 
-        //Handles fight for a single unit versus a linked-list of units
+        //Handles fight for a single unit vs a linked-list of units
         private void HandleUnit(Unit unit, Unit other)
         {
             while (other != null)
             {
                 //Make them fight if they have similar position - use square distance because it's faster
-                if ((unit.transform.position - other.transform.position).sqrMagnitude < ATTACK_DISTANCE * ATTACK_DISTANCE)
+                if ((unit.transform.position - other.transform.position).sqrMagnitude < Unit.ATTACK_DISTANCE * Unit.ATTACK_DISTANCE)
                 {
                     HandleAttack(unit, other);
                 }
@@ -208,7 +234,8 @@ private void HandleUnit(Unit unit, Unit other)
         private void HandleAttack(Unit one, Unit two)
         {
             //Insert fighting mechanic
-            Debug.Log("Two units are fighting! monkaS");
+            one.StartFighting();
+            two.StartFighting();
         }
     }
 }