Started adding spatial partition

Author: Habrador

Assets/Patterns/19. Spatial Partition.meta

@@ -0,0 +1,22 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace SpatialPartition.Grid
+{
+    //Implementation of the Spatial Partion pattern from the book Game Programming Patterns
+    public class GameController : MonoBehaviour
+    {
+
+        void Start()
+        {
+
+        }
+
+
+        void Update()
+        {
+
+        }
+    }
+}

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

@@ -0,0 +1,214 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace SpatialPartition.Grid
+{
+    //The grid class which will also handle fighting
+    public class Grid
+    {
+        public const int NUM_CELLS = 10;
+
+        public const int CELL_SIZE = 20;
+    
+        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;
+
+
+
+        public Grid()
+        {
+            //Clear the grid
+            for (int x = 0; x < NUM_CELLS; x++)
+            {
+                for (int y = 0; y < NUM_CELLS; y++)
+                {
+                    cells[x, y] = null;
+                }
+            }
+        }
+
+
+
+        //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)
+        {
+            //Determine which grid cell it's in
+            Vector2Int cellPos = ConvertFromWorldToCell(newUnit.transform.position);
+
+            //Add the unit to the front of list for the cell it's in
+            newUnit.prev = null;
+            newUnit.next = cells[cellPos.x, cellPos.y];
+
+            //Associate the cell with this unit
+            cells[cellPos.x, cellPos.y] = newUnit;
+
+            //If there already was a unit in this cell, it should point to the new unit
+            if (newUnit.next != null)
+            {
+                Unit nextUnit = newUnit.next;
+                
+                nextUnit.prev = newUnit;
+            }
+        }
+
+
+
+        //Move a unit on the grid
+        public void Move(Unit unit, Vector3 newPos)
+        {
+            //See what cell it was in
+            Vector2Int oldCellPos = ConvertFromWorldToCell(unit.transform.position);
+
+            //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)
+            {
+                return;
+            }
+
+            //Unlink it from the list of its old cell
+            UnlinkUnit(unit);
+
+            //If this unit is the head of a linked-list in this cell, remove it
+            if (cells[oldCellPos.x, oldCellPos.y] == unit)
+            {
+                cells[oldCellPos.x, oldCellPos.y] = unit.next;
+            }
+
+            //Add it back to the grid at its new cell
+            Add(unit);
+        }
+
+
+
+        //Unlink a unit from its linked list
+        private void UnlinkUnit(Unit unit)
+        {
+            if (unit.prev != null)
+            {
+                //The previous unit should get a new next
+                unit.prev.next = unit.next;
+            }
+
+            if (unit.next != null)
+            {
+                //The next unit should get a new prev
+                unit.next.prev = unit.prev;
+            }            
+        }
+
+
+
+        //Help method to convert from Vector3 to cell pos
+        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
+
+            Vector2Int cellPos = new Vector2Int(cellX, cellY);
+
+            return cellPos;
+        }
+
+
+
+        //
+        // Fighting
+        //
+
+        //Make the units fight
+        public void HandleMelee()
+        {
+            //Loop through all cells
+            for (int x = 0; x < NUM_CELLS; x++)
+            {
+                for (int y = 0; y < NUM_CELLS; y++)
+                {
+                    HandleCell(new Vector2Int(x, y));
+                }
+            }
+        }
+
+
+
+        //Handles fight for a single cell
+        private void HandleCell(Vector2Int cellPos)
+        {
+            Unit unit = cells[cellPos.x, cellPos.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
+            //We always start with the first unit A, which we get from the cells[x, y]
+            //Loop 1: A vs B, C, D. Change to unit B
+            //Loop 2: B vs C, D. Change to unit C. (A-B where fighting in round 1, so they dont need to fight again)
+            //Loop 3: C vs D. Change to unit D (C-A and C-B have already been fighting)
+            //Loop 4: unit will be null so the loop will terminate
+            while (unit != null)
+            {
+                //Try to fight other units in this cell
+                HandleUnit(unit, unit.next);
+
+                //We also should try to fight units in the 8 surrounding cells because some of them might be within the attack distance
+                //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)
+                {
+                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y - 1]);
+                }
+                if (cellPos.x > 0)
+                {
+                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y - 0]);
+                }
+                if (cellPos.y > 0)
+                {
+                    HandleUnit(unit, cells[cellPos.x - 0, cellPos.y - 1]);
+                }
+                if (cellPos.x > 0 && cellPos.y < NUM_CELLS - 1)
+                {
+                    HandleUnit(unit, cells[cellPos.x - 1, cellPos.y + 1]);
+                }
+
+                unit = unit.next;
+            }
+        }
+
+
+
+        //Handles fight for a single unit versus 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)
+                {
+                    HandleAttack(unit, other);
+                }
+
+                other = other.next;
+            }
+        }
+
+        
+
+        //Handles attack between two units
+        private void HandleAttack(Unit one, Unit two)
+        {
+            //Insert fighting mechanic
+            Debug.Log("Two units are fighting! monkaS");
+        }
+    }
+}

Assets/Patterns/19. Spatial Partition/Grid/Scripts.meta

@@ -0,0 +1,67 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace SpatialPartition.Grid
+{
+    //Code for one unit on a grid
+    public class Unit : MonoBehaviour
+    {
+        //The body is child to an empty game object
+        public GameObject unitBody;
+    
+        private Grid grid;
+
+        //Pointers to other units so we can put them in a doubly-linked-list
+        //We dont want these to show up in the inspector
+        [System.NonSerialized] public Unit prev;
+        [System.NonSerialized] public Unit next;
+
+        //So we can change the unit's color
+        private MeshRenderer meshRenderer;
+
+        private Color unitColor;
+
+
+
+        public void InitUnit(Grid grid, Vector3 startPos)
+        {
+            this.grid = grid;
+
+            transform.position = startPos;
+
+            prev = null;
+            next = null;
+
+            //Add the unit to the grid
+            grid.Add(this);
+
+            meshRenderer = unitBody.GetComponent<MeshRenderer>();
+
+            //Give it a random color
+            unitColor = new Color(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f), 1f);
+
+            LookingForFight();
+        }
+        
+
+        public void Move(Vector3 newPos)
+        {
+            //transform.position = newPos;
+
+            grid.Move(this, newPos);
+        }
+
+
+        //To see that the unit is fighting we change the color
+        public void Fight()
+        {
+            meshRenderer.sharedMaterial.color = Color.red;
+        }
+
+        public void LookingForFight()
+        {
+            meshRenderer.sharedMaterial.color = unitColor;
+        }
+    }
+}