Unity universal red dot system

The red dot system is generally implemented by multi tree .
Trees ：

using System;
using System.Collections.Generic;
using UnityEngine;

[Serializable]
public class SGTreeNode
{
    
    [SerializeField]
    System.Object mData = null;
    [SerializeField]
    SGTreeNode mParent = null;
    [SerializeField]
    List<SGTreeNode> mChildren = null;
    [SerializeField]
    bool mIsLeaf = true;

    public bool IsLeaf {
     get {
     return mIsLeaf; } }
    public SGTreeNode Parent {
     get {
     return mParent; } }
    public List<SGTreeNode> Children {
     get {
     return mChildren; } }

    public SGTreeNode(System.Object data)
    {
    
        mChildren = new List<SGTreeNode>();
        mData = data;
    }

    public System.Object GetData() 
    {
    
        return mData;
    }

    public SGTreeNode SearchNode(Predicate<System.Object> compare)
    {
    
        if (compare.Invoke(mData))
        {
    
            return this;
        }
        else
        {
    
            SGTreeNode searchedNode = null;
            foreach (var item in mChildren)
            {
    
                if (compare.Invoke(item.mData))
                {
    
                    searchedNode = item;
                }
                else
                {
    
                    searchedNode = item.SearchNode(compare); 
                }
                if (searchedNode != null)
                {
    
                    break;
                }
            }
            return searchedNode;
        }
    }

    public SGTreeNode AddChild(SGTreeNode child)
    {
    
        this.mIsLeaf = false;
        child.mParent = this;
        mChildren.Add(child);
        return child;
    }
}

Red dot Manager ：
See initialization for the following tree structure of the red dot system .

using SG.Utils;
using System;
using System.Collections.Generic;
using UnityEngine;

public enum RedPointType
{
    
    Null,
    Root,// Red dot system root node 
    Task,// Task node 
    SignIn,// Sign in 
    DailyTask, // Daily tasks 
    DailyTaskItem, // Daily specific items 
    WeeklyTask,// Weekly task 
    WeeklyTaskItem,// Specific tasks of each week 
    AchievementTask,// Achievement task 
    AchievementTaskItem,// Achieve specific tasks 


}

public enum RedPointEvent
{
    
    RefreshRedPoint,
}

public class RedPointData
{
    
    public RedPointType mType = RedPointType.Null;
    public bool mIsShow = false;
    public Dictionary<string, bool> mExtDatas = new Dictionary<string, bool>();
    public int mRedCount = 0;

    public RedPointData(RedPointType type)
    {
    
        mType = type;
        mIsShow = false;
    }
}


public class RedPointManager2 :  MonoSingleton<RedPointManager2>
{
    
    [SerializeField]
    SGTreeNode mRootNode = null;

    /// <summary>
    ///  Initialize the red dot system 
    /// </summary>
    public new void Init()
    {
    
        mRootNode = new SGTreeNode(new RedPointData(RedPointType.Root));
        
        var taskNode = mRootNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.Task)));
        var signNode = taskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.SignIn)));
        var dailyTaskNode = taskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.DailyTask)));
        var weeklyTaskNode = taskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.WeeklyTask)));
        var achievementTaskNode = taskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.AchievementTask)));

        dailyTaskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.DailyTaskItem)));
        weeklyTaskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.WeeklyTaskItem)));
        achievementTaskNode.AddChild(new SGTreeNode(new RedPointData(RedPointType.AchievementTaskItem)));
    }

    /// <summary>
    ///  Refresh whether the red dot is displayed according to the red dot type . notes ： Only the leaf node small red dot data can be refreshed 
    /// </summary>
    /// <param name="redPointType"></param>
    /// <param name="isShow"></param>
    public void UpdateRedPoint(RedPointType redPointType, bool isShow)
    {
    
        var node = SearchNode(redPointType);

        if (node != null)
        {
    
            if (node.IsLeaf)
            {
    
                var data = node.GetData() as RedPointData;
                data.mIsShow = isShow;
                data.mRedCount = 1;
                UpdateParent(node.Parent);
                SendRefreshRedPointEvent(node);
            }
        }
    }

    /// <summary>
    ///  Refresh whether the red dot is displayed according to the red dot type . notes ： Only the leaf node small red dot data can be refreshed 
    /// </summary>
    /// <param name="redPointType"></param>
    /// <param name="extData"> The current red dot type contains multiple red dot data </param>
    public void UpdateRedPoint(RedPointType redPointType, Dictionary<string, bool> extData)
    {
    
        var node = SearchNode(redPointType);

        if (node != null)
        {
    
            if (node.IsLeaf)
            {
    
                var data = node.GetData() as RedPointData;
                var isShow = false;
                var showCount = 0;
                foreach (var item in extData)
                {
    
                    isShow = item.Value || isShow;
                    if (item.Value)
                    {
    
                        showCount++;
                    }
                    data.mExtDatas.Remove(item.Key);
                    data.mExtDatas[item.Key] = item.Value;
                }
                data.mIsShow = isShow;
                data.mRedCount = showCount;
                UpdateParent(node.Parent);
                SendRefreshRedPointEvent(node);
            }
        }
    }

    /// <summary>
    ///  Get red dot data information 
    /// </summary>
    /// <param name="redPointType"></param>
    /// <returns></returns>
    public RedPointData GetRedPointData(RedPointType redPointType)
    {
    
        var node = SearchNode(redPointType);
        if (node != null)
        {
    
            return node.GetData() as RedPointData;
        }
        else
        {
    
            return null;
        }
    }

    SGTreeNode SearchNode(RedPointType redPointType)
    {
    
        var node = mRootNode.SearchNode(new Predicate<object>(delegate (object nodeData) {
    
            RedPointData data = nodeData as RedPointData;
            if (data != null)
            {
    
                return data.mType == redPointType;
            }
            else
            {
    
                return false;
            }
        }));
        return node;
    }

    
    RedPointData GetNodeData(SGTreeNode node)
    {
    
        return node.GetData() as RedPointData;
    }

    void UpdateParent(SGTreeNode node)
    {
    
        if (node != null && !node.IsLeaf)
        {
    
            if (node.Children.Count > 0)
            {
    
                int redCount = 0;
                bool isShow = false;
                foreach (var item in node.Children)
                {
    
                    var dataTemp = GetNodeData(item);
                    isShow = isShow || dataTemp.mIsShow;
                    if (GetNodeData(item).mIsShow)
                    {
    
                        redCount = redCount + dataTemp.mRedCount;
                    }
                }
                var data = node.GetData() as RedPointData;
                data.mIsShow = isShow;
                data.mRedCount = redCount;
            }
            UpdateParent(node.Parent);
        }
    }

    void SendRefreshRedPointEvent(SGTreeNode node)
    {
    
        if (node != null)
        {
    
            GameEventMgr.Instance.SendEvent(RedPointEvent.RefreshRedPoint, new GameEventMgr.GameEventArgs()
            {
    
                data = node.GetData()
            });
            SendRefreshRedPointEvent(node.Parent);
        }
    }
}

Examples of use ：

 void TestRedPoint()
    {
    
        GameEventMgr.Instance.RemoveEvent(RedPointEvent.RefreshRedPoint, OnEventUpdateRedPoint);
        GameEventMgr.Instance.AddEvent(RedPointEvent.RefreshRedPoint, OnEventUpdateRedPoint);

        Debug.Log("=========UpdateRedPoint:SignIn");
        RedPointManager2.Instance.UpdateRedPoint(RedPointType.SignIn, true);
        
        Debug.Log("=========UpdateRedPoint:DailyTaskItem 1");
        RedPointManager2.Instance.UpdateRedPoint(RedPointType.DailyTaskItem, true);

        Debug.Log("=========UpdateRedPoint:DailyTaskItem 2");
        Dictionary<string, bool> mData = new Dictionary<string, bool>();
        mData["1000"] = true;
        mData["1001"] = true;
        mData["1002"] = false;
        RedPointManager2.Instance.UpdateRedPoint(RedPointType.DailyTaskItem, mData);
    }

    void OnEventUpdateRedPoint(AEventArgs arg)
    {
    
        var temp = arg as GameEventMgr.GameEventArgs;
        var data = temp.data as RedPointData;
       
        Debug.Log("===========TestEvent:" + LitJson.JsonMapper.ToJson(data));
    }

Output ：