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]];
}
}
}
}
void PeekNode(RedPointNode node, string nodeName, out RedPointNode ret)
{
if (node.name == nodeName)
{
ret = node;
return;
}
if (node.childNodes.ContainsKey(nodeName))
{
ret = node.childNodes[nodeName];
return;
}
foreach (var kv in node.childNodes)
{
PeekNode(kv.Value, nodeName, out ret);
if (ret != null)
{
return;
}
}
ret = null;
}
void Start()
{
RedPointNode node_player = new RedPointNode("Player");
node_player.BindUI(m_User);
RedPointNode node_Task = new RedPointNode("Task");
node_Task.BindUI(m_Task);
node_SingleTask = new RedPointNode("Task.Single");
node_SingleTask.BindUI(m_TaskSingle);
node_DailyTask = new RedPointNode("Task.Daily");
node_DailyTask.BindUI(m_TaskDaily);
node_DailyTask.SetNum(2);
node_Task.AddChild(node_SingleTask);
node_Task.AddChild(node_DailyTask);
//RedPointSystem.S.AddRedPointNode(node_Task);
node_player.AddChild(node_Task);
// RedPointSystem.S.GetRedPointNode("Player").AddChild(node_SingleTask);
// RedPointSystem.S.GetRedPointNode("Player").AddChild(node_DailyTask);
RedPointSystem.S.Refesh();
}
/// <summary>
/// 树结构设置事件回调
/// </summary>
/// <param name="_nodeName"></param>
/// <param name="_callback"></param>
public void SetRedPointCallBack(string _nodeName, OnPointNumChange _callback)
{
RedPointNode _root = mRoot;
string[] _nodeNameArr = _nodeName.Split('.');
if (_nodeNameArr.Length == 1)
{
if (_nodeNameArr[0] != RedPointConst.MAIN)
{
Debug.LogError("Node Error:" + _nodeNameArr[0]);
return;
}
}
for (int i = 0; i < _nodeNameArr.Length; i++)
{
if (!_root.nodeChilds.ContainsKey(_nodeNameArr[i]))
{
Debug.LogError("This Node not Contains Child " + _nodeNameArr[i]);
return;
}
_root = _root.nodeChilds[_nodeNameArr[i]];
if (i == _nodeNameArr.Length - 1)
{
_root.PointNumChange = _callback;
return;
}
}
}
/// <summary>
/// 通过Key获取到对应到节点，必须从根节点开始
/// </summary>
/// <param name="fullKey">例如：Root.Main.Mail</param>
public int GetIdByKey(string fullKey)
{
string[] splits = fullKey.Split('.');
RedPointNode node = rootNode;
if (!splits[0].Equals(node.key))
{
Debug.LogErrorFormat("<RedPointMgr> {0}需要从根节点{1}开始！", fullKey, node.key);
return(-1);
}
int id = node.id;
for (int j = 1; j < splits.Length; j++)
{
string key = splits[j];
if (!node.childDicByKey.TryGetValue(key, out id))
{
Debug.LogErrorFormat("<RedPointMgr> 节点{0}不存在！", key);
return(-1);
}
//节点存在，继续查找
node = nodeDic[id];
}
return(id);
}
void Start()
{
var demoModule = new DemoRedPointModule();
RedPointSystem.S.AddModule("Demo", demoModule);
RedPointNode node1 = new RedPointNode();
RedPointNode node2 = new RedPointNode();
RedPointNode node3 = new RedPointNode();
RedPointNode node1_1 = new RedPointNode();
RedPointNode node1_2 = new RedPointNode();
// RedPointNode node1_3 = new RedPointNode();
node1.AddNode(node1_1);
node1.AddNode(node1_2);
// node1.AddNode(node1_3);
demoModule.RootNode.AddNode(node1);
demoModule.RootNode.AddNode(node2);
demoModule.RootNode.AddNode(node3);
RedPointSystem.S.Refesh();
m_NodeRoot.BindNode(demoModule.RootNode);
m_Node1.BindNode(node1);
m_Node2.BindNode(node2);
m_Node3.BindNode(node3);
m_Node1_1.BindNode(node1_1);
m_Node1_2.BindNode(node1_2);
}
/// <summary>
/// 动态添加一个有红点功能标签：例如道具背包中的每个item上的New功能。
/// 此时，每个Item都应该为一个叶子节点，此时只需为每个Item设置一个独有的Key
/// </summary>
/// <param name="fullKey">Tag应该具有完整的父子级关系, 需要从根节点开始</param>
public int AddDynamicFullKey(string fullKey)
{
string[] splits = fullKey.Split('.');
RedPointNode node = rootNode;
if (!splits[0].Equals(node.key))
{
Debug.LogErrorFormat("<RedPointMgr> {0}需要从根节点{1}开始", fullKey, node.key);
return(-1);
}
int leafNodeId = 0;
for (int j = 1; j < splits.Length; j++)
{
string key = splits[j];
//节点存在，继续查找
if (node.childDicByKey.TryGetValue(key, out leafNodeId))
{
node = nodeDic[leafNodeId];
continue;
}
//节点不存在，需要创建一个节点
leafNodeId = ++_index;
RedPointNode childNode = AddNode(leafNodeId, key, node.id);
node.AddChild(childNode);
node = childNode;
}
if (!node.IsLeafNode())
{
Debug.LogErrorFormat("<RedPointMgr> {0}不是叶子节点！", fullKey);
return(-1);
}
return(leafNodeId);
}
private RedPointNode AddNode(int id, string key, int parentId)
{
RedPointNode node = new RedPointNode(id, key, parentId);
nodeDic.Add(id, node);
return(node);
}
private string GetKey(int id, string subfix = null)
{
string key;
int parentId;
if (Application.isPlaying)
{
RedPointNode node = RedPointMgr.Inst.nodeDic[id];
key = node.key;
parentId = node.parentId;
}
else
{
RedPointAssetCfg cfg = _nodeDic[id];
key = cfg.key;
parentId = cfg.parentId;
}
if (string.IsNullOrEmpty(subfix))
{
subfix = key;
}
else
{
subfix = key + "." + subfix;
}
if (parentId == -1) //已经达到根节点了
{
return(subfix);
}
return(GetKey(parentId, subfix));
}
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);
}
/// <summary>
/// 初始化
/// </summary>
public void InitRedPointTreeNode()
{
_rootNode = new RedPointNode
{
NodeName = RedPointConst.MAIN
};
for (int i = 0; i < RedPointTreeList.Count; i++)
{
var node = _rootNode;
var treeNodeArray = RedPointTreeList[i].Split('.');
if (!treeNodeArray[0].Equals(_rootNode.NodeName))
{
Debug.LogError("red point tree root node error :" + treeNodeArray[0]);
continue;
}
if (treeNodeArray.Length > 1)
{
for (int j = 1; j < treeNodeArray.Length; j++)
{
if (!node.ChildDict.ContainsKey(treeNodeArray[j]))
{
node.ChildDict.Add(treeNodeArray[j], new RedPointNode());
}
node.ChildDict[treeNodeArray[j]].NodeName = treeNodeArray[j];
node.ChildDict[treeNodeArray[j]].Parent = node;
node = node.ChildDict[treeNodeArray[j]];
}
}
}
}
public void BindNode(RedPointNode node)
{
m_Node = node;
m_Node.OnNumChange += UpdateNum;
UpdateUI();
UpdateNum();
}
/// <summary>
/// 修改指定节点的红点数，默认只能修改叶子节点的数量
/// </summary>
/// <param name="checkEndNode">检查节点是否为叶子节点，默认为true.</param>
public void SetPointNum(int id, int num, bool checkEndNode = true)
{
RedPointNode node = nodeDic[id];
if (checkEndNode && !node.IsLeafNode())
{
Debug.LogErrorFormat("<RedPointMgr> {0}节点不是叶子节点，请检查是否要进行此操作！", node.key);
return;
}
node.SetPointNum(num);
}
//添加子节点
public void AddChild(RedPointNode child)
{
childs.Add(child.id);
if (childDicByKey.ContainsKey(child.key))
{
Debug.LogErrorFormat("<RedPointNode> 节点：{0}中，有相同Key的子节点：{1}", key, child.key);
}
else
{
childDicByKey.Add(child.key, child.id);
}
}
/// <summary>
/// 依據指定的節點名稱建立出對應的節點樹
/// </summary>
/// <param name="parentNodeName"></param>
/// <param name="children"></param>
private void CreateNode(string parentNodeName, Type children)
{
var parentNode = Find(parentNodeName);
foreach (var obj in Enum.GetValues(children))
{
// var n = obj.ToString();
var n = obj.GetType().Name + obj;
var node = new RedPointNode(n);
parentNode.AddChild(node);
}
}
/// <summary>
/// 設置紅點點數
/// </summary>
/// <param name="value"></param>
protected void SetNumCount(int value)
{
if (!RedPointNode.HasChildren())
{
RedPointNode.NumCount = value;
}
var total = RedPointNode.TotalNumCount();
redPointDisplayImp.SetNumCount(total.ToString());
SetVisibleImage(total > 0);
}
/// <summary>
/// 依據 RedPointTreeMap 建立關聯節點
/// </summary>
/// <param name="treeMap"></param>
private void CreateTreeMap(IRedPointTreeMap treeMap)
{
_root = new RedPointNode(RootName);
foreach (var e in Enum.GetValues(treeMap.Nodes))
{
// var n = e.ToString();
var n = e.GetType().Name + e;
var node = new RedPointNode(n);
_root.Children.Add(node);
}
foreach (var parent in treeMap.Tree.Keys)
{
var children = treeMap.Tree[parent];
CreateNode(parent, children);
}
}
/// <summary>
/// 强行设置节点的红点数
/// </summary>
/// <param name="isTrigger">是否Trigger事件</param>
public void SetPointNum(int num, bool isTrigger = true)
{
if (pointNum == num)
{
return;
}
if (parentId > 0)//不是根节点
{
int changeNum = num - pointNum;
RedPointNode parentNode = RedPointMgr.Inst.nodeDic[parentId];
parentNode.SetPointNum(parentNode.pointNum + changeNum, isTrigger);
}
pointNum = num;
if (isTrigger)
{
TriggerEvent(false);
}
}
/// 为parentId所在的节点，添加子节点
/// <param name="key">叶子节点key</param>
/// <param name="parentId">父节点id</param>
public int AddDynamicKey(string key, int parentId)
{
RedPointNode parentNode = nodeDic[parentId];
int id;
if (parentNode.childDicByKey.TryGetValue(key, out id))
{
if (!nodeDic[id].IsLeafNode())
{
Debug.LogErrorFormat("<RedPointMgr> {0}不是叶子节点！", key);
return(-1);
}
return(id);
}
id = ++_index;
RedPointNode childNode = AddNode(id, key, parentNode.id);
parentNode.AddChild(childNode);
return(id);
}
public void SetRedPoint(string nodeName, int num)
{
var nodeNameArr = nodeName.Split('.');
if (nodeNameArr.Length == 0)
{
return;
}
nodeName = nodeNameArr[nodeNameArr.Length - 1];
RedPointNode node = PeekNode(rootNode, nodeName);
//RedPointNode node = null;
//PeekNode(rootNode, nodeName, out node);
if (node != null)
{
node.num = num;
}
else
{
UnityEngine.Debug.LogError("[SetRedPoint] not found node => " + nodeName);
}
}
RedPointNode PeekNode(RedPointNode node, string nodeName)
{
if (node.name == nodeName)
{
return(node);
}
if (node.childNodes.ContainsKey(nodeName))
{
return(node.childNodes[nodeName]);
}
foreach (var kv in node.childNodes)
{
var result = PeekNode(kv.Value, nodeName);
if (result != null)
{
return(result);
}
}
return(null);
}
/// <summary>
/// 依據節點名稱遍尋出指定的節點
/// </summary>
/// <param name="node"></param>
/// <param name="n"></param>
/// <returns></returns>
private RedPointNode Find(RedPointNode node, string n)
{
if (node == null)
{
return(null);
}
foreach (var child in node.Children)
{
RedPointNode targetNode = null;
if (child.Name.Equals(n))
{
targetNode = child;
return(targetNode);
}
targetNode = Find(child, n);
if (targetNode != null)
{
return(targetNode);
}
}
return(null);
}
public void RegisterEvent(string nodeName, OnRedPointNumChange onRedPointNumChange)
{
var nodeNameArr = nodeName.Split('.');
if (nodeNameArr.Length == 0)
{
return;
}
nodeName = nodeNameArr[nodeNameArr.Length - 1];
RedPointNode node = PeekNode(rootNode, nodeName);
//RedPointNode node = null;
//PeekNode(rootNode, nodeName, out node);
if (node != null)
{
node.OnRedPointNumChange = onRedPointNumChange;
}
else
{
UnityEngine.Debug.LogError("[RegisterEvent] not found node => " + nodeName);
}
}
/// <summary>
/// 初始化红点系统
/// </summary>
public void Init()
{
RedPointTrees.Add(RedPointConst.MAIN);
RedPointTrees.Add(RedPointConst.MAIL);
RedPointTrees.Add(RedPointConst.TASK);
RedPointTrees.Add(RedPointConst.ALLIANCE);
RedPointTrees.Add(RedPointConst.MAIL_ALLIANCE);
RedPointTrees.Add(RedPointConst.MAIL_SYSTEM);
RedPointTrees.Add(RedPointConst.MAIL_TEAM);
mRoot = new RedPointNode();
mRoot.NodeName = RedPointConst.MAIN;
foreach (string _nodeName in RedPointTrees)
{
RedPointNode _root = mRoot;
string[] _nodeNameArr = _nodeName.Split('.');
if (_nodeNameArr[0] != _root.NodeName)
{
Debug.LogWarning("node error:" + _nodeNameArr[0]);
continue;
}
if (_nodeNameArr.Length > 1)
{
for (int i = 0; i < _nodeNameArr.Length; i++)
{
if (!_root.nodeChilds.ContainsKey(_nodeNameArr[i]))
{
_root.nodeChilds.Add(_nodeNameArr[i], new RedPointNode());
}
_root.nodeChilds[_nodeNameArr[i]].NodeName = _nodeNameArr[i];
_root.nodeChilds[_nodeNameArr[i]].Parent = _root;
_root = _root.nodeChilds[_nodeNameArr[i]];
}
}
}
}
public static RedPointNode Create(RedPointNode parent, string redPointPath, ERedTreeRefreshType refreshType = ERedTreeRefreshType.OpenWindow, bool isShowCount = false)
{
RedPointNode node = new RedPointNode();
node.Parent = parent;
node.redPointPath = redPointPath;
node.refreshType = refreshType;
node.isShowCount = isShowCount;
if (redPointPath != "")
{
node.windowName = redPointPath.Substring(0, redPointPath.IndexOf('/'));
Dictionary <string, Dictionary <ERedTreeRefreshType, List <RedPointNode> > > dic = RedPointTree.Singleton.windowName2NodeDic;
if (!dic.ContainsKey(node.windowName))
{
dic.Add(node.windowName, new Dictionary <ERedTreeRefreshType, List <RedPointNode> >());
}
if (!dic[node.windowName].ContainsKey(refreshType))
{
dic[node.windowName].Add(refreshType, new List <RedPointNode>());
}
dic[node.windowName][refreshType].Add(node);
}
return(node);
}
public void Init()
{
rootNode = new RedPointNode();
rootNode.name = RedPointEnum.Main;
for (var i = 0; i < listConfig.Count; i++)
{
var node = rootNode;
var arraySplit = listConfig[i].Split('.');
if (arraySplit.Length > 1)
{
for (int j = 0; j < arraySplit.Length; j++)
{
if (!node.childNodes.ContainsKey(arraySplit[j]))
{
node.childNodes.Add(arraySplit[j], new RedPointNode());
}
node.childNodes[arraySplit[j]].name = arraySplit[j];
node.childNodes[arraySplit[j]].parent = node;
node = node.childNodes[arraySplit[j]];
}
}
}
}
private void OnMailRedPointChange(RedPointNode node)
{
ImgMail.gameObject.SetActive(node.PointNum > 0);
TexMail.text = node.PointNum.ToString();
}
private void MailAllianceCB(RedPointNode _node)
{
//UI层表现
}
private void TaskCB(RedPointNode _node)
{
//UI层表现
}
private void MailSystemCB(RedPointNode _node)
{
//UI层表现
}
