// 缓存回调列表移到真实回调列表
private static void RegisterHooksTempToRealHooks()
{
if (g_DataHook == null)
{
g_DataHook = new Dictionary <eMsgTypes, List <int> >();
}
Dictionary <eMsgTypes, List <int> > .Enumerator iter = g_DataHookAddTemp.GetEnumerator();
while (iter.MoveNext())
{
List <int> listHookTemp = iter.Current.Value;
eMsgTypes key = iter.Current.Key;
int nTempCount = listHookTemp.Count;
for (int nCntTemp = 0; nCntTemp < nTempCount; nCntTemp++)
{
int nHookIndex = listHookTemp[nCntTemp];
if (!g_DataHook.ContainsKey(key))
{
g_DataHook[key] = new List <int>();
}
List <int> listHook = g_DataHook[key];
if (listHook.Contains(nHookIndex) == false)
{
listHook.Add(nHookIndex);
}
}
}
iter.Dispose();
g_DataHookAddTemp.Clear();
}
// 回调事件
private static void DispatchEvent(eMsgTypes type, object Info)
{
if (g_DcHook.ContainsKey(type) == true)
{
g_DcHook[type](type, Info);
}
}
/// <summary>
/// 反注册DC
/// </summary>
public static void AntiRegisterDCHooks(eMsgTypes type)
{
if (g_DcHook.ContainsKey(type) == false)
{
g_DcHook.Remove(type);
}
}
/// <summary>
/// 登入GS 回调
/// </summary>
// 保存登录gs 服务器消息
public static void RecvMsgGS2CLLoginReply(eMsgTypes Type, object Info)
{
if (Info == null)
{
return;
}
g_GSLogin = Info as ProtoMsg.MsgCl2gsLoginReply;
IGGDebug.Log("连接游戏服务器成功");
}
public static void RecvMsgClientKeepLive(eMsgTypes Type, object Info)
{
if (Info == null)
{
return;
}
MsgClientKeepLive g_KeepLive = Info as ProtoMsg.MsgClientKeepLive;
SendKeepLiveMsg();
}
/// <summary>
/// 请求登入回调
/// </summary>
public static void RecvMsgLS2CLLoginReply(eMsgTypes Type, object Info)
{
if (Info == null)
{
return;
}
g_LSLogin = Info as ProtoMsg.MsgCl2lgLoginReply;
IGGDebug.Log("连接登入服务器成功");
// 请求链接GS
LoginM.ConnectGameServer();
}
public static void RecvMsgGS2CLServerTimeNotice(eMsgTypes Type, object Info)
{
if (Info == null)
{
return;
}
/*MsgGS2CLServerTimeNotice data = (MsgGS2CLServerTimeNotice)Info;
* m_LastGameTime = data.server_time * 1000;
* m_LastTime = System.DateTime.Now.Ticks / 10000;*/
}
/// <summary>
/// 消息到达的处理
/// </summary>
/// <param name="msg">到达的消息</param>
public static void MsgArrival(int msg)
{
eMsgTypes Type = (eMsgTypes)msg;
//IGGDebug.Log("MsgArrival prev:" + Type);
if (!msgWainList.ContainsKey(msg))
{
// 无人等待此消息
return;
}
//IGGDebug.Log("MsgArrival:" + Type);
// 添加到列表中
arrivalList.Add(msg);
}
private static void AntiRegisterHooksFrDelTemp()
{
Dictionary <eMsgTypes, List <int> > .Enumerator iter = g_DataHookDelTemp.GetEnumerator();
while (iter.MoveNext())
{
List <int> listDelHook = iter.Current.Value;
eMsgTypes key = iter.Current.Key;
int nDelCount = listDelHook.Count;
for (int nDelCnt = 0; nDelCnt < nDelCount; nDelCnt++)
{
int nDelHookIndex = listDelHook[nDelCnt];
if (g_DataHook.ContainsKey(key))
{
List <int> listHook = g_DataHook[key];
if (listHook.Contains(nDelHookIndex) == true)
{
listHook.Remove(nDelHookIndex);
}
int nCount = listHook.Count;
if (nCount == 0)
{
g_DataHook.Remove(key);
}
}
else
{
g_DataHook.Remove(key);
}
if (g_DataHookAddTemp.ContainsKey(key))
{
List <int> listHookTemp = g_DataHookAddTemp[key];
if (listHookTemp.Contains(nDelHookIndex) == true)
{
listHookTemp.Remove(nDelHookIndex);
}
int nCount = listHookTemp.Count;
if (nCount == 0)
{
g_DataHookAddTemp.Remove(key);
}
}
else
{
g_DataHookAddTemp.Remove(key);
}
}
}
iter.Dispose();
g_DataHookDelTemp.Clear();
}
/// <summary>
/// 注册服务端触发事件
/// </summary>
public static void RegisterHooks(eMsgTypes type, DataHook pf)
{
if (pf == null)
{
IGGDebug.Log("注册的Hook 非法");
return;
}
bool bHaveDataHook = false;
int nAddHookIndex = 0;
Dictionary <int, DataHook> .Enumerator iter = g_IndexDataHook.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Value == pf)
{
bHaveDataHook = true;
nAddHookIndex = iter.Current.Key;
break;
}
}
iter.Dispose();
if (!bHaveDataHook)
{
g_IndexDataHook[g_nHookIndex] = pf;
nAddHookIndex = g_nHookIndex;
g_nHookIndex++;
}
if (g_DataHookAddTemp == null)
{
g_DataHookAddTemp = new Dictionary <eMsgTypes, List <int> >(new msgtypeMsgTypeComparer());
}
if (!g_DataHookAddTemp.ContainsKey(type))
{
g_DataHookAddTemp[type] = new List <int>();
}
List <int> listHookTemp = g_DataHookAddTemp[type];
if (!listHookTemp.Contains(nAddHookIndex))
{
listHookTemp.Add(nAddHookIndex);
}
}
public static bool ProcessData(eMsgTypes Type, byte[] data, int index, int length)
{
object obj = protobufM.Deserialize(Type, data, index, length);
if (obj == null)
{
return(false);
}
// 派发到DC中进行存储
DispatchEvent(Type, obj);
// 派发消息用
EventCenter.DispatchEvent(Type, obj);
return(true);
}
/// <summary>
/// Send2s the G.
/// </summary>
/// <returns><c>true</c>, if G was send2ed, <c>false</c> otherwise.</returns>
/// <param name="msgNo">Message no.</param>
/// <param name="data">protobuf object.</param>
public static bool Send2GS(eMsgTypes type, byte[] msg)
{
//IGGDebug.Log("send:" + type);
NetBuffer Nb = NetCache.GetNetBuffer(msg.Length);
if (Nb != null)
{
Nb.PackBuf(type, msg);
return(gsConnector.SendToServer(Nb));
}
else
{
return(false);
}
}
/// <summary>
/// 反注册服务端通知事件
/// </summary>
public static void AntiRegisterHooks(eMsgTypes type, DataHook pfRemove)
{
if (pfRemove == null)
{
return;
}
bool bHaveDataHook = false;
int nRemovHookIndex = 0;
Dictionary <int, DataHook> .Enumerator iter = g_IndexDataHook.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Value == pfRemove)
{
bHaveDataHook = true;
nRemovHookIndex = iter.Current.Key;
break;
}
}
iter.Dispose();
if (!bHaveDataHook)
{
return;
}
g_IndexDataHook.Remove(nRemovHookIndex);
if (g_DataHookDelTemp == null)
{
g_DataHookDelTemp = new Dictionary <eMsgTypes, List <int> >(new msgtypeMsgTypeComparer());
}
if (!g_DataHookDelTemp.ContainsKey(type))
{
g_DataHookDelTemp[type] = new List <int>();
}
List <int> listHookTemp = g_DataHookDelTemp[type];
if (listHookTemp.Contains(nRemovHookIndex) == false)
{
listHookTemp.Add(nRemovHookIndex);
}
}
public static void Init()
{
eMsgTypes test = new eMsgTypes();
System.Reflection.FieldInfo[] fieldInfos = typeof(eMsgTypes).GetFields();
int FieldCount = fieldInfos.Length;
g_TypeDict = new Dictionary <eMsgTypes, Type>(FieldCount, new msgtypeMsgTypeComparer());
for (int i = 1; i < FieldCount; ++i)
{
System.Reflection.FieldInfo FiledName = fieldInfos[i];
eMsgTypes msgt = (eMsgTypes)FiledName.GetValue(test);
Type t = Type.GetType(FiledName.Name.Replace("Msg", "ProtoMsg.Msg"));
g_TypeDict.Add(msgt, t);
}
g_ms = new MemoryStream(64 * 1024);
}
/// <summary>
/// 注册DC到数据中心
/// </summary>
public static void RegisterDCHooks(eMsgTypes type, DataHook pf)
{
if (pf == null)
{
IGGDebug.Log("注册的Hook 非法");
return;
}
if (g_DcHook.ContainsKey(type) == false)
{
g_DcHook.Add(type, pf);
}
else
{
IGGDebug.Log("不同dc有注册到相同的存储函数");
}
}
private void ProcessPacket(byte[] message, int length)
{
//byte[] data = new byte[length - 2];
//Array.Copy(message, 2, data, 0, length - 2);
//大小端转换
ushort cmd = (ushort)message[0];
cmd += (ushort)(message[1] << 8);
eMsgTypes Type = (eMsgTypes)cmd;
//IGGDebug.Log("Revice:" + Type);
bool result = MsgM.Dispatch(Type, message, 6, length - 6);
if (result == true)
{
NetConnectState.MsgArrival(cmd);
}
}
// 反序列化
public static object Deserialize(eMsgTypes type, byte[] data, int index, int length)
{
if (g_TypeDict.ContainsKey(type) == false)
{
UnityEngine.Debug.Log("客户端不存在该proto协议类型：" + type.ToString());
return(null);
}
Type t = g_TypeDict[type];
if (null == t)
{
UnityEngine.Debug.Log("客户端不存在该proto协议类型：" + type.ToString());
return(null);
}
g_ms.SetLength(0);
g_ms.Write(data, index, length);
g_ms.Seek(0, SeekOrigin.Begin);
return(ProtoBuf.Meta.RuntimeTypeModel.Default.Deserialize(g_ms, null, t));
}
/// <summary>
/// 派发服务端事件，也可以用于模拟服务端触发事件
/// </summary>
/// <param name="type">proto 枚举类型</param>
/// <param name="obj">proto协议结构</param>
public static void DispatchEvent(eMsgTypes type, object obj)
{
RegisterHooksTempToRealHooks();
if (g_DataHook.ContainsKey(type))
{
List <int> listHook = g_DataHook[type];
for (int nCnt = 0; nCnt < listHook.Count; ++nCnt)
{
int nHookIndex = listHook[nCnt];
#if UNITY_EDITOR
if (g_IndexDataHook.ContainsKey(nHookIndex))
{
g_IndexDataHook[nHookIndex](type, obj);
}
#else
try
{
if (g_IndexDataHook.ContainsKey(nHookIndex))
{
g_IndexDataHook[nHookIndex](type, obj);
}
}
catch (Exception e)
{
IGGDebug.Log(e.ToString());
//当上面s_IndexDataHook回调出现问题时，此回调就会被移除，小心成为坑
listHook.Remove(nHookIndex);
--nCnt;
if (listHook.Count == 0)
{
g_DataHook.Remove(type);
break;
}
}
#endif
}
}
AntiRegisterHooksFrDelTemp();
}
// 序列化
public void PackBuf(eMsgTypes type, byte[] msg)
{
ushort msgNo = (ushort)type;
this.BufferLength = msg.Length + 8;
// 先封包头2个字节。
short size = (short)BufferLength;
short netsize = System.Net.IPAddress.HostToNetworkOrder(size);
this.Pbuffer[0] = (byte)(netsize >> 8);
this.Pbuffer[1] = (byte)(netsize);
// 再封命令ID
short id = (short)type;
netsize = System.Net.IPAddress.HostToNetworkOrder(id);
this.Pbuffer[2] = (byte)(netsize >> 8);
this.Pbuffer[3] = (byte)(netsize);
// 再封装协议体
Array.Copy(msg, 0, this.Pbuffer, 8, msg.Length);
this.mIsUsed = true;
this.HaveSendBytes = 0;
}
/// <summary>
/// 消息处理入口
/// </summary>
/// <param name="cmd">消息ID</param>
/// <param name="para">消息参数</param>
public static bool Dispatch(eMsgTypes Type, byte[] data, int index, int length)
{
//处理消息
Execute(Type, data, index, length);
return(true);
}
// 执行命令
public static void Execute(eMsgTypes Type, byte[] data, int index, int length)
{
DataCenter.ProcessData(Type, data, index, length);
}
} // GetElemValFromXml
/// <summary>
///
/// </summary>
/// <param name="i_sString"></param>
/// <returns></returns>
public static eMsgTypes MsgtypeFromString(string i_sString)
{
eMsgTypes mRet = eMsgTypes.NOP;
switch (i_sString)
{
case "NOP":
mRet = eMsgTypes.NOP;
break;
case "Ack":
mRet = eMsgTypes.Ack;
break;
case "Ping":
mRet = eMsgTypes.Ping;
break;
case "Stat":
mRet = eMsgTypes.Stat;
break;
case "SBResetComp":
mRet = eMsgTypes.SBResetComp;
break;
case "SBResetCompDone":
mRet = eMsgTypes.SBResetCompDone;
break;
case "SBStop":
mRet = eMsgTypes.SBStop;
break;
case "SBStopDone":
mRet = eMsgTypes.SBStopDone;
break;
case "SBUpdate":
mRet = eMsgTypes.SBUpdate;
break;
case "SBUpdateDone":
mRet = eMsgTypes.SBUpdateDone;
break;
case "OSUpdate":
mRet = eMsgTypes.OSUpdate;
break;
case "OSUpdateDone":
mRet = eMsgTypes.OSUpdateDone;
break;
case "NetSet":
mRet = eMsgTypes.NetSet;
break;
case "NetSetDone":
mRet = eMsgTypes.NetSetDone;
break;
case "SrvReset":
mRet = eMsgTypes.SrvReset;
break;
default:
mRet = eMsgTypes.NOP;
break;
}
return(mRet);
} // MsgtypeFromString
