added some stuff

Assets/Scripts/LemonGenericLib/Generic Classes/Grid/GridClass.cs

@@ -0,0 +1,454 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+using System;
+using UnityEngine.UI;
+using TMPro;
+
+//things to do (for the authur only):
+//check if this class is very reusable
+//implement a proper way to destroy grids
+//add more debug features and controls
+//test this in 3D (using x and z axis)
+//remove all mentions of  real names in this class and replace them with screen names
+
+//this is Wong Sui Bin's grid class, I advise not to touch this if you are not the authur of this class
+//this is a class that greats a 2D grid in the game world that maps with real coordinates
+//requires text mesh pro to work
+
+//so far used for
+//level editors
+//tile based building system
+//grid reresentation of positions of game objects
+namespace Lemon.GenericLib.Generics
+{
+    public class Grid<TGridObject>
+    {
+        public event EventHandler<OnGridObjectChangedArgs> OnGridObjectChanged;
+
+        public class OnGridObjectChangedArgs : EventArgs
+        {
+            public int x, y;
+        }
+
+
+        public int width;
+        public int height;
+        private float cellSize;
+        private Vector3 originPosition;
+        private TGridObject[,] gridArray;
+        private TextMeshPro[,] gridText;
+
+        private Color textColour;
+        private bool showText;
+        private int textSize;
+        private bool spawnText;
+        private bool debugLine;
+
+        #region constructors
+        //arrangement of y is up and x is right
+        //grid constructor for custom data types
+        public Grid(int width, int height, float cellSize, Vector3 originPosition, Transform parent, Func<Grid<TGridObject>, int, int, TGridObject> createGridObject, bool spawnText = true, bool debugLine = true)
+        {
+            this.width = width;
+            this.height = height;
+            this.cellSize = cellSize;
+            this.gridArray = new TGridObject[width, height];
+            this.gridText = new TextMeshPro[width, height];
+            this.originPosition = originPosition;
+            this.textColour = Color.white;
+            this.showText = true;
+            this.textSize = 5;
+            this.spawnText = spawnText;
+            this.debugLine = debugLine;
+
+            //construct grid object
+            for (int x = 0; x < gridArray.GetLength(0); x++)
+            {
+                for (int y = 0; y < gridArray.GetLength(1); y++)
+                {
+                    gridArray[x, y] = createGridObject(this, x, y);
+                }
+            }
+
+            //set debug visuals
+            for (int x = 0; x < gridArray.GetLength(0); x++)
+            {
+                for (int y = 0; y < gridArray.GetLength(1); y++)
+                {
+                    if (debugLine)
+                    {
+                        Debug.DrawLine(GetWorldPosition(x, y), GetWorldPosition(x, y + 1), Color.white, 100f);
+                        Debug.DrawLine(GetWorldPosition(x, y), GetWorldPosition(x + 1, y), Color.white, 100f);
+
+                    }
+
+
+                    if (spawnText)
+                        gridText[x, y] = CreateGridText(gridArray[x, y]?.ToString(), parent, x, y, GetWorldPositionCenter(x, y), textSize, textColour, TMPro.TextAlignmentOptions.CenterGeoAligned);
+
+                    //disable text if configured to not show
+                    gridText[x, y]?.gameObject.SetActive(showText);
+                }
+
+
+            }
+            if (debugLine)
+            {
+                Debug.DrawLine(GetWorldPosition(0, height), GetWorldPosition(width, height), Color.white, 100f);
+                Debug.DrawLine(GetWorldPosition(width, 0), GetWorldPosition(width, height), Color.white, 100f);
+            }
+
+            //assign object changed even for debug visuals
+            OnGridObjectChanged += (object sender, OnGridObjectChangedArgs eventArgs) =>
+            {
+                gridText[eventArgs.x, eventArgs.y].text = gridArray[eventArgs.x, eventArgs.y].ToString();
+            };
+        }
+
+        //grid constructor for non custom data type
+        public Grid(int width, int height, float cellSize, Vector3 originPosition, Transform parent, bool spawnText = true, bool debugLine = true)
+        {
+            this.width = width;
+            this.height = height;
+            this.cellSize = cellSize;
+            this.gridArray = new TGridObject[width, height];
+            this.gridText = new TextMeshPro[width, height];
+            this.originPosition = originPosition;
+            this.textColour = Color.white;
+            this.showText = true;
+            this.textSize = 5;
+            this.spawnText = spawnText;
+            this.debugLine = debugLine;
+
+            //set debug visuals
+            for (int x = 0; x < gridArray.GetLength(0); x++)
+            {
+                for (int y = 0; y < gridArray.GetLength(1); y++)
+                {
+                    if (debugLine)
+                    {
+                        Debug.DrawLine(GetWorldPosition(x, y), GetWorldPosition(x, y + 1), Color.white, 100f);
+                        Debug.DrawLine(GetWorldPosition(x, y), GetWorldPosition(x + 1, y), Color.white, 100f);
+
+                    }
+
+                    if (spawnText)
+                        gridText[x, y] = CreateGridText(gridArray[x, y]?.ToString(), parent, x, y, GetWorldPositionCenter(x, y), textSize, textColour, TMPro.TextAlignmentOptions.CenterGeoAligned);
+
+                    //disable text if configured to not show
+                    gridText[x, y]?.gameObject.SetActive(showText);
+                }
+
+
+            }
+            if (debugLine)
+            {
+                Debug.DrawLine(GetWorldPosition(0, height), GetWorldPosition(width, height), Color.white, 100f);
+                Debug.DrawLine(GetWorldPosition(width, 0), GetWorldPosition(width, height), Color.white, 100f);
+            }
+            //assign object changed even for debug visuals
+            OnGridObjectChanged += (object sender, OnGridObjectChangedArgs eventArgs) =>
+            {
+                gridText[eventArgs.x, eventArgs.y].text = gridArray[eventArgs.x, eventArgs.y].ToString();
+            };
+        }
+        #endregion
+
+        #region position hash
+        //the hash index for the grid, start from 0 in the bottom left cell and counting right and upwards
+        //hash the ridArray position into hash index
+        public int positionHash(int x, int y)
+        {
+            return y * width + x;
+        }
+
+        //hash the index back to gridArray position
+        public void positionHash(int index, out int x, out int y)
+        {
+            y = index / width;
+            x = index % width;
+        }
+        #endregion
+
+        #region Get Positions
+        //get world posisiton of a corner of a cell
+        private Vector3 GetWorldPosition(int x, int y)
+        {
+            return new Vector3(x, y) * cellSize + originPosition;
+        }
+
+        //get world positon of the center of a cell
+        public Vector3 GetWorldPositionCenter(int x, int y)
+        {
+            return GetWorldPosition(x, y) + new Vector3(cellSize, cellSize) * .5f;
+        }
+
+        //convert a vector 3 position to the center of a grid
+        public Vector3 GetWorldPositionCenter(Vector3 worldPosition)
+        {
+            int x, y;
+            GetXY(worldPosition, out x, out y);
+            return GetWorldPositionCenter(x, y);
+
+        }
+
+        //get x and y of grid from world posistion
+        public void GetXY(Vector3 worldPosition, out int x, out int y)
+        {
+            x = Mathf.FloorToInt((worldPosition - originPosition).x / cellSize);
+            y = Mathf.FloorToInt((worldPosition - originPosition).y / cellSize);
+        }
+
+        public Vector2Int GetXYVector2Int(Vector3 worldPosition)
+        {
+            return new Vector2Int(Mathf.FloorToInt((worldPosition - originPosition).x / cellSize), Mathf.FloorToInt((worldPosition - originPosition).y / cellSize));
+        }
+        #endregion
+
+        #region Grid Object Manipulation
+        //set value from x and y of the array
+        public void SetGridObject(int x, int y, TGridObject gridObject)
+        {
+            if (x >= 0 && x < width && y >= 0 && y < height)
+            {
+                gridArray[x, y] = gridObject;
+                TriggerGridObjectChanged(x, y);
+            }
+        }
+
+        //set value from world position
+        public void SetGridObject(Vector3 worldPosition, TGridObject gridObject)
+        {
+            int x, y;
+            GetXY(worldPosition, out x, out y);
+            SetGridObject(x, y, gridObject);
+        }
+
+        //get value from x and y of the array
+        public TGridObject GetGridObject(int x, int y)
+        {
+            if (x >= 0 && x < width && y >= 0 && y < height)
+            {
+                return gridArray[x, y];
+            }
+            else
+            {
+                return default(TGridObject);
+            }
+        }
+
+        public TGridObject GetGridObject(Vector2Int pos)
+        {
+            return GetGridObject(pos.x, pos.y);
+        }
+
+        //get value from world position
+        public TGridObject GetGridObject(Vector3 worldPosition)
+        {
+            int x, y;
+            GetXY(worldPosition, out x, out y);
+            return GetGridObject(x, y);
+
+        }
+        #endregion
+
+        #region get grid object patterns
+        List<TGridObject> returnObjList = new List<TGridObject>();
+
+        public bool CheckWithinGrid(Vector2Int pos) {
+            if (pos.x >= 0 && pos.x < width) {
+                if (pos.y >= 0 && pos.y < height)
+                    return true;
+            }
+            return false;
+        }
+
+        public bool CheckWithinGrid(Vector3 worldPosition)
+        {
+            if (worldPosition.x >= originPosition.x && worldPosition.x < originPosition.x + (cellSize*width))
+            {
+                if (worldPosition.y >= originPosition.y && worldPosition.y < originPosition.y + (cellSize * height))
+                    return true;
+            }
+            return false;
+        }
+
+        public List<TGridObject> GetAdjacent(Vector2Int originPos, int range = 1, bool includeSelf = false)
+        {
+            returnObjList.Clear();
+            List<Vector2Int> dirList = new List<Vector2Int>() { Vector2Int.up, Vector2Int.down, Vector2Int.left, Vector2Int.right };
+            if (CheckWithinGrid(originPos) && includeSelf) returnObjList.Add(GetGridObject(originPos));
+            foreach (var item in dirList)
+            {
+                if (CheckWithinGrid(originPos+(item*range))) returnObjList.Add(GetGridObject(originPos+ (item * range)));
+            }
+            return returnObjList;
+        }
+
+        public List<TGridObject> GetSurrounding(Vector2Int originPos,int range = 1, bool includeSelf = false)
+        {
+            returnObjList.Clear();
+            List<Vector2Int> dirList = new List<Vector2Int>() { new Vector2Int(-1,1), new Vector2Int(1, 1), new Vector2Int(-1, -1), new Vector2Int(1, -1) };
+            returnObjList.AddRange(GetAdjacent(originPos, range, includeSelf));
+            foreach (var item in dirList)
+            {
+                if (CheckWithinGrid(originPos + (item * range))) returnObjList.Add(GetGridObject(originPos + (item * range)));
+            }
+            return returnObjList;
+        }
+
+        public List<TGridObject> GetArea(Vector2Int originPos, int range = 1, bool includeSelf = false)
+        {
+            returnObjList.Clear();
+            Vector2Int temp;
+            for (int x = originPos.x- range; x <= originPos.x+range; x++)
+            {
+                for (int y = originPos.y - range; y <= originPos.y + range; y++)
+                {
+                    temp = new Vector2Int(x, y);
+                    if (CheckWithinGrid(temp)) {
+                        if (temp == originPos && !includeSelf) continue;
+                        returnObjList.Add(GetGridObject(temp));
+                    }
+                }
+            }
+            return returnObjList;
+        }
+
+        public List<TGridObject> GetRow(int y)
+        {
+            returnObjList.Clear();
+            for (int x = 0; x < width; x++)
+            {
+                returnObjList.Add(gridArray[x, y]);
+            }
+            return returnObjList;
+        }
+
+        public List<TGridObject> GetColumn(int x)
+        {
+            returnObjList.Clear();
+            for (int y = 0; y < height; y++)
+            {
+                returnObjList.Add(gridArray[x, y]);
+            }
+            return returnObjList;
+        }
+
+        #endregion
+
+        #region entire grid manipulation
+        public TGridObject[,] OutputArray()
+        {
+            return gridArray;
+        }
+
+        public void DoAllGridObjects(Action<int,int,TGridObject> function) {
+            for (int x = 0; x < width; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+                    function(x,y,gridArray[x, y]);
+                }
+            }
+        }
+
+        public void DestroyGrid()
+        {
+            if (!spawnText) return;
+            for (int x = 0; x < width; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+
+
+                    if (gridText[x, y] != null)
+                    {
+                        MonoBehaviour.Destroy(gridText[x, y].gameObject);
+
+                    }
+
+
+                }
+            }
+        }
+        #endregion
+
+        #region DebugText
+        //trigger the update debug text event using gridArray Position
+        public void TriggerGridObjectChanged(int x, int y)
+        {
+            if (OnGridObjectChanged != null && spawnText) OnGridObjectChanged(this, new OnGridObjectChangedArgs { x = x, y = y });
+        }
+
+        //trigger the update debug text event using world Position
+        public void TriggerGridObjectChanged(Vector3 position)
+        {
+            int x, y;
+            GetXY(position, out x, out y);
+            if (OnGridObjectChanged != null && spawnText) OnGridObjectChanged(this, new OnGridObjectChangedArgs { x = x, y = y });
+        }
+
+        //configure debug text option
+        //so far no use for this
+        public void configureDebugText(bool show, Color textColour, int size)
+        {
+
+            this.showText = show;
+            this.textColour = textColour;
+            this.textSize = size;
+
+            if (!spawnText) return;
+            for (int x = 0; x < width; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+
+                    //disable text if configured to not show
+                    gridText[x, y]?.gameObject.SetActive(showText);
+                    if (gridText[x, y] != null)
+                    {
+                        gridText[x, y].color = this.textColour;
+                        gridText[x, y].fontSize = this.textSize;
+                    }
+
+
+                }
+            }
+        }
+
+        //get if the text is shown
+        public bool getShowText()
+        {
+            return showText;
+        }
+
+        // Create Text in the Grid
+        private TextMeshPro CreateGridText(string text, Transform parent = null, int x = 0, int y = 0, Vector3 localPosition = default(Vector3), int fontSize = 40, Color? color = null, TextAlignmentOptions textAlignment = TextAlignmentOptions.Left, int sortingOrder = 5000)
+        {
+            if (color == null) color = Color.white;
+            return CreateGridText(parent, text, $"Grid_Text_[{x}, {y}]", localPosition, fontSize, (Color)color, textAlignment, sortingOrder);
+        }
+
+        // Create Text in the Grid
+        private TextMeshPro CreateGridText(Transform parent, string text, string objectName, Vector3 localPosition, int fontSize, Color color, TextAlignmentOptions textAlignment, int sortingOrder)
+        {
+            GameObject gameObject = new GameObject(objectName, typeof(TextMeshPro));
+            Transform transform = gameObject.transform;
+            transform.SetParent(parent, false);
+            transform.localPosition = localPosition;
+            TextMeshPro textMesh = gameObject.GetComponent<TextMeshPro>();
+            textMesh.alignment = textAlignment;
+            //textMesh.anchor = AnchorPositions.Center;
+            textMesh.text = text;
+            textMesh.fontSize = fontSize;
+            textMesh.color = color;
+            textMesh.GetComponent<MeshRenderer>().sortingOrder = sortingOrder;
+            return textMesh;
+        }
+        #endregion
+    }
+
+}

Assets/Scripts/LemonGenericLib/Generic Classes/Grid/GridClass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 67f78fc7678d30c41a2a7d560cf4bda9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/LemonGenericLib/Generic Classes/Grid/GridHelper.cs

@@ -0,0 +1,15 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Lemon.GenericLib.Generics
+{ 
+
+    public class GridHelper<T>
+    {
+        private Grid<T> grid;
+
+       
+    }   
+}
+

Assets/Scripts/LemonGenericLib/Generic Classes/Grid/GridHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e422af2af72481844b3dc6e0cd0d8c71
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: