First Commit

Author: BlackSentryDevXo

.DS_Store

@@ -0,0 +1,46 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &8115805376265406789
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6125993688496956866}
+  - component: {fileID: 8823135042377463800}
+  m_Layer: 0
+  m_Name: BadgeManager
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &6125993688496956866
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8115805376265406789}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &8823135042377463800
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8115805376265406789}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfa30d055f3c4f64bb0e2d2151af7afe, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 

BadgeNotificationSystem.meta

@@ -0,0 +1,97 @@
+using System.Collections;
+using NaughtyAttributes;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace SentryToolkit
+{
+    public class BadgeComponent : MonoBehaviour
+    {
+        public BadgeID badgeId; // Unique ID for the badge
+        public Image badgeSymbolImage; // Image component to display the badge symbol
+
+        public bool autoGetButton = true;
+        [DisableIf("autoGetButton")]
+        public Button badgeClickButton;
+        BadgeManager badgeManager;
+
+        private void Start()
+        {
+            InitializeBadgeManager();
+            if (autoGetButton)
+                GetComponent<Button>().onClick.AddListener(OnBadgeClicked);
+            else
+                badgeClickButton.onClick.AddListener(OnBadgeClicked);
+        }
+
+        void InitializeBadgeManager()
+        {
+            if (!badgeManager)
+            {
+                badgeManager = BadgeManager.Instance;
+            }
+        }
+
+        private void OnEnable()
+        {
+            InitializeBadgeManager();
+            StartCoroutine(HandleManagerSubscription());
+        }
+
+        private IEnumerator HandleManagerSubscription()
+        {
+            yield return new WaitForEndOfFrame();
+            
+            if (badgeSymbolImage != null) badgeSymbolImage.gameObject.SetActive(false);
+
+            if (badgeManager != null) {
+                badgeManager.OnBadgeStateChanged += HandleBadgeStateChanged;
+            }
+            else {
+                Debug.LogError("Badge Manager is null");
+            }
+            UpdateBadge();
+        }
+
+        private void OnDisable()
+        {
+            if (badgeManager != null)
+            {
+                badgeManager.OnBadgeStateChanged -= HandleBadgeStateChanged;
+            }
+        }
+
+        public void OnBadgeClicked()
+        {
+            // Debug.LogError(gameObject.name);
+            if (badgeManager != null)
+            {
+                badgeManager.ClearBadge(badgeId);
+            }
+            else
+            {
+                Debug.LogError("Can't find badge manager");
+            }
+        }
+
+        private void HandleBadgeStateChanged(BadgeID id)
+        {
+            // Debug.LogError("state has changed");
+            UpdateBadge();
+        }
+
+        public void UpdateBadge()
+        {
+            if (badgeManager == null)
+            {
+                Debug.LogError("Badge Manager is null");
+            }
+
+            BadgeState state = badgeManager.GetBadge(badgeId);
+            // Debug.LogError($"{gameObject.name} badge state is {state.Type.ToString()} & the active status is {state.Type != BadgeType.None}");
+            if (badgeSymbolImage == null) { Debug.LogError($"{gameObject.name} doesn't have a badge symbol image"); return; }
+            // Activate or deactivate the symbol image based on badge state
+            badgeSymbolImage.gameObject.SetActive(state.Type != BadgeType.None);
+        }
+    }
+}

BadgeNotificationSystem/.DS_Store

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace SentryToolkit
+{
+    [System.Serializable]
+    public class BadgeState
+    {
+        public BadgeType Type;
+    }
+
+    [System.Serializable]
+    public class BadgeChildMapping
+    {
+        public BadgeID Parent;
+        public List<BadgeID> Children;
+    }
+}

BadgeNotificationSystem/BadgeManager.prefab

@@ -0,0 +1,161 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
+using System;
+
+namespace SentryToolkit
+{
+    public class BadgeManager : MonoBehaviour
+    {
+        public static BadgeManager Instance;
+
+        private Dictionary<BadgeID, BadgeState> badgeStates; // Stores current badge states
+        private Dictionary<BadgeID, List<BadgeID>> childMap; // Maps parent badges to their child badges
+
+        public event Action<BadgeID> OnBadgeStateChanged;
+
+        private void Awake()
+        {
+            if (Instance == null)
+            {
+                Instance = this;
+                LoadBadgeStates();
+                childMap = new Dictionary<BadgeID, List<BadgeID>>();
+                DontDestroyOnLoad(gameObject);
+            }
+            else
+            {
+                Destroy(gameObject);
+            }
+        }
+
+        public void InitializeChildMap(List<BadgeChildMapping> mappings)
+        {
+            foreach (var mapping in mappings)
+            {
+                if (!childMap.ContainsKey(mapping.Parent))
+                {
+                    childMap[mapping.Parent] = new List<BadgeID>();
+                }
+                childMap[mapping.Parent].AddRange(mapping.Children);
+            }
+        }
+
+        public void InitializeBadgesWithPropagations()
+        {
+            // Create a temporary list of keys to iterate over
+            List<BadgeID> badgeKeys = new List<BadgeID>(badgeStates.Keys);
+
+            // Iterate over the temporary list
+            foreach (var key in badgeKeys)
+            {
+                if (badgeStates.TryGetValue(key, out var state))
+                {
+                    SetBadge(key, state);
+                }
+            }
+        }
+
+        public void ClearChildMap()
+        {
+            childMap.Clear();
+        }
+
+        public void SetBadge(BadgeID id, bool saveState = true)
+        {
+            SetBadge(id, new BadgeState { Type = BadgeType.Symbol }, saveState);
+        }
+
+        public void SetBadge(BadgeID id, BadgeState state, bool saveState = true)
+        {
+            badgeStates[id] = state;
+            if (saveState) { SaveBadgeStates(); }
+            OnBadgeStateChanged?.Invoke(id);
+            PropagateBadgeState(id, saveState);
+        }
+
+        public BadgeState GetBadge(BadgeID id)
+        {
+            if (badgeStates.ContainsKey(id))
+            {
+                return badgeStates[id];
+            }
+            return new BadgeState { Type = BadgeType.None };
+        }
+
+        public void ClearBadge(BadgeID id)
+        {
+            if (badgeStates.ContainsKey(id))
+            {
+                badgeStates.Remove(id);
+                SaveBadgeStates();
+                OnBadgeStateChanged?.Invoke(id);
+                PropagateBadgeState(id, true);
+            }
+        }
+
+        private void SaveBadgeStates()
+        {
+            string json = JsonConvert.SerializeObject(badgeStates, Formatting.Indented);
+            File.WriteAllText(Application.persistentDataPath + "/badgeStates.json", json);
+        }
+
+        private void LoadBadgeStates()
+        {
+            string path = Application.persistentDataPath + "/badgeStates.json";
+            if (File.Exists(path))
+            {
+                string json = File.ReadAllText(path);
+                badgeStates = JsonConvert.DeserializeObject<Dictionary<BadgeID, BadgeState>>(json);
+            }
+            else
+            {
+                badgeStates = new Dictionary<BadgeID, BadgeState>();
+            }
+        }
+
+        private void PropagateBadgeState(BadgeID id, bool saveState)
+        {
+            // Propagate state to children
+            if (childMap.TryGetValue(id, out List<BadgeID> childIds))
+            {
+                foreach (var childId in childIds)
+                {
+                    PropagateBadgeState(childId, saveState);
+                }
+            }
+
+            // Check if the current badge should propagate an alert to its parent
+            foreach (var kvp in childMap)
+            {
+                if (kvp.Value.Contains(id))
+                {
+                    BadgeID parentId = kvp.Key;
+                    bool parentShouldHaveBadge = false;
+
+                    // Check if any child badge of the parent has an active badge state
+                    foreach (var childId in kvp.Value)
+                    {
+                        if (badgeStates.ContainsKey(childId) && badgeStates[childId].Type != BadgeType.None)
+                        {
+                            parentShouldHaveBadge = true;
+                            break;
+                        }
+                    }
+
+                    BadgeState parentState = GetBadge(parentId);
+                    if (parentShouldHaveBadge && parentState.Type == BadgeType.None)
+                    {
+                        parentState.Type = BadgeType.Symbol;
+                        SetBadge(parentId, parentState, saveState);
+                    }
+                    else if (!parentShouldHaveBadge && parentState.Type != BadgeType.None)
+                    {
+                        ClearBadge(parentId);
+                    }
+                }
+            }
+        }
+    }
+}