diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/CNetProcessor.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/CNetProcessor.cs | 363 |
1 files changed, 363 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/CNetProcessor.cs b/Client/Assets/Scripts/XMainClient/CNetProcessor.cs new file mode 100644 index 00000000..0b76dd17 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/CNetProcessor.cs @@ -0,0 +1,363 @@ +using System;
+using System.IO;
+using Ionic.Zlib;
+using XUpdater;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ public class CNetProcessor : ILuaNetProcess, INetProcess
+ {
+ private CNetwork m_oNetwork;
+
+ private INetObserver m_oObserver;
+
+ private Random r;
+
+ public static int MaxBuffSize = 65536;
+
+ private MemoryStream RecvStream = new MemoryStream(65536);
+
+ private ProtocolHead head = new ProtocolHead();
+
+ private ZlibStream zDecompress = null;
+
+ private static NetEvent m_sCurrentEvent = null;
+
+ public void OnLuaProcessBuffer(NetEvent evt)
+ {
+ bool flag = this.m_oNetwork.IsOnlyDispacherInLua(this.head.type);
+ bool isPtc = this.head.IsPtc;
+ if (isPtc)
+ {
+ bool flag2 = true;
+ bool flag3 = this.m_oNetwork.ContainPtc(this.head.type, out flag2) || flag;
+ if (flag3)
+ {
+ bool flag4 = this.RecvStream != null;
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("ptc new type: ", this.head.type.ToString(), " only: " + flag.ToString(), null, null, null);
+ LuaNetNode node = this.m_oNetwork.GetNode(flag2 || flag);
+ node.Reset();
+ node.isRpc = false;
+ node.isOnlyLua = flag;
+ node.type = this.head.type;
+ bool flag5 = flag2 || flag;
+ if (flag5)
+ {
+ node.SetBuff(this.RecvStream.GetBuffer(), (int)this.RecvStream.Length);
+ }
+ evt.node = node;
+ evt.IsOnlyLua = flag;
+ }
+ }
+ }
+ else
+ {
+ bool flag6 = flag;
+ if (flag6)
+ {
+ LuaNetNode node2 = this.m_oNetwork.GetNode(true);
+ node2.isOnlyLua = true;
+ node2.isRpc = true;
+ node2.type = this.head.type;
+ byte[] buffer = this.RecvStream.GetBuffer();
+ node2.SetBuff(buffer, (int)this.RecvStream.Length);
+ evt.node = node2;
+ evt.IsOnlyLua = true;
+ }
+ else
+ {
+ LuaNetNode removeRpc = this.m_oNetwork.GetRemoveRpc(this.head.tagID);
+ bool flag7 = removeRpc == null;
+ if (!flag7)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("rpc new type: " + this.head.type, " only: " + flag.ToString(), null, null, null, null);
+ removeRpc.type = this.head.type;
+ removeRpc.isRpc = true;
+ removeRpc.isOnlyLua = flag;
+ bool copyBuffer = removeRpc.copyBuffer;
+ if (copyBuffer)
+ {
+ removeRpc.SetBuff(this.RecvStream.GetBuffer(), (int)this.RecvStream.Length);
+ }
+ evt.node = removeRpc;
+ evt.IsOnlyLua = false;
+ }
+ }
+ }
+ }
+
+ public void OnLuaProcess(NetEvent evt)
+ {
+ LuaNetNode node = evt.node;
+ bool flag = node != null;
+ if (flag)
+ {
+ bool isOnlyLua = node.isOnlyLua;
+ if (isOnlyLua)
+ {
+ XSingleton<XUpdater.XUpdater>.singleton.XLuaEngine.hotfixMgr.ProcessOveride(node.type, node.buffer, node.length);
+ }
+ else
+ {
+ bool isRpc = node.isRpc;
+ if (isRpc)
+ {
+ bool flag2 = node.resp != null;
+ if (flag2)
+ {
+ node.resp(node.buffer, node.length);
+ }
+ }
+ else
+ {
+ XSingleton<XUpdater.XUpdater>.singleton.XLuaEngine.hotfixMgr.RegistedPtc(node.type, node.buffer, node.length);
+ }
+ }
+ this.m_oNetwork.ReturnNode(node);
+ }
+ }
+
+ public CNetProcessor(CNetwork network, INetObserver ob)
+ {
+ this.m_oNetwork = network;
+ this.m_oObserver = ob;
+ this.r = new Random(DateTime.Now.Millisecond);
+ this.zDecompress = new ZlibStream(this.RecvStream, CompressionMode.Decompress, true);
+ }
+
+ public void OnConnect(bool bSuccess)
+ {
+ bool flag = this.m_oObserver != null;
+ if (flag)
+ {
+ this.m_oObserver.OnConnect(bSuccess);
+ }
+ }
+
+ public void OnClosed(NetErrCode nErrCode)
+ {
+ bool flag = this.m_oObserver != null;
+ if (flag)
+ {
+ this.m_oObserver.OnClosed(nErrCode);
+ }
+ }
+
+ private void ProcessStream(NetEvent evt)
+ {
+ bool flag = (long)evt.m_oBuffer.Count < 12L;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("head file size error", null, null, null, null, null);
+ }
+ else
+ {
+ this.head.Reset();
+ this.head.Deserialize(ref evt.m_oBuffer);
+ int size = this.head.Size;
+ bool isInit = evt.m_oBuffer.IsInit;
+ if (isInit)
+ {
+ bool isCompressed = this.head.IsCompressed;
+ if (isCompressed)
+ {
+ this.zDecompress.Seek(0L, SeekOrigin.Begin);
+ this.zDecompress.SetLength(0L);
+ this.zDecompress.Write(evt.m_oBuffer.OriginalBuff, evt.m_oBuffer.StartOffset + size, evt.m_nBufferLength - size);
+ this.zDecompress.Flush();
+ this.RecvStream.Seek(0L, SeekOrigin.Begin);
+ }
+ else
+ {
+ this.RecvStream.Seek(0L, SeekOrigin.Begin);
+ this.RecvStream.SetLength(0L);
+ this.RecvStream.Write(evt.m_oBuffer.OriginalBuff, evt.m_oBuffer.StartOffset + size, evt.m_nBufferLength - size);
+ this.RecvStream.Seek(0L, SeekOrigin.Begin);
+ }
+ }
+ }
+ }
+
+ private void ProcessDeSerialize(NetEvent evt)
+ {
+ evt.IsPtc = this.head.IsPtc;
+ bool isPtc = this.head.IsPtc;
+ if (isPtc)
+ {
+ Protocol protocolThread = Protocol.GetProtocolThread(this.head.type);
+ bool flag = protocolThread == null;
+ if (flag)
+ {
+ bool flag2 = !this.m_oNetwork.ConatainPtc(this.head.type) && !this.m_oNetwork.IsOnlyDispacherInLua(this.head.type);
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Ptc Not found: ", this.head.type.ToString(), null, null, null, null);
+ }
+ }
+ else
+ {
+ try
+ {
+ bool flag3 = this.RecvStream.Length > 1024L;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddWarningLog2("Recv Ptc:{0} to long:{1}b", new object[]
+ {
+ protocolThread.GetProtoType(),
+ this.RecvStream.Length
+ });
+ }
+ protocolThread.ThreadErrCode = EProtocolErrCode.ENoErr;
+ protocolThread.DeSerialize(this.RecvStream);
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog2("Ptc {0} deserialize fail: {1} ", new object[]
+ {
+ this.head.type,
+ ex.Message
+ });
+ bool flag4 = protocolThread != null;
+ if (flag4)
+ {
+ protocolThread.ThreadErrCode = EProtocolErrCode.EDeSerializeErr;
+ }
+ }
+ evt.protocol = protocolThread;
+ }
+ }
+ else
+ {
+ Rpc removeRpcByTag = Rpc.GetRemoveRpcByTag(this.head.tagID);
+ bool flag5 = removeRpcByTag == null;
+ if (!flag5)
+ {
+ try
+ {
+ bool flag6 = this.RecvStream.Length > 0L;
+ if (flag6)
+ {
+ bool flag7 = this.RecvStream.Length > 1024L;
+ if (flag7)
+ {
+ XSingleton<XDebug>.singleton.AddWarningLog2("Recv Rpc:{0} to long:{1}b", new object[]
+ {
+ removeRpcByTag.GetRpcType(),
+ this.RecvStream.Length
+ });
+ }
+ removeRpcByTag.ThreadErrCode = EProtocolErrCode.ENoErr;
+ removeRpcByTag.DeSerialize(this.RecvStream);
+ }
+ else
+ {
+ bool isRpcNull = this.head.IsRpcNull;
+ if (isRpcNull)
+ {
+ removeRpcByTag.ThreadErrCode = EProtocolErrCode.ENullProtocol;
+ }
+ else
+ {
+ removeRpcByTag.ThreadErrCode = EProtocolErrCode.ENoErr;
+ removeRpcByTag.DeSerialize(this.RecvStream);
+ }
+ }
+ }
+ catch (Exception ex2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog2("Rpc {0} deserialize fail: {1}", new object[]
+ {
+ this.head.type,
+ ex2.Message
+ });
+ bool flag8 = removeRpcByTag != null;
+ if (flag8)
+ {
+ removeRpcByTag.ThreadErrCode = EProtocolErrCode.EDeSerializeErr;
+ }
+ }
+ evt.rpc = removeRpcByTag;
+ }
+ }
+ }
+
+ public void OnPrePropress(NetEvent evt)
+ {
+ this.ProcessStream(evt);
+ this.ProcessDeSerialize(evt);
+ this.OnLuaProcessBuffer(evt);
+ }
+
+ public void OnProcess(NetEvent evt)
+ {
+ CNetProcessor.m_sCurrentEvent = evt;
+ bool flag = evt.protocol != null;
+ if (flag)
+ {
+ bool flag2 = XSingleton<XDebug>.singleton.EnableRecord();
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddPoint(evt.protocol.GetProtoType(), evt.protocol.GetType().Name, (float)evt.m_nBufferLength, 0, XDebug.RecordChannel.ENetwork);
+ }
+ bool flag3 = !evt.IsOnlyLua;
+ if (flag3)
+ {
+ evt.protocol.Process();
+ }
+ this.OnLuaProcess(evt);
+ }
+ else
+ {
+ bool flag4 = evt.rpc != null;
+ if (!flag4)
+ {
+ this.OnLuaProcess(evt);
+ return;
+ }
+ bool flag5 = XSingleton<XDebug>.singleton.EnableRecord();
+ if (flag5)
+ {
+ XSingleton<XDebug>.singleton.AddPoint(evt.rpc.GetRpcType(), evt.rpc.GetType().Name, (float)evt.m_nBufferLength, 0, XDebug.RecordChannel.ENetwork);
+ }
+ evt.rpc.replyTick = evt.m_oTime;
+ bool flag6 = !evt.IsOnlyLua;
+ if (flag6)
+ {
+ evt.rpc.Process();
+ }
+ else
+ {
+ evt.rpc.RemoveTimer();
+ }
+ this.OnLuaProcess(evt);
+ }
+ bool flag7 = this.m_oObserver != null;
+ if (flag7)
+ {
+ this.m_oObserver.OnReceive(this.head.type, 0);
+ }
+ }
+
+ public void OnPostProcess(NetEvent evt)
+ {
+ bool flag = evt.protocol != null;
+ if (flag)
+ {
+ Protocol.ReturnProtocolThread(evt.protocol);
+ }
+ CNetProcessor.m_sCurrentEvent = null;
+ }
+
+ public static void ManualReturnProtocol()
+ {
+ bool flag = CNetProcessor.m_sCurrentEvent != null;
+ if (flag)
+ {
+ CNetProcessor.m_sCurrentEvent.ManualReturnProtocol();
+ }
+ }
+ }
+}
|