Death loop, Serializable Dictionary & Spawner fixes (#20)

* Changes Made
+ Persistent Inventory Items Saving
+ Bag Refactored from SO to Serializable Class
+ Custom Json Serializer for SOs using Addressable
+ Small Utils Edits and Bug Fixes

* Changes Made
+ Lighting regenerated for game scene
+ Small modifications and added burst project settings files

* Refactored Functions in to states (just renames)

* Updated Unity version to v2022 LTS

* checkpoint

* checkpoint, refactored StateStatus enum to a bool IsEnabled

* added refactored and tested new state transitions

* pooling abstraction implemented, moved SerializableVector3.cs to Data package to fix core dependency compile error

* implemented spawner to hit effect on weapons

* Changes made
- Added serialized dictionary as an attribute to Generic Dictionary
- More improvements to Spawner

* checkpoint

* finished #16

* small DeSpawn fix for Spawner.cs

Author: rob1997

Packages/com.ekaka.character/Runtime/Damage/DefaultDeath.cs

@@ -0,0 +1,12 @@
+using Damage.Main;
+
+namespace Character.Damage
+{
+    public class DefaultDeath : Death
+    {
+        public override void Apply(DamageData damage)
+        {
+            Destroy(damage.Damagable.Obj);
+        }
+    }
+}

Packages/com.ekaka.character/Runtime/Damage/DefaultDeath.cs.meta

@@ -0,0 +1,98 @@
+using System.Dynamic;
+using Core.Utils;
+using UnityEditor;
+using UnityEngine;
+
+namespace Editor.Core
+{
+    [CustomPropertyDrawer(typeof(SerializedDictionaryAttribute), true)]
+    public class SerializedDictionaryPropertyDrawer : PropertyDrawer
+    {
+        private Rect _position;
+        
+        private bool _foldout;
+        
+        private readonly float _foldoutPadding = 15f;
+        
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            _position = position;
+            
+            _position.height = EditorGUIUtility.singleLineHeight;
+
+            _foldout = EditorGUI.Foldout(_position, _foldout, new GUIContent(property.displayName, property.tooltip));
+            
+            if (_foldout)
+            {
+                _position.x += _foldoutPadding;
+
+                _position.width -= _foldoutPadding;
+                
+                NewLine();
+                
+                DrawSerializedDictionary(property);
+                
+                property.serializedObject.ApplyModifiedProperties();
+            }
+        }
+
+        private void DrawSerializedDictionary(SerializedProperty dictProperty)
+        {
+            SerializedProperty pairListProperty = dictProperty.FindPropertyRelative(BaseEditor.SerializedListName);
+
+            EditorGUI.LabelField(MovedRect(0f, .4f), "Keys", EditorStyles.boldLabel);
+            
+            EditorGUI.LabelField(MovedRect(.45f, .4f), "Values", EditorStyles.boldLabel);
+            
+            if (GUI.Button(MovedRect(.9f, .1f), new GUIContent("+", "Add")))
+            {
+                pairListProperty.InsertArrayElementAtIndex(pairListProperty.arraySize);
+            }
+            
+            NewLine(1.25f);
+
+            int index = 0;
+            
+            foreach (SerializedProperty property in pairListProperty)
+            {
+                SerializedProperty keyProperty = property.FindPropertyRelative(BaseEditor.KeyName);
+
+                EditorGUI.PropertyField(MovedRect(0f, .4f), keyProperty, GUIContent.none);
+                
+                SerializedProperty valueProperty = property.FindPropertyRelative(BaseEditor.ValueName);
+
+                EditorGUI.PropertyField(MovedRect(.45f, .4f), valueProperty, GUIContent.none);
+                
+                if (GUI.Button(MovedRect(.9f, .1f), new GUIContent("-", "Remove")))
+                {
+                    pairListProperty.DeleteArrayElementAtIndex(index);
+                }
+
+                NewLine();
+
+                index++;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return _foldout ? _position.y : _position.height;
+        }
+
+        private Rect MovedRect(float normalizedX = 1f, float normalizedWidth = 1f)
+        {
+            Rect rect = _position;
+
+            rect.x += normalizedX * _position.width;
+            
+            rect.width *= normalizedWidth;
+            
+            return rect;
+        }
+        
+        private void NewLine(float normalizedLineHeight = 1.15f)
+        {
+            _position.y += _position.height * normalizedLineHeight;
+        }
+    }
+}

Packages/com.ekaka.core/Editor/SerializedDictionaryPropertyDrawer.cs

@@ -24,6 +24,8 @@ public enum GameState
         Play,
         //when game is paused - still in game scene
         Pause,
+        //when game is over (Player is dead) - still in game scene
+        GameOver,
         //onApplicationQuit (maybe use for dispose/garbage collection)
         Quitting
     }
@@ -80,6 +82,8 @@ private void InvokeGameStateChanged(GameState state)
 
         public GameState State { get; private set; } = GameState.Initializing;
 
+        public bool InGame => State == GameState.Play || State == GameState.Pause || State == GameState.GameOver;
+        
         private void Start()
         {
             Initialize();
@@ -127,9 +131,15 @@ public void StartGame(bool continued)
         }
 
         //load persistent data first
-        private void ContinueGame()
+        private void ContinueGame(bool reload = false)
         {
-            //implement
+            //change to loading until scene loads async
+            ChangeGameState(GameState.Loading);
+            
+            Debug.Log("Loading Game...");
+            
+            //load game scene and call onSceneLoaded
+            Utils.Utils.LoadScene(GameScene, NewGameStarted, reload);
         }
 
         private void StartNewGame()
@@ -163,24 +173,35 @@ public void ExitGame()
         //leave/unload game scene and load to Landing scene
         public void ExitToMainMenu()
         {
-            switch (State)
+            if (InGame)
             {
-                case GameState.Play: case GameState.Pause:
-                    
-                    //change to loading until scene loads async
-                    ChangeGameState(GameState.Loading);
+                //change to loading until scene loads async
+                ChangeGameState(GameState.Loading);
 
-                    Debug.Log($"exiting {nameof(GameScene)}...");
-                    
-                    //load landing scene and call onSceneLoaded
-                    Utils.Utils.LoadScene(LandingScene, GameExited);
+                Debug.Log($"exiting {nameof(GameScene)}...");
 
-                    break;
+                //load landing scene and call onSceneLoaded
+                Utils.Utils.LoadScene(LandingScene, GameExited);
+            }
+
+            else
+            {
+                Debug.LogError($"can't exit {nameof(GameScene)} when {nameof(GameState)} is not an {nameof(InGame)} {State}");
+            }
+        }
+
+        public void TryAgain()
+        {
+            if (!InGame)
+            {
+                Debug.LogError("Can't Not in Game.");
 
-                default:
-                    Debug.LogError($"can't exit {nameof(GameScene)} when {nameof(GameState)} is {State}");
-                    return;
+                return;
             }
+            
+            GameExited();
+            
+            ContinueGame(true);
         }
 
         //called once landing scene is loaded
@@ -208,6 +229,20 @@ public void PauseGame()
 
             ChangeGameState(GameState.Pause);
         }
+        
+        public void GameOver()
+        {
+            if (!InGame)
+            {
+                Debug.LogWarning($"can't {nameof(GameOver)} when {nameof(GameState)} is {State}");
+                
+                return;
+            }
+            
+            Time.timeScale = 0f;
+
+            ChangeGameState(GameState.GameOver);
+        }
 
         public void ResumeGame()
         {

Packages/com.ekaka.core/Editor/SerializedDictionaryPropertyDrawer.cs.meta

@@ -51,14 +51,26 @@ public TValue this[TKey key]
         }
 
         public bool IsReadOnly { get; set; }
-        
-        public void OnBeforeSerialize() { }
+
+        public void OnBeforeSerialize()
+        {
+            if (serializedList.GroupBy(p => p.Key).Any(g => g.Count() > 1))
+            {
+                Debug.LogError("Can't serialize duplicate keys into dictionary");
+            }
+        }
 
         public void OnAfterDeserialize()
         {
             _dictionary.Clear();
 
-            serializedList.ForEach(pair => _dictionary.Add(pair.Key, pair.Value));
+            serializedList.ForEach(pair =>
+            {
+                if (_dictionary.ContainsKey(pair.Key))
+                    Debug.LogError($"Can't serialize duplicate key {pair.Key}");
+                else
+                    _dictionary.Add(pair.Key, pair.Value);
+            });
         }
 
         public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _dictionary.GetEnumerator();

Packages/com.ekaka.core/Runtime/Game/GameManager.cs

@@ -1,6 +1,4 @@
-using System;
 using System.Collections;
-using Core.Game;
 using UnityEngine;
 using UnityEngine.Pool;
 
@@ -41,37 +39,63 @@ public T Spawn(Vector3 position, Quaternion rotation, Transform parent)
 
             return instance;
         }
+        
+        public T Spawn(Vector3 position, Quaternion rotation, Transform parent, float timeout)
+        {
+            T instance = Spawn(position, rotation, parent);
+            
+            DeSpawn(instance, timeout);
+
+            return instance;
+        }
 
         public void DeSpawn(T instance)
         {
-            Pool.Release(instance);
+            // Check if already DeSpawned.
+            if (instance != null)
+            {
+                Pool.Release(instance);
+            }
         }
 
-        public void DeSpawn(T instance, float t)
+        public void DeSpawn(T instance, float timeout)
         {
-            GameManager.Instance.StartCoroutine(WaitAndDeSpawn(instance, t));
+            StartCoroutine(WaitAndDeSpawn(instance, timeout));
         }
 
-        private IEnumerator WaitAndDeSpawn(T instance, float t)
+        private IEnumerator WaitAndDeSpawn(T instance, float timeout)
         {
-            yield return new WaitForSeconds(t);
+            yield return new WaitForSeconds(timeout);
 
-            _pool?.Release(instance);
+            DeSpawn(instance);
         }
-        
-        protected void Renew(T instance)
+
+        private void Renew(T instance)
         {
             instance.Renew();
         }
 
-        protected void Release(T instance)
+        private void Release(T instance)
         {
             instance.Release();
         }
 
-        protected void Retire(T instance)
+        private void Retire(T instance)
         {
             instance.Retire();
         }
+        
+        public void Clear()
+        {
+            Pool.Clear();
+        }
+        
+        private void OnApplicationQuit()
+        {
+            if (_pool != null && _pool.CountActive > 0)
+            {
+                Pool.Dispose();
+            }
+        }
     }
 }

Packages/com.ekaka.core/Runtime/Utils/GenericDictionary.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Core.Utils
+{
+    [AttributeUsage(AttributeTargets.Field)]
+    public class SerializedDictionaryAttribute : PropertyAttribute
+    {
+        public SerializedDictionaryAttribute()
+        {
+            
+        }
+    }
+}