init

Assets/Scripts/MyTypes.cs

@@ -0,0 +1,194 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public static class MyVars
+{
+    public static float cellSize = 1;
+
+    public static int gridWidth = 15;
+    public static int gridHeight = 12;
+
+    public static float slowTime = .1f;
+    public static float defaultTime = 1;
+
+    public static Vector2Int p1StartPos = new Vector2Int((gridWidth-1)/2, 2);
+    public static Vector2Int p2StartPos = new Vector2Int((gridWidth+1)/2, 2);
+
+    public static float enemyMaxSpeed = 3;
+    public static float enemySpeedGrowth = 0.2f;
+
+    public static float minEnemyAmount = 2;
+    public static float maxEnemyAmount = 5;
+    public static float enemyAmountGrowth = 0.25f;
+    public static int enemyKillScore = 1000;
+
+    public static float spikeAmount = 3;
+}
+
+public static class MyMethods
+{
+    private static System.Random rng = new System.Random();
+
+    public static float Remap(this float value, float from1, float to1, float from2, float to2)
+    {
+        return (value - from1) / (to1 - from1) * (to2 - from2) + from2;
+    }
+    public static void Shuffle<T>(this IList<T> list)
+    {
+        int n = list.Count;
+        while (n > 1)
+        {
+            n--;
+            int k = rng.Next(n + 1);
+            T value = list[k];
+            list[k] = list[n];
+            list[n] = value;
+        }
+    }
+
+}
+
+
+namespace MyTypes
+{
+    public enum MyDirection
+    {
+        _UP, _DOWN, _RIGHT, _LEFT, _MAX
+    }
+
+    public class MyPawn : MonoBehaviour
+    {
+        protected MyCell currentCell=null;
+
+        public MyCell CurrentCell
+        {
+            get
+            {
+                return currentCell;
+            }
+
+            set 
+            {
+                currentCell = value;
+            }
+        }
+    }
+
+    public class MyCell
+    {
+        public Vector2Int position;
+        private MyPawn pawn;
+        public MyPawn Pawn
+        {
+            get
+            {
+                return pawn;
+            }
+            set
+            {
+                //pawn = value;
+                if (value != null) //if value does not equal null, the pawn is moving into this cell
+                {
+                    if (pawn == null) //I am an empty cell
+                    {
+                        if(value.CurrentCell!=null)
+                            value.CurrentCell.pawn = null;
+                        pawn = value;
+                        pawn.CurrentCell = this;
+
+                        LeanTween.move(pawn.gameObject, new Vector3(position.x * MyVars.cellSize, 0, position.y * MyVars.cellSize), 0.1f).setEaseOutCirc();
+                        pawn.gameObject.transform.localScale = new Vector3(.75f, .75f, 1.25f);
+                        //LeanTween.scaleZ(pawn.gameObject, 1.5f, 0).setEaseOutBack();
+                        //LeanTween.scaleX(pawn.gameObject, .75f, 0).setEaseOutBack();
+                        //LeanTween.scaleY(pawn.gameObject, .75f, 0).setEaseOutBack();
+
+                        LeanTween.scaleZ(pawn.gameObject, 1, .35f).setEaseOutBack();
+                        LeanTween.scaleX(pawn.gameObject, 1, .35f).setEaseOutBack();
+                        LeanTween.scaleY(pawn.gameObject, 1, .35f).setEaseOutBack();
+
+
+                        //pawn.gameObject.transform.position = new Vector3(position.x * MyVars.cellSize, 0, position.y * MyVars.cellSize);
+                    }
+                    else
+                    {
+                        Debug.LogError("Assigned pawn to an occupied cell: " + position);
+                        EnemyBehavior.enemyAmount--;
+                    }
+                }
+            }
+        }
+
+        public MyCell (Vector2Int position)
+        {
+            this.position = position;
+            pawn = null;
+        }
+
+        public MyCell (int x, int y)
+        {
+            position = new Vector2Int(x, y);
+            pawn = null;
+        }
+    }
+
+    [System.Serializable]
+    public class MyGrid
+    {
+        public int width=MyVars.gridWidth;
+        public int height=MyVars.gridHeight;
+        public float cellSize = MyVars.cellSize;
+
+        public MyCell[,] grid;
+        
+        public List<MyCell> availableCells;
+
+        public MyGrid(int width, int height)
+        {
+            this.width = width;
+            this.height = height;
+
+            grid = new MyCell[width, height];
+
+            availableCells = new List<MyCell>();
+        }
+
+        public MyCell getCell(Vector2Int pos)
+        {
+            return grid[pos.x , pos.y];
+        }
+        public MyCell getCell(Vector2Int pos, Vector2Int offset)
+        {
+            return grid[pos.x+offset.x, pos.y+offset.y];
+        }
+
+        public void AddAvailableCell(MyCell cell)
+        {
+            availableCells.Add(cell);
+        }
+
+        public MyCell GetAvailableCell()
+        {
+            MyMethods.Shuffle(availableCells);
+            MyCell aux = availableCells[availableCells.Count-1];
+            availableCells.Remove(aux);
+            return aux;
+        }
+
+        public void RemoveAvailableCell(MyCell cell)
+        {
+            if(availableCells.Contains(cell))
+                availableCells.Remove(cell);
+        }
+
+        public void movePawn(MyPawn pawnToMove, MyCell targetCell)
+        {
+            AddAvailableCell(pawnToMove.CurrentCell);
+            RemoveAvailableCell(targetCell);
+
+
+            //pawnToMove.CurrentCell = targetCell; 
+            targetCell.Pawn = pawnToMove; //this also updates former cell's pawn reference and pawn's cell reference
+        }
+    }
+}