0%

unity红点框架代码

最近公司项目做到了红点的步骤,之前的项目感觉红点架构感觉不太好用,于是我自己设计了一下。来上代码
先上C# 代码

预制体红点绑定这个 可以绑定lua文件 在lua检测红点条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/**
* 红点物体;
* RedDotItem.cs
**/
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using LuaInterface;

public class RedDotItem : MonoBehaviour
{
/// <summary>
/// lua文件;
/// </summary>
public string luaClassName;
/// <summary>
/// 红点物体;
/// </summary>
public GameObject Go_RedDot;
/// <summary>
/// 红点类型;
/// </summary>
public List<RedDotType> redDotTypes;
[SerializeField] private string curShowType;

private bool _isInit;
private LuaTable luaObj;
private LuaFunction fnCheckRedDot;
private int leftTime = -1;

public bool isInit
{
get
{
return this._isInit;
}
}

void Awake(){

if (luaClassName == null)
luaClassName = "MainRedDotHelp";
LuaBehaviourProxy obj = LuaBehaviourProxy.CreateLuaProxy(this.gameObject,luaClassName);
luaObj = obj.luaObj;
fnCheckRedDot = luaObj["CheckRedDot"] as LuaFunction;


if (Go_RedDot == null)
return;

this.Init();
}

void Start()
{
//设置红点;
this.CheckRedDot();
this.MoveTime();
}

public void Init()
{
if (_isInit)
return;
_isInit = true;

RedDotManager.Instance.RegisterRedDot(redDotTypes, this);

//设置红点;
this.CheckRedDot();
this.MoveTime();
}

public void Reset()
{
// 取消注册红点;
RedDotManager.Instance.UnRegisterRedDot(this);
// 清除类型
this.redDotTypes.Clear();
// 清除红点标记
this.Go_RedDot = null;
// 重新初始化
_isInit = false;
}

void OnDestroy()
{
//取消注册红点;
RedDotManager.Instance.UnRegisterRedDot(this);

//取消注册lua函数
if (fnCheckRedDot != null)
{
fnCheckRedDot.Dispose();
}
fnCheckRedDot = null;
luaObj = null;
}

public void MoveTime()
{
if (!this.isInit)
return;

if (leftTime > 0)
{
leftTime--;
}
this.SetData(leftTime == 0);
}

/// <summary>
/// 设置红点显示;
/// </summary>
/// <param name="bRedDot"></param>
public void SetData(bool bRedDot, bool bForceRefresh = false)
{
if (bForceRefresh && Go_RedDot.active != bRedDot)
{
Go_RedDot.SetActive(bRedDot);
return;
}

if (Go_RedDot.active != bRedDot)
{
Go_RedDot.SetActive(bRedDot);
}
}
/// <summary>
/// 获取当前物体挂载的所有红点;
/// </summary>
/// <returns></returns>
public List<RedDotType> GetRedDotTypes()
{
return this.redDotTypes;
}

/// 添加当前物体挂载的红点类型;
public void AddRedDotType(RedDotType rt = RedDotType.None)
{
if (rt != RedDotType.None){

if (redDotTypes == null)
redDotTypes = new List<RedDotType>();

if (!redDotTypes.Contains(rt))
{
redDotTypes.Add(rt);
}
CheckRedDot();
}
}

// 设置红点样式
public void SetRedDotNode(GameObject goRedDot)
{
this.Go_RedDot = goRedDot;
}

/// <summary>
/// 调用lua方法;
/// </summary>
/// <returns></returns>
public int CheckRedDot(RedDotType redDotType)
{
string rt = redDotType.ToString();

fnCheckRedDot.BeginPCall();
fnCheckRedDot.Push(luaObj);
fnCheckRedDot.Push(rt);
fnCheckRedDot.PCall();
int state = (int)fnCheckRedDot.CheckNumber();
fnCheckRedDot.EndPCall();

return state;
}

//检测单前对象所有类型红点
public void CheckRedDot()
{
if (!this.isInit)
return;

this.curShowType = "";
List<RedDotType> redDotTypes = this.GetRedDotTypes();
int tmpTime = -1;
for(int i = 0; i < redDotTypes.Count; i++)
{

int time = this.CheckRedDot(redDotTypes[i]);
if (time == 0)
{
this.leftTime = 0;
this.curShowType = redDotTypes[i].ToString();
return;
}

if (time > 0)
{
if (tmpTime == -1)
tmpTime = time;

if (tmpTime > time)
tmpTime = time;
}
}
this.leftTime = tmpTime;
}

/// <summary>
/// 检测红点返回值;
/// </summary>
/// <returns></returns>
public void ShowRedDot(RedDotType redDotType)
{

}
}


红点管理器可以导出lua之后调用更新

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/**
* 红点系统管理类;
* RedDotManager.cs
**/
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RedDotManager
{
private static RedDotManager _instance;
public static RedDotManager Instance
{
get
{
if (null == _instance)
{
_instance = new RedDotManager();
GameVars.tickUtils.SetInterval(1, _instance.UpdateAll);
}
return _instance;
}
}

/// <summary>
/// 红点物体;
/// </summary>
Dictionary<RedDotType, List<RedDotItem>> RedDotObjDict = new Dictionary<RedDotType, List<RedDotItem>>();
/// <summary>
/// 初始化红点系统(注意只需要初始化一次);
/// </summary>
public void Initilize()
{

}

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

/// <summary>
/// 通过gameObject注册红点;
/// </summary>
/// <param name="rt"> 类型</param>
/// <param name="item"> 添加的节点</param>
/// <param name="goRedDot"> 红点物体</param>
public void LuaRegisterRedDot(string rt, GameObject item,GameObject goRedDot)
{
RedDotType redDotType = (RedDotType)Enum.Parse(typeof(RedDotType),rt);
RedDotItem rItem = item.GetComponent<RedDotItem>();
if (rItem == null)
{
rItem = item.AddComponent<RedDotItem>();
rItem.AddRedDotType(redDotType);
rItem.SetRedDotNode(goRedDot);
}
else
{
if (!rItem.isInit)
{
rItem.Reset();
rItem.AddRedDotType(redDotType);
rItem.SetRedDotNode(goRedDot);
}
else
{
rItem.AddRedDotType(redDotType);
RegisterRedDot(redDotType,rItem);
}
}
}

/// <summary>
/// 取消注册红点;
/// </summary>
/// <param name="item"></param>
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;
}
}
}

// lua 调用
public void LuaNotifyAll(string rt, object obj = null)
{
RedDotType cc = (RedDotType)Enum.Parse(typeof(RedDotType),rt);
NotifyAll(cc);
}

private void UpdateAll(object obj)
{
var enumerator = this.RedDotObjDict.GetEnumerator();
while (enumerator.MoveNext())
{
for (int i = 0; i < enumerator.Current.Value.Count; i++)
{
RedDotItem item = enumerator.Current.Value[i];
if (item != null)
{
item.MoveTime();
}
}
}
}

/// <summary>
/// 更新该类型的所有红点组件;
/// </summary>
/// <param name="redDotType"></param>
/// <returns></returns>
private void NotifyAll(RedDotType redDotType)
{
if (RedDotObjDict.ContainsKey(redDotType))
{
for (int i = 0; i < RedDotObjDict[redDotType].Count; i++)
{
RedDotItem item = RedDotObjDict[redDotType][i];
if (item != null)
{
item.CheckRedDot();
}
}
}
}
#region private
/// <summary>
/// 添加红点界面;
/// </summary>
/// <param name="redDotType"></param>
/// <param name="item"></param>
private void RegisterRedDot(RedDotType redDotType, RedDotItem item)
{
if (RedDotObjDict.ContainsKey(redDotType))
{
if (!RedDotObjDict[redDotType].Contains(item))
{
RedDotObjDict[redDotType].Add(item);
}
}
else
{
List<RedDotItem> items = new List<RedDotItem>();
items.Add(item);
RedDotObjDict.Add(redDotType, items);
}
}
#endregion
}


枚举值可在预制体选择那个类型

1
2
3
4
5
6
7
8
9
10
/**
* 红点类型的枚举;
* RedDotType.cs
**/
public enum RedDotType
{
None = 0,
MainUI_EmailRedDot = 1,
MainUI_SignInRedDot = 2,
}

lua方面的代码介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
MainRedDotHelp = newClass("MainRedDotHelp",LuaBehaviour);
function MainRedDotHelp:CheckRedDot(type)
-- 检测状态 RedDotType
if self[type] then
return self[type]()
end
end

-- 邮件红点
function MainRedDotHelp:MainUI_EmailRedDot()

local state = GameData.mailData:GetRedDotTag()
return state
end

-- 签到红点
function MainRedDotHelp:MainUI_SignInRedDot()

local state = GameData.welfareData:GetSignInRedDotTag()
return state
end

好啦大概就这样了 用起来还行