Stamina Implemented (#30)

* 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

* EventBus implemented

* EventBus.cs implemented/refactored into Project

* namespace and class renames

* revert from merge

* GameState converted from enums to struct/class

* checkpoint

* just renames

* stamina/endurance implemented

* Endurance Immutable on Turret prefab

Author: rob1997

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

@@ -1,8 +1,6 @@
 using System.Collections.Generic;
 using Character.Main;
-using Damage.Main;
 using UnityEngine;
-using UnityEngine.Serialization;
 
 namespace Character.Damage
 {

Packages/com.ekaka.damage/Runtime/Main/DamageData.cs renamed to Packages/com.ekaka.character/Runtime/Damage/DamageData.cs

@@ -4,7 +4,7 @@
 using Sensors.Main;
 using UnityEngine;
 
-namespace Damage.Main
+namespace Character.Damage
 {
     //!!!INDEXES MUST BE UNIQUE
     //!!!NEVER CHANGE THE INDEX NUMBERS, CAUSES A SHUFFLE ISSUE ON CUSTOM EDITOR
@@ -55,9 +55,12 @@ public DamageData(Dictionary<DamageType, float> hits, Damager damager, IDamageab
 
             foreach (var hitPair in Hits)
             {
-                Resistance resistance = Damageable.Resistance[hitPair.Key];
-
-                if (!resistance.Invulnerable) DamageDealt += hitPair.Value - (resistance.Value * hitPair.Value);
+                DamageDealt += hitPair.Value;
+                
+                if (Damageable.Resistance.TryGetValue(hitPair.Key, out Resistance resistance) && !resistance.Invulnerable)
+                {
+                    DamageDealt -= resistance.Value * hitPair.Value;
+                }
             }
 
             MaxDamageType = Hits.Aggregate((h, l) => h.Value > l.Value ? h : l).Key;

Packages/com.ekaka.damage/Runtime/Main/DamageData.cs.meta renamed to Packages/com.ekaka.character/Runtime/Damage/DamageData.cs.meta

@@ -1,4 +1,4 @@
-namespace Damage.Main
+namespace Character.Damage
 {
     public class Damager
     {

Packages/com.ekaka.damage/Runtime/Main/Damager.cs renamed to Packages/com.ekaka.character/Runtime/Damage/Damager.cs

@@ -1,6 +1,6 @@
 using UnityEngine;
 
-namespace Damage.Main
+namespace Character.Damage
 {
     public abstract class DeathHandler : MonoBehaviour
     {

Packages/com.ekaka.damage/Runtime/Main/Damager.cs.meta renamed to Packages/com.ekaka.character/Runtime/Damage/Damager.cs.meta

@@ -1,4 +1,3 @@
-using Damage.Main;
 
 namespace Character.Damage
 {

Packages/com.ekaka.damage/Runtime/Main/DeathHandler.cs renamed to Packages/com.ekaka.character/Runtime/Damage/DeathHandler.cs

@@ -0,0 +1,33 @@
+using System;
+using Character.Main;
+using Core.Game;
+using UnityEngine;
+
+namespace Character.Damage
+{
+    [Serializable]
+    public class Endurance : Stat
+    {
+        [field: SerializeField, Tooltip("How many units of stamina is recovered per second.")]
+        public float RecoveryRate { get; private set; } = 5f;
+
+        public IDamageable Damageable { get; private set; }
+        
+        public void Initialize(IDamageable damageable)
+        {
+            CurrentValue = FullValue;
+            
+            Damageable = damageable;
+        }
+
+        public void RecoverStamina(float normalizedRate)
+        {
+            GainValue(RecoveryRate * normalizedRate * Time.deltaTime, out _, true);
+        }
+        
+        public void DrainStamina(float normalizedRate)
+        {
+            LoseValue(RecoveryRate * normalizedRate * Time.deltaTime, out _, true);
+        }
+    }
+}

Packages/com.ekaka.damage/Runtime/Main/DeathHandler.cs.meta renamed to Packages/com.ekaka.character/Runtime/Damage/DeathHandler.cs.meta

@@ -1,22 +1,23 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using Core.Game;
 using Core.Common;
 using Sensors.Main;
-using UnityEngine;
 
-namespace Damage.Main
+namespace Character.Damage
 {
     public interface IDamageable : ITargetable
     {
         public Vitality Vitality { get; }
 
+        public Endurance Endurance { get; }
+        
         public Damager Damager { get; }
 
-        public float CurrentHealth => Vitality.CurrentHealth;
+        public float CurrentHealth => Vitality.CurrentValue;
+        
+        public float CurrentStamina => Endurance.CurrentValue;
+        
+        public float NormalizedHealth => CurrentHealth / Vitality.FullValue;
 
-        public float NormalizedHealth => CurrentHealth / Vitality.FullHealth;
+        public float NormalizedStamina => CurrentStamina / Endurance.FullValue;
 
         public bool IsDead => CurrentHealth <= 0;
 
@@ -26,11 +27,13 @@ public interface IDamageable : ITargetable
         public float LoadCurrentHealth();
     }
 
-    public static class DamagableWrapper
+    public static class DamageableWrapper
     {
-        public static void InitializeDamagable(this IDamageable damageable)
+        public static void InitializeDamageable(this IDamageable damageable)
         {
             damageable.Vitality.Initialize(damageable);
+            
+            damageable.Endurance.Initialize(damageable);
         }
 
         public static void TakeDamage(this IDamageable damageable, DamageData damageReceived)

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

@@ -0,0 +1,117 @@
+using System;
+using System.Linq;
+using Character.Main;
+using Core.Common;
+using UnityEngine;
+
+namespace Character.Damage
+{
+    [Serializable]
+    public struct Resistance
+    {
+        [field: SerializeField] public bool Invulnerable { get; private set; }
+        
+        [field: ShowIf(nameof(Invulnerable), false)]
+        [field: Range(0, 1)]
+        [field: Tooltip("0 being will take all the damage sent 1 being invulnerable to damage")]
+        [field: SerializeField] public float Value { get; private set; }
+    }
+
+    [Serializable]
+    public class Vitality : Stat
+    {
+        #region DamageTaken
+
+        public delegate void DamageTaken(DamageData damage);
+
+        public event DamageTaken OnDamageTaken;
+
+        private void InvokeDamageTaken(DamageData damage)
+        {
+            OnDamageTaken?.Invoke(damage);
+        }
+
+        #endregion
+    
+        #region Death
+        
+        public delegate void DeathDelegate(DamageData damage);
+
+        public event DeathDelegate OnDeath;
+
+        private void InvokeDeath(DamageData damage)
+        {
+            OnDeath?.Invoke(damage);
+
+            if (!DeathOverrides.TryGetValue(damage.MaxDamageType, out DeathHandler death))
+            {
+                death = Death;
+            }
+            
+            death.Apply(damage);
+        }
+        
+        [field: SerializeField] public DeathHandler Death { get; private set; }
+
+        [field: SerializeField, SerializedDictionary,
+                Tooltip(
+                    "If the highest killing blow hit damage type is not found in this dictionary, default death will be applied instead.")]
+        public GenericDictionary<DamageType, DeathHandler> DeathOverrides { get; private set; }
+
+        #endregion
+
+        [field: SerializeField, SerializedDictionary,
+                Tooltip(
+                    "Resistance to specific Damage type, 0 - 1, 1 being invulnerable to damage.")]
+        public GenericDictionary<DamageType, Resistance> Resistance { get; private set; }
+    
+        public IDamageable Damageable { get; private set; }
+
+        public void Initialize(IDamageable damageable)
+        {
+            Damageable = damageable;
+            
+            //load health from damageable
+            CurrentValue = Damageable.LoadCurrentHealth();
+            
+            //if current health is 0, it means it's a new Game or Damageable wasn't initialized before
+            if (CurrentValue <= 0)
+            {
+                CurrentValue = FullValue;
+            }
+        }
+        
+        public void TakeDamage(DamageData damageReceived)
+        {
+            Debug.Log($"{damageReceived.DamageDealt} damage dealt to {Damageable.Obj.name}");
+            
+            if (LoseValue(damageReceived.DamageDealt, out float damageTaken))
+            {
+                Debug.Log($"{damageTaken} damage taken by {Damageable.Obj.name}");
+            
+                InvokeDamageTaken(damageReceived);
+        
+                damageReceived.Damager.InvokeDamageDealt(damageReceived);
+        
+                if (IsDepleted)
+                {
+                    Debug.Log($"{Damageable.Obj.name} Dead...");
+                
+                    InvokeDeath(damageReceived);
+            
+                    damageReceived.Damager.InvokeKillingBlow(damageReceived);
+                }
+            }
+        }
+
+        public void GainHealth(float healthReceived)
+        {
+            Debug.Log($"{healthReceived} health received to {Damageable.Obj.name}");
+
+            if (GainValue(healthReceived, out float healthGained))
+            {
+                Debug.Log($"{healthGained} health gained by {Damageable.Obj.name}");
+            }
+        }
+    }
+}

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

@@ -1,9 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using Core.Game;
 using Core.Common;
-using Damage.Main;
+using Character.Damage;
 using Sensors.Main;
 using UnityEngine;
 
@@ -88,15 +86,17 @@ public CharacterController CharacterController
 
         #endregion
 
-        #region Damagable
+        #region Damageable
 
         [field: SerializeField] public Vitality Vitality { get; private set; }
+        
+        [field: SerializeField] public Endurance Endurance { get; private set; }
 
         public Damager Damager { get; private set; } = new Damager();
 
         public virtual float LoadCurrentHealth()
         {
-            return Vitality.FullHealth;
+            return Vitality.FullValue;
         }
 
         #endregion
@@ -125,21 +125,9 @@ protected virtual void Initialize()
                 controller.InvokeReady();
             }
 
-            #region Targetable
-
-            ITargetable targetable = this;
-
-            targetable.InitializeTargetable();
-
-            #endregion
-            
-            #region Damagable
-
-            IDamageable damageable = this;
-
-            damageable.InitializeDamagable();
+            this.InitializeTargetable();
 
-            #endregion
+            this.InitializeDamageable();
 
             InvokeReady();
         }