@@ -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}

@@ -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();
 }
 }
 }

@@ -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();
 }
 }
 }