红点系统

最新推荐文章于 2024-07-23 17:51:42 发布
最新推荐文章于 2024-07-23 17:51:42 发布
阅读量742 收藏 2
点赞数
分类专栏： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33950757/article/details/109692228
版权
本文介绍了Unity中的Red Dot Manager类及其关联组件，展示了如何使用红点类型来标记未读邮件，通过RedDotItem和RedDotBase子类实现不同邮件类型的红点显示，并通过MailManager管理全局红点状态。同时，邮件按钮点击事件触发红点更新和邮件状态的同步。
摘要由CSDN通过智能技术生成

01.RedManager
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

 public enum RedDotType:ushort
{
    None=0,
    Email_UnReadSstem=1,
    Email_UnReadPlayer=2,
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class RedDotItem : MonoBehaviour
{
    //红点物体
    [SerializeField]
    private GameObject GO_RedDot;
    //红点类型
    public List<RedDotType> redDotTypes;
    private bool bCacheRedDot = false;
    void Start()
    {
        RedDotManager.Instance.RegisterRedDot(redDotTypes, this);
        bool bRedDot = RedDotManager.Instance.Check(redDotTypes);
        SetData(bRedDot, true);
    }


    public void SetData(bool bRedDot,bool bForceRefresh=false)
    {
        if (bForceRefresh)
        {
            GO_RedDot.SetActive(bRedDot);
            bCacheRedDot = bRedDot;
            return;
        }
        if (bCacheRedDot != bRedDot)
        {
            GO_RedDot.SetActive(bRedDot);
            bCacheRedDot = bRedDot;
        }
    }

    public List<RedDotType> GetRedDotTypes()
    {
        return this.redDotTypes;
    }


    private void OnDestroy()
    {
        RedDotManager.Instance.UnRegisterRedDot(this);
    }


}


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

public abstract class RedDotBase
{
    public virtual bool ShowRedDot(object[] objs)
    {
        return false;
    }
}


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

public class RedDot_EmailUnReadSystem : RedDotBase
{
    public override bool ShowRedDot(object[] objs)
    {
        return MailManager.Instance.IsSystemRedDot();
    }
}


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

public class RedDot_EmailUnReadPlayer : RedDotBase
{
    public override bool ShowRedDot(object[] objs)
    {
        return MailManager.Instance.IsPlayerRedDot();
    }
}


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

public class MailManager
{
    private static MailManager _inctance;
    public static MailManager Instance
    {
        get
        {
            if (_inctance == null)
            {
                _inctance = new MailManager();
            }
            return _inctance;
        }
    }

    private bool bSystemRedDot = true;
    public bool IsSystemRedDot()
    {
        return bSystemRedDot;
    }

    public void SetSystemRedDot(bool bRedDot)
    {
        this.bSystemRedDot = bRedDot;
    }
    private bool bPlayerRedDot = true;

    public bool IsPlayerRedDot()
    {
        return bPlayerRedDot;
    }

    public void SetPlayerRedDot(bool bRedDot)
    {
        this.bPlayerRedDot = bRedDot;
    }
}



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

public class RedDotManager 
{
    private static RedDotManager _inctance;
    public static RedDotManager Instance
    {
        get
        {
            if (_inctance == null)
            {
                _inctance = new RedDotManager();
            }
            return _inctance;
        }
    }
    //红点数据
    Dictionary<RedDotType, RedDotBase> RedDotConditionDict = new Dictionary<RedDotType, RedDotBase>();
    //红点物体
    Dictionary<RedDotType, List<RedDotItem>> RedDotObjDict = new Dictionary<RedDotType, List<RedDotItem>>();

    public void Initilize()
    {
        RedDotConditionDict.Clear();
        RedDotConditionDict.Add(RedDotType.Email_UnReadSstem,new RedDot_EmailUnReadSystem());
        RedDotConditionDict.Add(RedDotType.Email_UnReadPlayer, new RedDot_EmailUnReadPlayer());
    }

    // 注册红点
    public void RegisterRedDot(List<RedDotType> redDotTypes,RedDotItem item)
    {
        for (int i=0;i<redDotTypes.Count; i++)
        {
            RegisterRedDot(redDotTypes[i], item);
        }
    }

    private void RegisterRedDot(RedDotType redDotType, RedDotItem item)
    {
        if (RedDotObjDict.ContainsKey(redDotType))
        {
            RedDotObjDict[redDotType].Add(item);
        }
        else
        {
            List<RedDotItem> items = new List<RedDotItem>();
            items.Add(item);
            RedDotObjDict.Add(redDotType,items);
        }
    }

    //取消注册红点
    public void UnRegisterRedDot(RedDotItem item)
    {
        Dictionary<RedDotType, List<RedDotItem>>.Enumerator itor = RedDotObjDict.GetEnumerator();
        while (itor.MoveNext())
        {
            List<RedDotItem> redDotItems = itor.Current.Value;
            if (redDotItems.Contains(item))
            {
                redDotItems.Remove(item);
                break;
            }
        }
    }
    // 检查红点提示
    public bool Check(List<RedDotType> redDotTypes, object[] objs = null)
    {
        for (int i = 0; i < redDotTypes.Count; i++)
        {
            if (Check(redDotTypes[i], objs))
            {
                return true;
            }
        }
        return false;
    }
    private bool Check(RedDotType redDotType, object[] objs)
    {
        if (RedDotConditionDict.ContainsKey(redDotType))
        {
            return RedDotConditionDict[redDotType].ShowRedDot(objs);
        }
        return false;
    }
    // 更新该类型的所有红点组件
    public void NotifyAll(RedDotType redDotType, object[] objs = null)
    {
        if (RedDotObjDict.ContainsKey(redDotType))
        {
            for (int i = 0; i < RedDotObjDict[redDotType].Count; i++)
            {
                RedDotItem item=RedDotObjDict[redDotType][i];
                if (item!=null)
                {
                    List<RedDotType> redDotTypes=item.GetRedDotTypes();
                   bool bCheck=Check(redDotTypes, objs);
                    item.SetData(bCheck);
                }
            }
        }
    }
}


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class UIEmail : MonoBehaviour
{
    /// <summary>
    /// 系统邮件按钮;
    /// </summary>
    [SerializeField]
    Button Button_EmailSystem;
    /// <summary>
    /// 玩家邮件按钮;
    /// </summary>
    [SerializeField]
    Button Button_EmailPlayer;

    void Awake()
    {
        // 注意这个函数只需要初始化一次;
        RedDotManager.Instance.Initilize();
    }

    // Use this for initialization
    void Start()
    {
        // 设置按钮回调;
        Button_EmailSystem.onClick.AddListener(OnClickEmailSystem);
        Button_EmailPlayer.onClick.AddListener(OnClickEmailPlayer);

    }

    /// <summary>
    /// 系统按钮的回调;
    /// </summary>
    void OnClickEmailSystem()
    {
        // 点击之后表示邮件读取过了,设置邮件为已读状态;
        // (注意这里不能够设置红点的显隐,因为是有数据控制的,所以要控制数据那边的红点逻辑);
        // RedDot.RedDotManager.Instance.SetData(RedDot.RedDotType.Email_UnRead,false);

        MailManager.Instance.SetSystemRedDot(false);
        RedDotManager.Instance.NotifyAll(RedDotType.Email_UnReadSstem);
    }

    /// <summary>
    /// 玩家按钮的回调;
    /// </summary>
    void OnClickEmailPlayer()
    {
        // 点击之后表示邮件读取过了,设置邮件为已读状态;
        // (注意这里不能够设置红点的显隐,因为是有数据控制的,所以要控制数据那边的红点逻辑);
        // RedDot.RedDotManager.Instance.SetData(RedDot.RedDotType.Email_UnRead,false);

        MailManager.Instance.SetPlayerRedDot(false);
        RedDotManager.Instance.NotifyAll(RedDotType.Email_UnReadPlayer);
    }
}


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

public class RedPointNode
{
    public string nodeName;// 节点名称
    public int pointNum = 0;// 红点数量
    public RedPointNode parent = null;// 父节点
    public RedPointSystem.OnPointNumChange numChangeFunc; // 发生变化的回调函数

    // 子节点
    public Dictionary<string, RedPointNode> dicChilds = new Dictionary<string, RedPointNode>();

    /// <summary>
    /// 设置当前节点的红点数量
    /// </summary>
    /// <param name="rpNum"></param>
    public void SetRedPointNum(int rpNum)
    {
        if (dicChilds.Count > 0) // 红点数量只能设置叶子节点
        {
            Debug.LogError("Only Can Set Leaf Node!");
            return;
        }
        pointNum = rpNum;

        NotifyPointNumChange();
        if (parent != null)
        {
            parent.ChangePredPointNum();
        }
    }

    /// <summary>
    /// 计算当前红点数量
    /// </summary>
    public void ChangePredPointNum()
    {
        int num = 0;
        foreach (var node in dicChilds.Values)
        {
            num += node.pointNum;
        }
        if (num != pointNum) // 红点有变化
        {
            pointNum = num;
            NotifyPointNumChange();
        }
    }

    /// <summary>
    /// 通知红点数量变化
    /// </summary>
    public void NotifyPointNumChange()
    {
        numChangeFunc?.Invoke(this);
    }

}

public class RedPointConst
{
    public const string main = "Main";// 主界面
    public const string mail = "Main.Mail";// 主界面邮件按钮
    public const string mailSystem = "Main.Mail.System";// 邮件系统界面
    public const string mailTeam = "Main.Mail.Team";// 邮件队伍界面
    public const string mailAlliance = "Main.Mail.Alliance";// 邮件公会界面

    public const string task = "Main.Task";// 主界面任务按钮

    public const string alliance = "Main.Alliance";// 主界面公会按钮
}


public class RedPointSystem
{
    public delegate void OnPointNumChange(RedPointNode node);// 红点变化通知
    RedPointNode mRootNode; // 红点树Root节点

    static List<string> lstRedPointTreeList = new List<string> // 初始化红点树
    {
        RedPointConst.main,
        RedPointConst.mail,
        RedPointConst.mailSystem,
        RedPointConst.mailTeam ,
        RedPointConst.mailAlliance ,

        RedPointConst.task,

        RedPointConst.alliance,
    };

    public void InitRedPointTreeNode()
    {
        mRootNode = new RedPointNode();
        mRootNode.nodeName = RedPointConst.main;

        foreach (var s in lstRedPointTreeList)
        {
            var node = mRootNode;
            var treeNodeAy = s.Split('.');
            if (treeNodeAy[0] != mRootNode.nodeName)
            {
                Debug.Log("RedPointTree Root Node Error:" + treeNodeAy[0]);
                continue;
            }
            if (treeNodeAy.Length > 1)
            {
                for (int i = 1; i < treeNodeAy.Length; i++)
                {
                    if (!node.dicChilds.ContainsKey(treeNodeAy[i]))
                    {
                        node.dicChilds.Add(treeNodeAy[i], new RedPointNode());
                    }
                    node.dicChilds[treeNodeAy[i]].nodeName = treeNodeAy[i];
                    node.dicChilds[treeNodeAy[i]].parent = node;

                    node = node.dicChilds[treeNodeAy[i]];
                }
            }
        }
    }

    public void SetRedPointNodeCallBack(string strNode, RedPointSystem.OnPointNumChange callBack)
    {
        var nodeList = strNode.Split('.');// 分析树节点
        if (nodeList.Length == 1)
        {
            if (nodeList[0] != RedPointConst.main)
            {
                Debug.Log("Get Wrong Root Node! current is " + nodeList[0]);
                return;
            }
        }

        var node = mRootNode;
        for (int i = 1; i < nodeList.Length; i++)
        {
            if (!node.dicChilds.ContainsKey(nodeList[i]))
            {
                Debug.Log("Does Not Contains Child Node :" + nodeList[i]);
                return;
            }
            node = node.dicChilds[nodeList[i]];

            if (i == nodeList.Length - 1) // 最后一个节点了
            {
                node.numChangeFunc = callBack;
                return;
            }
        }
    }

    /// <summary>
    /// 激发数据变化
    /// </summary>
    /// <param name="nodeName"></param>
    /// <param name="rpNum"></param>
    public void SetInvoke(string strNode, int rpNum)
    {
        var nodeList = strNode.Split('.');// 分析树节点
        if (nodeList.Length == 1)
        {
            if (nodeList[0] != RedPointConst.main)
            {
                Debug.Log("Get Wrong Root Node! current is " + nodeList[0]);
                return;
            }
        }

        var node = mRootNode;
        for (int i = 1; i < nodeList.Length; i++)
        {
            if (!node.dicChilds.ContainsKey(nodeList[i]))
            {
                Debug.Log("Does Not Contains Child Node :" + nodeList[i]);
                return;
            }
            node = node.dicChilds[nodeList[i]];

            if (i == nodeList.Length - 1) // 最后一个节点了
            {
                node.SetRedPointNum(rpNum); // 设置节点的红点数量
            }
        }
    }



}


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

public class BootStart : MonoBehaviour
{
    public Image imgMail;
    public Image imgMailSystem;
    public Image imgMailTeam;

    public Text txtMail;
    public Text txtMailSystem;
    public Text txtMailTeam;

    private void Start()
    {
        RedPointSystem rps = new RedPointSystem();
        rps.InitRedPointTreeNode();

        // 设置 红点节点的处理函数
        rps.SetRedPointNodeCallBack(RedPointConst.mail, MailCallBack);
        rps.SetRedPointNodeCallBack(RedPointConst.mailSystem, MailSystemCallBack);
        rps.SetRedPointNodeCallBack(RedPointConst.mailTeam, MailTeamCallBack);

        // 激发节点变化
        rps.SetInvoke(RedPointConst.mailSystem,3);
        rps.SetInvoke(RedPointConst.mailTeam, 4);
    }

    void MailCallBack(RedPointNode node)
    {
        txtMail.text = node.pointNum.ToString();
        imgMail.gameObject.SetActive(node.pointNum > 0);

        Debug.Log(node.nodeName + " rp Num changed!  num = " + node.pointNum);
    }

    void MailSystemCallBack(RedPointNode node)
    {
        txtMailSystem.text = node.pointNum.ToString();
        imgMailSystem.gameObject.SetActive(node.pointNum > 0);
        Debug.Log(node.nodeName + " rp Num changed! num = " + node.pointNum);
    }

    void MailTeamCallBack(RedPointNode node)
    {
        txtMailTeam.text = node.pointNum.ToString();
        imgMailTeam.gameObject.SetActive(node.pointNum > 0);
        Debug.Log(node.nodeName + " rp Num changed! num = " + node.pointNum);
    }

}
唐孝辉
关注
专栏目录
【Unity游戏开发】基于前缀树的红点系统构思与客户端方案
米莱虾
08-16 1207
前段时间负责了项目中红点系统的实现，和大家分享一下初期是设计思路
c# Unity 红点系统终极版,完美解决红点处理问题.让你一行代码解决所有红点问题
07-07
1.用于游戏中需要红点,但是各各地方的构建导致代码结构杂乱 2.只需要一行代码即可解决红点问题 3.完美剥离代码与UI的关联 4.无论是邮件红点还是设置红点,一行代码搞定它! 5.先看用法再迁移,代码整合到RedDotManager中,使用的时候只需要这个代码即可 6.有Unity的日志,迁移到自己项目的时候注意修改 7.其实这个思路不管什么功能和项目都能用得上.需要的自取
【Unity】红点系统
2302_76830411的博客
10-09 1743
上面TODO要构建树结构，我们需要先定义树节点的名，按层级1|层级2|层级3/// 节点名。
Unity基于前缀树的红点系统优化--从零到一手撕并且优化
最新发布
qq_54351806的博客
07-23 909
本红点系统不能设置红点值,添加红点就是num++;只能对子节点进行修改,非子结点的值由系统来处理红点的键采用params string[] 作为键可以动态添加节点,只需要输入名字即可。
Unity--树实现的红点系统
qq_45071375的博客
01-10 3462
红点系统的简介 我们在平常生活中的软件中都能看到消息通知会在一些条目上会有红色的点点提示，我们在开发中也会遇到这样的情况，这就是我们平常说的红点系统。下面是我总结的红点系统的简单知识和今天的红点系统的示例： 下面就是实现以上代码的示例： 树结构的常量类 using System.Collections; using System.Collections.Generic; using Unity...
Unity 3D 红点系统
songhuanfei2017的博客
10-28 1491
定义常量： public class RedPointConst { public const string main = "Main"; public const string mail = "Main.Mail"; public const string mailSystem = "Main.Mail.System"; public const string...
Unity 游戏红点系统(Reddot System)
xdedzl的博客
08-02 5255
  游戏中按钮上经常会有一些用于提示玩家点击的小红点，显示方式可能不同，统称为红点系统。这里结合unity的GraphView做了一个通用的红点系统。   源码在这里红点系统，里面实现了一个简单demo 一.红点树编辑器   进入菜单 XFramework—>UI—>ReddotEditor 编辑红点树 二.ReddotManager 1.红点显示规则   需要显示红点的UI会注册一个节点的Key，可以是叶子结点也可以是非叶子结点。   在合适的时候会标记结点的状态（只能编辑叶子结点，非.
红点系统,游戏中的红点树
06-05
树的应用：游戏中的红点树，如何实现红点系统？ unity 2020 ...
前缀树Unity红点系统
02-21
前缀树Unity红点系统
Unity中基于前缀树的红点系统实现 (Unity + Lua + Prefix Tree) 红点系统.zip
01-22
Unity中基于前缀树的红点系统实现 (Unity + Lua + Prefix Tree) 红点系统是在大部分游戏中都能看到的常见功能需求。在相关的UI上亮起红点来提示玩家进行相关操作。 项目基于UnityXFramework框架，集成tolua，使用lua...
[unity] 游戏内的红点系统
hhh314159的博客
03-02 1621
在游戏中，通常需要给玩家提示一些未完成的任务或者活动，这些提示以红点的形式展示，被称为红点系统。红点系统可以帮助玩家了解当前有哪些任务或者活动需要完成，从而提高玩家的参与度和粘性。
Unity：红点系统
weixin_40097554的博客
11-15 1611
在我们日常的开发中，红点几乎是一个必不可少的流程。各类游戏或多或少都会有红点提示。想要实现红点这个功能其实我们也可以通过最简单的在某个地方放上一个红点的图片，然后根据条件来判断它是否需要显示。这么一来虽然可以实现这个功能，但是如果红点的数量较多，或者样式比较多，我们就会难以进行管理。所以我们在设计之初可以将它统一进行管理。在此之前大家可以看看这篇文章：https://blog.uwa4d.com/archives/USparkle_RedPoint.html我是在大佬的基础上进行的修改，这是大佬的知乎主页.
[Unity]红点系统
weixin_46472622的博客
06-20 738
参考大佬的lua 版本。
游戏服务器红点系统,Unity简易的红点系统RedPoint System
weixin_39776298的博客
08-10 2818
由于是展示，主要就三个脚本using System.Collections;using System.Collections.Generic;using UnityEngine;public class RedPointConst{public const string main = "Main";public const string mail = "Main.Mail";public cons...
[游戏开发]Unity红点系统
liuyongjie1992的博客
12-26 904
[游戏开发]红点系统
Unity 通用红点系统
lcl20093466的博客
07-27 1814
unity游戏开发通用红点系统
【功能】Unity 红点系统
TheBigBoy的博客
07-07 644
项目需求：提供一个共用的红点功能 设计：注册与反注册的管理器，定义红点枚举类型 连接管理器的基类，基类中提供外部调用的接口 实现： --红点类型 RedDotMgrType = { MailPanel_Red = 1, --邮件系统 } ---@private function RedDotMgr:ctor() self:Clear() end ---@private function RedDotMgr:Clear() self.msgMap = {} se...
【Unity】游戏开发中的树形结构——红点系统
NOBE
09-17 4547
游戏开发中最常见的用到树形结构的功能就是红点系统和行为树。 我今天先写一下红点系统的开发。
unity 界面红点
qq_42064172的博客
02-23 854
思路： 当前红点向上递归查询父级红点，由父级红点向下查询子级红点的状态来判定自身状态 配置部分 自定义红点id 此红点id的父级红点id 数据结构：class RedPoint int/EnumredPointType List ParentPoint List ChildPoint bool isShow 初始化数据 List AllRedPoint ;//存储所有表中数据 void SetDepe...
unity红点系统设计
03-28
Unity红点系统是一种常用的游戏UI设计，主要用于提醒玩家当前有新的任务、奖励或其他未读信息需要处理。下面是一个简单的Unity红点系统设计： 1. 定义红点控件：在UI界面中添加一个红点控件，通常是一个小圆点或小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值