Multi-Floors LevelGrid

Assets/Scenes/GameScene_MultiFloors.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 33055f3c15d93c4a8a0245cf9546b0ba
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Actions/GrenadeAction.cs

@@ -30,7 +30,7 @@ namespace Actions {
             GridPosition unitGridPosition = Unit.GridPosition;
             for (int x = -maxThrowDistance; x <= maxThrowDistance; x++) {
                 for (int z = -maxThrowDistance; z <= maxThrowDistance; z++) {
-                    GridPosition offsetGridPosition = new(x, z);
+                    GridPosition offsetGridPosition = new(x, z, 0);
                     GridPosition testGridPosition = unitGridPosition + offsetGridPosition;
 
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions

Assets/Scripts/Actions/InteractAction.cs

@@ -23,7 +23,7 @@ namespace Actions {
             GridPosition unitGridPosition = Unit.GridPosition;
             for (int x = -MaxInteractDistance; x <= MaxInteractDistance; x++) {
                 for (int z = -MaxInteractDistance; z <= MaxInteractDistance; z++) {
-                    GridPosition offsetGridPosition = new(x, z);
+                    GridPosition offsetGridPosition = new(x, z, 0);
                     GridPosition testGridPosition = unitGridPosition + offsetGridPosition;
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions
                     if (LevelGrid.Instance.GetInteractableAtGridPosition(testGridPosition) is null) continue; //No Interactable on this GridPosition

Assets/Scripts/Actions/MoveAction.cs

@@ -9,14 +9,14 @@ namespace Actions {
         private const float moveSpeed = 4f;
         private const float rotationSpeed = 10f;
         private const float stoppingDistance = 0.1f;
-        [FormerlySerializedAs("MaxMoveDistance")] [SerializeField] private int maxMoveDistance = 4;
-        private List<Vector3> PositionList { get; set; }
-        private int currentPositionIndex;
         private const int pathfindingDistanceMultiplier = 10;
 
-        public event EventHandler OnStartMoving;
-        public event EventHandler OnStopMoving;
-       
+        [FormerlySerializedAs("MaxMoveDistance")] [SerializeField]
+        private int maxMoveDistance = 4;
+
+        private int currentPositionIndex;
+        private List<Vector3> PositionList { get; set; }
+
 
         protected override void Awake() {
             base.Awake();
@@ -30,7 +30,8 @@ namespace Actions {
 
             transform.forward = Vector3.Lerp(transform.forward, moveDirection, rotationSpeed * Time.deltaTime); //Rotate towards targetPosition
 
-            if (Vector3.Distance(targetPosition, Unit.GetWorldPosition()) > stoppingDistance) { //Move towards targetPosition
+            if (Vector3.Distance(targetPosition, Unit.GetWorldPosition()) > stoppingDistance) {
+                //Move towards targetPosition
                 transform.position += moveSpeed * Time.deltaTime * moveDirection;
             }
             else {
@@ -39,16 +40,18 @@ namespace Actions {
                 OnStopMoving?.Invoke(this, EventArgs.Empty);
                 ActionComplete();
             }
-
         }
 
+        public event EventHandler OnStartMoving;
+        public event EventHandler OnStopMoving;
+
         public override List<GridPosition> GetValidActionGridPositionList() {
             List<GridPosition> validGridPositionList = new();
             GridPosition unitGridPosition = Unit.GridPosition;
-            
+
             for (int x = -maxMoveDistance; x <= maxMoveDistance; x++) {
                 for (int z = -maxMoveDistance; z <= maxMoveDistance; z++) {
-                    GridPosition offsetGridPosition = new(x, z);
+                    GridPosition offsetGridPosition = new(x, z, 0);
                     GridPosition testGridPosition = unitGridPosition + offsetGridPosition;
 
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions
@@ -58,7 +61,7 @@ namespace Actions {
                     if (!Pathfinding.Instance.HasPath(unitGridPosition, testGridPosition)) continue; //No path available
 
                     if (Pathfinding.Instance.GetPathLength(unitGridPosition, testGridPosition) > maxMoveDistance * pathfindingDistanceMultiplier) continue; //Pathlength is to long
-                    
+
                     validGridPositionList.Add(testGridPosition);
                 }
             }
@@ -68,14 +71,14 @@ namespace Actions {
 
         public override void TakeAction(GridPosition gridPosition, Action onMoveCompleted) {
             List<GridPosition> pathGridPositionList = Pathfinding.Instance.FindPath(Unit.GridPosition, gridPosition, out _);
-            
+
             currentPositionIndex = 0;
             PositionList = new();
 
             foreach (GridPosition pathGridPosition in pathGridPositionList) {
                 PositionList.Add(LevelGrid.Instance.GetWorldPosition(pathGridPosition));
             }
-            
+
             OnStartMoving?.Invoke(this, EventArgs.Empty);
             ActionStart(onMoveCompleted);
         }

Assets/Scripts/Actions/ShootAction.cs

@@ -93,7 +93,7 @@ namespace Actions {
             List<GridPosition> validGridPositionList = new();
             for (int x = -MaxShootDistance; x <= MaxShootDistance; x++) {
                 for (int z = -MaxShootDistance; z <= MaxShootDistance; z++) {
-                    GridPosition offsetGridPosition = new(x, z);
+                    GridPosition offsetGridPosition = new(x, z, 0);
                     GridPosition testGridPosition = unitGridPosition + offsetGridPosition;
 
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions

Assets/Scripts/Actions/SwordAction.cs

@@ -53,7 +53,7 @@ namespace Actions {
             GridPosition unitGridPosition = Unit.GridPosition;
             for (int x = -MaxSwordDistance; x <= MaxSwordDistance; x++) {
                 for (int z = -MaxSwordDistance; z <= MaxSwordDistance; z++) {
-                    GridPosition offsetGridPosition = new(x, z);
+                    GridPosition offsetGridPosition = new(x, z, 0);
                     GridPosition testGridPosition = unitGridPosition + offsetGridPosition;
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions
                     if (!LevelGrid.Instance.HasAnyUnitOnGridPosition(testGridPosition)) continue; //Grid position is empty, no unit

Assets/Scripts/Actions/UnitActionSystem.cs

@@ -52,6 +52,7 @@ namespace Actions {
         private void Start() => SetSelectedUnit(SelectedUnit);
 
         private void Update() {
+            Debug.Log(LevelGrid.Instance.GetGridPosition(MouseWorld.GetPosition()));
             if (IsBusy) return;
             if (!TurnSystem.Instance.IsPlayerTurn) return;
             if (EventSystem.current.IsPointerOverGameObject()) return;

Assets/Scripts/Grid/GridPosition.cs

@@ -1,22 +1,24 @@
 using System;
 
 namespace Grid {
-    public struct GridPosition : IEquatable<GridPosition> {
-        public int X { get; }
-        public int Z { get; }
+    public readonly struct GridPosition : IEquatable<GridPosition> {
+        public int XPosition { get; }
+        public int ZPosition { get; }
+        public int Floor { get; }
 
-        public GridPosition(int x, int z) {
-            X = x;
-            Z = z;
+        public GridPosition(int xPosition, int zPosition, int floor) {
+            XPosition = xPosition;
+            ZPosition = zPosition;
+            Floor = floor;
         }
 
-        public override string ToString() => $"{X};{Z}";
-        public static bool operator ==(GridPosition a, GridPosition b) => a.X == b.X && a.Z == b.Z;
-        public static bool operator !=(GridPosition a, GridPosition b) => a.X != b.X || a.Z != b.Z;
-        public override bool Equals(object obj) => obj is GridPosition other && Equals(other);
-        public override int GetHashCode() => HashCode.Combine(X, Z);
-        public bool Equals(GridPosition other) => X == other.X && Z == other.Z;
-        public static GridPosition operator +(GridPosition a, GridPosition b) => new(a.X + b.X, a.Z + b.Z);
-        public static GridPosition operator -(GridPosition a, GridPosition b) => new(a.X - b.X, a.Z - b.Z);
+        public override string ToString() => $"X: {XPosition}; Z: {ZPosition}; Floor: {Floor}";
+        public static bool operator ==(GridPosition a, GridPosition b) => a.XPosition == b.XPosition && a.ZPosition == b.ZPosition && a.Floor == b.Floor;
+        public static bool operator !=(GridPosition a, GridPosition b) => a.XPosition != b.XPosition || a.ZPosition != b.ZPosition || a.Floor != b.Floor;
+        public override bool Equals(object gridPositionObject) => gridPositionObject is GridPosition gridPosition && Equals(gridPosition);
+        public override int GetHashCode() => HashCode.Combine(XPosition, ZPosition, Floor);
+        public bool Equals(GridPosition gridPosition) => XPosition == gridPosition.XPosition && ZPosition == gridPosition.ZPosition && Floor == gridPosition.Floor;
+        public static GridPosition operator +(GridPosition a, GridPosition b) => new(a.XPosition + b.XPosition, a.ZPosition + b.ZPosition, a.Floor + b.Floor);
+        public static GridPosition operator -(GridPosition a, GridPosition b) => new(a.XPosition - b.XPosition, a.ZPosition - b.ZPosition, a.Floor - b.Floor);
     }
 }

Assets/Scripts/Grid/GridSystem.cs

@@ -4,33 +4,37 @@ using Object = UnityEngine.Object;
 
 namespace Grid {
     public class GridSystem<TGridObject> {
-        private readonly float cellSize;
         private readonly TGridObject[,] gridObjectArray;
 
-        public GridSystem(int width, int height, float cellSize, Func<GridSystem<TGridObject>, GridPosition, TGridObject> createGridObject) {
+        public GridSystem(int width, int height, float cellSize, int floor, float floarHeight, Func<GridSystem<TGridObject>, GridPosition, TGridObject> createGridObject) {
             Width = width;
             Height = height;
-            this.cellSize = cellSize;
+            CellSize = cellSize;
+            Floor = floor;
+            FloorHeight = floarHeight;
 
             gridObjectArray = new TGridObject[width, height];
             for (int x = 0; x < width; x++) {
                 for (int z = 0; z < height; z++) {
-                    gridObjectArray[x, z] = createGridObject(this, new(x, z));
+                    gridObjectArray[x, z] = createGridObject(this, new(x, z, floor));
                 }
             }
         }
 
         public int Height { get; }
         public int Width { get; }
+        private float CellSize { get; }
+        private int Floor { get; }
+        private float FloorHeight { get; }
 
-        public Vector3 GetWorldPosition(GridPosition gridPosition) => new Vector3(gridPosition.X, 0, gridPosition.Z) * cellSize;
+        public Vector3 GetWorldPosition(GridPosition gridPosition) => new Vector3(gridPosition.XPosition, 0, gridPosition.ZPosition) * CellSize + new Vector3(0, gridPosition.Floor, 0) * FloorHeight;
 
-        public GridPosition GetGridPosition(Vector3 worldPosition) => new(Mathf.RoundToInt(worldPosition.x / cellSize), Mathf.RoundToInt(worldPosition.z / cellSize));
+        public GridPosition GetGridPosition(Vector3 worldPosition) => new(Mathf.RoundToInt(worldPosition.x / CellSize), Mathf.RoundToInt(worldPosition.z / CellSize), Floor);
 
         public void CreateDebugObjects(Transform debugPrefab) {
             for (int x = 0; x < Width; x++) {
                 for (int z = 0; z < Height; z++) {
-                    GridPosition gridPosition = new(x, z);
+                    GridPosition gridPosition = new(x, z, Floor);
                     Transform debugTransform = Object.Instantiate(debugPrefab, GetWorldPosition(gridPosition), Quaternion.identity);
                     GridDebugObject gridDebugObject = debugTransform.GetComponent<GridDebugObject>();
                     gridDebugObject.SetGridObject(GetGridObject(gridPosition));
@@ -38,8 +42,8 @@ namespace Grid {
             }
         }
 
-        public TGridObject GetGridObject(GridPosition gridPosition) => gridObjectArray[gridPosition.X, gridPosition.Z];
+        public TGridObject GetGridObject(GridPosition gridPosition) => gridObjectArray[gridPosition.XPosition, gridPosition.ZPosition];
 
-        public bool IsValidGridPosition(GridPosition gridPosition) => gridPosition is { X: >= 0, Z: >= 0 } && gridPosition.X < Width && gridPosition.Z < Height;
+        public bool IsValidGridPosition(GridPosition gridPosition) => gridPosition is { XPosition: >= 0, ZPosition: >= 0 } && gridPosition.XPosition < Width && gridPosition.ZPosition < Height && gridPosition.Floor == Floor;
     }
 }

Assets/Scripts/Grid/GridSystemVisual.cs

@@ -41,7 +41,7 @@ namespace Grid {
 
             for (int x = 0; x < width; x++) {
                 for (int z = 0; z < height; z++) {
-                    Transform gridSystemVisualSingleTransform = Instantiate(gridSystemVisualSinglePrefab, LevelGrid.Instance.GetWorldPosition(new(x, z)), Quaternion.identity);
+                    Transform gridSystemVisualSingleTransform = Instantiate(gridSystemVisualSinglePrefab, LevelGrid.Instance.GetWorldPosition(new(x, z, 0)), Quaternion.identity);
                     gridSystemVisualSingleArray[x, z] = gridSystemVisualSingleTransform.GetComponent<GridSystemVisualSingle>();
                 }
             }
@@ -62,14 +62,14 @@ namespace Grid {
 
         private void ShowGridPositionList(List<GridPosition> gridPositionList, GridVisualType gridVisualType) {
             foreach (GridPosition gridPosition in gridPositionList)
-                gridSystemVisualSingleArray[gridPosition.X, gridPosition.Z].Show(GetGridVisualTypeMaterial(gridVisualType));
+                gridSystemVisualSingleArray[gridPosition.XPosition, gridPosition.ZPosition].Show(GetGridVisualTypeMaterial(gridVisualType));
         }
 
         private void ShowGridPositionRange(GridPosition gridPosition, int range, GridVisualType gridVisualType) {
             List<GridPosition> gridPositionList = new();
             for (int x = -range; x <= range; x++) {
                 for (int z = -range; z <= range; z++) {
-                    GridPosition testGridPosition = gridPosition + new GridPosition(x, z);
+                    GridPosition testGridPosition = gridPosition + new GridPosition(x, z, 0);
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions
                     if (Mathf.Abs(x) + Mathf.Abs(z) > range) continue; //Out of Range
                     gridPositionList.Add(testGridPosition);
@@ -83,7 +83,7 @@ namespace Grid {
             List<GridPosition> gridPositionList = new();
             for (int x = -range; x <= range; x++) {
                 for (int z = -range; z <= range; z++) {
-                    GridPosition testGridPosition = gridPosition + new GridPosition(x, z);
+                    GridPosition testGridPosition = gridPosition + new GridPosition(x, z, 0);
                     if (!LevelGrid.Instance.IsValidGridPosition(testGridPosition)) continue; //Only return valid grid positions
                     gridPositionList.Add(testGridPosition);
                 }

Assets/Scripts/Grid/LevelGrid.cs

@@ -5,14 +5,17 @@ using UnityEngine.Serialization;
 
 namespace Grid {
     public class LevelGrid : MonoBehaviour {
+        public const float FLOOR_HEIGHT = 3f;
+
         [FormerlySerializedAs("GridDebugObjectPrefab")] [SerializeField]
         private Transform gridDebugObjectPrefab;
 
         [SerializeField] private int width = 20;
         [SerializeField] private int height = 20;
         [SerializeField] private float cellSize = 2f;
+        [SerializeField] private int floorAmount = 1;
 
-        private GridSystem<GridObject> gridSystem;
+        private List<GridSystem<GridObject>> gridSystemList;
 
         public static LevelGrid Instance { get; private set; }
 
@@ -24,23 +27,31 @@ namespace Grid {
             }
 
             Instance = this;
-            gridSystem = new(width, height, cellSize, (g, gridPosition) => new(g, gridPosition));
+
+            gridSystemList = new();
+            for (int floor = 0; floor < floorAmount; floor++) {
+                GridSystem<GridObject> gridSystem = new(width, height, cellSize, floor, FLOOR_HEIGHT, (g, gridPosition) => new(g, gridPosition));
+                gridSystemList.Add(gridSystem);
+            }
         }
 
         private void Start() => Pathfinding.Instance.Setup(width, height, cellSize);
 
+        private GridSystem<GridObject> GetGridSystem(int floor) => gridSystemList[floor];
         public event EventHandler OnAnyUnitMovedGridPosition;
 
-        public void AddUnitAtGridPosition(GridPosition gridPosition, Unit unit) => gridSystem.GetGridObject(gridPosition).UnitList.Add(unit);
+        public void AddUnitAtGridPosition(GridPosition gridPosition, Unit unit) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).UnitList.Add(unit);
+
+        public List<Unit> GetUnitListAtGridPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).UnitList;
+        public void RemoveUnitAtGridPosition(GridPosition gridPosition, Unit unit) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).UnitList.Remove(unit);
 
-        public List<Unit> GetUnitListAtGridPosition(GridPosition gridPosition) => gridSystem.GetGridObject(gridPosition).UnitList;
-        public void RemoveUnitAtGridPosition(GridPosition gridPosition, Unit unit) => gridSystem.GetGridObject(gridPosition).UnitList.Remove(unit);
+        private static int GetFloor(Vector3 worldPosition) => Mathf.RoundToInt(worldPosition.y / FLOOR_HEIGHT);
 
-        public GridPosition GetGridPosition(Vector3 worldPosition) => gridSystem.GetGridPosition(worldPosition);
-        public Vector3 GetWorldPosition(GridPosition gridPosition) => gridSystem.GetWorldPosition(gridPosition);
-        public bool IsValidGridPosition(GridPosition gridPosition) => gridSystem.IsValidGridPosition(gridPosition);
-        public int GetWidth() => gridSystem.Width;
-        public int GetHeight() => gridSystem.Height;
+        public GridPosition GetGridPosition(Vector3 worldPosition) => GetGridSystem(GetFloor(worldPosition)).GetGridPosition(worldPosition);
+        public Vector3 GetWorldPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).GetWorldPosition(gridPosition);
+        public bool IsValidGridPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).IsValidGridPosition(gridPosition);
+        public int GetWidth() => GetGridSystem(0).Width;
+        public int GetHeight() => GetGridSystem(0).Height;
 
         public void UnitMovedGridPosition(Unit unit, GridPosition fromGridPosition, GridPosition toGridPosition) {
             RemoveUnitAtGridPosition(fromGridPosition, unit);
@@ -48,9 +59,9 @@ namespace Grid {
             OnAnyUnitMovedGridPosition?.Invoke(this, EventArgs.Empty);
         }
 
-        public bool HasAnyUnitOnGridPosition(GridPosition gridPosition) => gridSystem.GetGridObject(gridPosition).UnitList.Count > 0;
-        public Unit GetUnitAtGridPosition(GridPosition gridPosition) => gridSystem.GetGridObject(gridPosition).GetUnit();
-        public IInteractable GetInteractableAtGridPosition(GridPosition gridPosition) => gridSystem.GetGridObject(gridPosition).Interactable;
-        public void SetInteractableAtGridPosition(GridPosition gridPosition, IInteractable interactable) => gridSystem.GetGridObject(gridPosition).Interactable = interactable;
+        public bool HasAnyUnitOnGridPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).UnitList.Count > 0;
+        public Unit GetUnitAtGridPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).GetUnit();
+        public IInteractable GetInteractableAtGridPosition(GridPosition gridPosition) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).Interactable;
+        public void SetInteractableAtGridPosition(GridPosition gridPosition, IInteractable interactable) => GetGridSystem(gridPosition.Floor).GetGridObject(gridPosition).Interactable = interactable;
     }
 }

Assets/Scripts/Pathfinding.cs

@@ -32,12 +32,12 @@ public class Pathfinding : MonoBehaviour {
         Width = width;
         Height = height;
         CellSize = cellSize;
-        GridSystem = new(width, height, cellSize, (_, gridPosition) => new(gridPosition));
+        GridSystem = new(width, height, cellSize, 0, LevelGrid.FLOOR_HEIGHT, (_, gridPosition) => new(gridPosition));
         // GridSystem.CreateDebugObjects(gridDebugObjectPrefab);
 
         for (int x = 0; x < Width; x++) {
             for (int z = 0; z < Height; z++) {
-                GridPosition gridPosition = new(x, z);
+                GridPosition gridPosition = new(x, z, 0);
                 Vector3 worldPosition = LevelGrid.Instance.GetWorldPosition(gridPosition);
                 if (Physics.Raycast(worldPosition + Vector3.down * raycastOffsetDistance, Vector3.up, raycastOffsetDistance * 2, obstaclesLayerMask)) {
                     GetNode(x, z).IsWalkable = false;
@@ -60,7 +60,7 @@ public class Pathfinding : MonoBehaviour {
 
         for (int x = 0; x < GridSystem.Width; x++) {
             for (int z = 0; z < GridSystem.Height; z++) {
-                PathNode pathNode = GridSystem.GetGridObject(new(x, z));
+                PathNode pathNode = GridSystem.GetGridObject(new(x, z, 0));
                 pathNode.GCost = int.MaxValue;
                 pathNode.HCost = 0;
                 pathNode.CameFromPathNode = null;
@@ -103,8 +103,8 @@ public class Pathfinding : MonoBehaviour {
 
     private static int CalculateDistance(GridPosition gridPositionA, GridPosition gridPositionB) {
         GridPosition gridPositionDistance = gridPositionA - gridPositionB;
-        int xDistance = Mathf.Abs(gridPositionDistance.X);
-        int zDistance = Mathf.Abs(gridPositionDistance.Z);
+        int xDistance = Mathf.Abs(gridPositionDistance.XPosition);
+        int zDistance = Mathf.Abs(gridPositionDistance.ZPosition);
         int remaining = Mathf.Abs(xDistance - zDistance);
         return moveDiagonalCost * Mathf.Min(xDistance, zDistance) + moveStraightCost * remaining;
     }
@@ -119,25 +119,25 @@ public class Pathfinding : MonoBehaviour {
         List<PathNode> neighbourList = new();
         GridPosition gridPosition = currentNode.GridPosition;
 
-        if (gridPosition.X - 1 >= 0) {
-            neighbourList.Add(GetNode(gridPosition.X - 1, gridPosition.Z + 0)); //Left
-            if (gridPosition.Z - 1 >= 0) neighbourList.Add(GetNode(gridPosition.X - 1, gridPosition.Z - 1)); //LeftDown
-            if (gridPosition.Z < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.X - 1, gridPosition.Z + 1)); //LeftUp
+        if (gridPosition.XPosition - 1 >= 0) {
+            neighbourList.Add(GetNode(gridPosition.XPosition - 1, gridPosition.ZPosition + 0)); //Left
+            if (gridPosition.ZPosition - 1 >= 0) neighbourList.Add(GetNode(gridPosition.XPosition - 1, gridPosition.ZPosition - 1)); //LeftDown
+            if (gridPosition.ZPosition < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.XPosition - 1, gridPosition.ZPosition + 1)); //LeftUp
         }
 
-        if (gridPosition.X + 1 < GridSystem.Width) {
-            neighbourList.Add(GetNode(gridPosition.X + 1, gridPosition.Z + 0)); //Right
-            if (gridPosition.Z - 1 >= 0) neighbourList.Add(GetNode(gridPosition.X + 1, gridPosition.Z - 1)); //RightDown
-            if (gridPosition.Z + 1 < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.X + 1, gridPosition.Z + 1)); //RightUp
+        if (gridPosition.XPosition + 1 < GridSystem.Width) {
+            neighbourList.Add(GetNode(gridPosition.XPosition + 1, gridPosition.ZPosition + 0)); //Right
+            if (gridPosition.ZPosition - 1 >= 0) neighbourList.Add(GetNode(gridPosition.XPosition + 1, gridPosition.ZPosition - 1)); //RightDown
+            if (gridPosition.ZPosition + 1 < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.XPosition + 1, gridPosition.ZPosition + 1)); //RightUp
         }
 
-        if (gridPosition.Z - 1 >= 0) neighbourList.Add(GetNode(gridPosition.X - 0, gridPosition.Z - 1)); //Down
-        if (gridPosition.Z + 1 < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.X - 0, gridPosition.Z + 1)); //Up
+        if (gridPosition.ZPosition - 1 >= 0) neighbourList.Add(GetNode(gridPosition.XPosition - 0, gridPosition.ZPosition - 1)); //Down
+        if (gridPosition.ZPosition + 1 < GridSystem.Height) neighbourList.Add(GetNode(gridPosition.XPosition - 0, gridPosition.ZPosition + 1)); //Up
 
         return neighbourList;
     }
 
-    private PathNode GetNode(int x, int z) => GridSystem.GetGridObject(new(x, z));
+    private PathNode GetNode(int x, int z) => GridSystem.GetGridObject(new(x, z, 0));
 
     private static List<GridPosition> CalculatePath(PathNode endNode) {
         List<PathNode> pathNodeList = new() { endNode };

Assets/Scripts/UI/UnitActionSystemUI.cs

@@ -7,9 +7,14 @@ using UnityEngine.Serialization;
 
 namespace UI {
     public class UnitActionSystemUI : MonoBehaviour {
-        [FormerlySerializedAs("ActionButtonPrefab")] [SerializeField] private Transform actionButtonPrefab;
-        [FormerlySerializedAs("ActionButtonContainerTransform")] [SerializeField] private Transform actionButtonContainerTransform;
-        [FormerlySerializedAs("ActionPointsText")] [SerializeField] private TextMeshProUGUI actionPointsText;
+        [FormerlySerializedAs("ActionButtonPrefab")] [SerializeField]
+        private Transform actionButtonPrefab;
+
+        [FormerlySerializedAs("ActionButtonContainerTransform")] [SerializeField]
+        private Transform actionButtonContainerTransform;
+
+        [FormerlySerializedAs("ActionPointsText")] [SerializeField]
+        private TextMeshProUGUI actionPointsText;
 
         private List<ActionButtonUI> actionButtonUIList;
 
@@ -26,6 +31,7 @@ namespace UI {
             UpdateSelectedVisual();
         }
 
+
         private void Unit_OnAnyActionPointsChanged(object sender, EventArgs e) => UpdateActionPoints();
 
         private void TurnSystem_OnTurnChanged(object sender, EventArgs e) => UpdateActionPoints();

Assets/Scripts/Unit.cs

@@ -4,7 +4,7 @@ using Grid;
 using UnityEngine;
 
 public class Unit : MonoBehaviour {
-    private const int ACTION_POINTS_MAX = 10;
+    private const int ACTION_POINTS_MAX = 4;
 
     [SerializeField] private bool isEnemy;
     private int actionPoints = ACTION_POINTS_MAX;