Update

Update

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetBaseEventArgs.cs

@@ -1,19 +0,0 @@
-using System;
-
-namespace TEngine.Runtime
-{
-    public abstract class NetBaseEventArgs : EventArgs, IMemory
-    {
-        /// <summary>
-        /// 初始化构造函数
-        /// </summary>
-        public NetBaseEventArgs()
-        {
-        }
-
-        /// <summary>
-        /// 清理引用。
-        /// </summary>
-        public abstract void Clear();
-    }
-}

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetBaseEventArgs.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: dd227169d1cedc64ba3c1454671bca7d
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetworkClosedEvent.cs

@@ -58,4 +58,63 @@
             NetworkChannel = null;
         }
     }
+    
+    /// <summary>
+    /// 网络连接关闭事件。
+    /// </summary>
+    public sealed class NetworkClosedEvent : GameEventArgs
+    {
+        /// <summary>
+        /// 网络连接关闭事件编号。
+        /// </summary>
+        public static readonly int EventId = typeof(NetworkClosedEvent).GetHashCode();
+
+        /// <summary>
+        /// 初始化网络连接关闭事件的新实例。
+        /// </summary>
+        public NetworkClosedEvent()
+        {
+            NetworkChannel = null;
+        }
+
+        /// <summary>
+        /// 获取网络连接关闭事件编号。
+        /// </summary>
+        public override int Id
+        {
+            get
+            {
+                return EventId;
+            }
+        }
+
+        /// <summary>
+        /// 获取网络频道。
+        /// </summary>
+        public INetworkChannel NetworkChannel
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 创建网络连接关闭事件。
+        /// </summary>
+        /// <param name="e">内部事件。</param>
+        /// <returns>创建的网络连接关闭事件。</returns>
+        public static NetworkClosedEvent Create(NetworkClosedEventArgs e)
+        {
+            NetworkClosedEvent networkClosedEventArgs = MemoryPool.Acquire<NetworkClosedEvent>();
+            networkClosedEventArgs.NetworkChannel = e.NetworkChannel;
+            return networkClosedEventArgs;
+        }
+
+        /// <summary>
+        /// 清理网络连接关闭事件。
+        /// </summary>
+        public override void Clear()
+        {
+            NetworkChannel = null;
+        }
+    }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetworkConnectedEventArgs.cs

@@ -71,4 +71,72 @@
             UserData = null;
         }
     }
+
+    public sealed class NetworkConnectedEvent : GameEventArgs
+    {
+        /// <summary>
+        /// 网络连接成功事件编号。
+        /// </summary>
+        public static readonly int EventId = typeof(NetworkConnectedEvent).GetHashCode();
+
+        /// <summary>
+        /// 初始化网络连接成功事件的新实例。
+        /// </summary>
+        public NetworkConnectedEvent()
+        {
+            NetworkChannel = null;
+            UserData = null;
+        }
+
+        /// <summary>
+        /// 获取网络连接成功事件编号。
+        /// </summary>
+        public override int Id
+        {
+            get
+            {
+                return EventId;
+            }
+        }
+
+        /// <summary>
+        /// 获取网络频道。
+        /// </summary>
+        public INetworkChannel NetworkChannel
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取用户自定义数据。
+        /// </summary>
+        public object UserData
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 创建网络连接成功事件。
+        /// </summary>
+        /// <param name="e">内部事件。</param>
+        /// <returns>创建的网络连接成功事件。</returns>
+        public static NetworkConnectedEvent Create(NetworkConnectedEventArgs e)
+        {
+            NetworkConnectedEvent networkConnectedEventArgs = MemoryPool.Acquire<NetworkConnectedEvent>();
+            networkConnectedEventArgs.NetworkChannel = e.NetworkChannel;
+            networkConnectedEventArgs.UserData = e.UserData;
+            return networkConnectedEventArgs;
+        }
+
+        /// <summary>
+        /// 清理网络连接成功事件。
+        /// </summary>
+        public override void Clear()
+        {
+            NetworkChannel = null;
+            UserData = null;
+        }
+    }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetworkCustomErrorEvent.cs

@@ -71,4 +71,75 @@
             CustomErrorData = null;
         }
     }
+    
+    /// <summary>
+    /// 用户自定义网络错误事件。
+    /// </summary>
+    public sealed class NetworkCustomErrorEvent : GameEventArgs
+    {
+        /// <summary>
+        /// 用户自定义网络错误事件编号。
+        /// </summary>
+        public static readonly int EventId = typeof(NetworkCustomErrorEvent).GetHashCode();
+
+        /// <summary>
+        /// 初始化用户自定义网络错误事件的新实例。
+        /// </summary>
+        public NetworkCustomErrorEvent()
+        {
+            NetworkChannel = null;
+            CustomErrorData = null;
+        }
+
+        /// <summary>
+        /// 获取用户自定义网络错误事件编号。
+        /// </summary>
+        public override int Id
+        {
+            get
+            {
+                return EventId;
+            }
+        }
+
+        /// <summary>
+        /// 获取网络频道。
+        /// </summary>
+        public INetworkChannel NetworkChannel
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取用户自定义错误数据。
+        /// </summary>
+        public object CustomErrorData
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 创建用户自定义网络错误事件。
+        /// </summary>
+        /// <param name="e">内部事件。</param>
+        /// <returns>创建的用户自定义网络错误事件。</returns>
+        public static NetworkCustomErrorEvent Create(NetworkCustomErrorEventArgs e)
+        {
+            NetworkCustomErrorEvent networkCustomErrorEventArgs = MemoryPool.Acquire<NetworkCustomErrorEvent>();
+            networkCustomErrorEventArgs.NetworkChannel = e.NetworkChannel;
+            networkCustomErrorEventArgs.CustomErrorData = e.CustomErrorData;
+            return networkCustomErrorEventArgs;
+        }
+
+        /// <summary>
+        /// 清理用户自定义网络错误事件。
+        /// </summary>
+        public override void Clear()
+        {
+            NetworkChannel = null;
+            CustomErrorData = null;
+        }
+    }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetworkErrorEvent.cs

@@ -99,4 +99,97 @@ namespace TEngine.Runtime
             ErrorMessage = null;
         }
     }
+    
+    /// <summary>
+    /// 网络错误事件。
+    /// </summary>
+    public sealed class NetworkErrorEvent : GameEventArgs
+    {
+        /// <summary>
+        /// 网络错误事件编号。
+        /// </summary>
+        public static readonly int EventId = typeof(NetworkErrorEvent).GetHashCode();
+
+        /// <summary>
+        /// 初始化网络错误事件的新实例。
+        /// </summary>
+        public NetworkErrorEvent()
+        {
+            NetworkChannel = null;
+            ErrorCode = NetworkErrorCode.Unknown;
+            ErrorMessage = null;
+        }
+
+        /// <summary>
+        /// 获取网络错误事件编号。
+        /// </summary>
+        public override int Id
+        {
+            get
+            {
+                return EventId;
+            }
+        }
+
+        /// <summary>
+        /// 获取网络频道。
+        /// </summary>
+        public INetworkChannel NetworkChannel
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取错误码。
+        /// </summary>
+        public NetworkErrorCode ErrorCode
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取 Socket 错误码。
+        /// </summary>
+        public SocketError SocketErrorCode
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取错误信息。
+        /// </summary>
+        public string ErrorMessage
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 创建网络错误事件。
+        /// </summary>
+        /// <param name="e">内部事件。</param>
+        /// <returns>创建的网络错误事件。</returns>
+        public static NetworkErrorEvent Create(NetworkErrorEventArgs e)
+        {
+            NetworkErrorEvent networkErrorEventArgs = MemoryPool.Acquire<NetworkErrorEvent>();
+            networkErrorEventArgs.NetworkChannel = e.NetworkChannel;
+            networkErrorEventArgs.ErrorCode = e.ErrorCode;
+            networkErrorEventArgs.SocketErrorCode = e.SocketErrorCode;
+            networkErrorEventArgs.ErrorMessage = e.ErrorMessage;
+            return networkErrorEventArgs;
+        }
+
+        /// <summary>
+        /// 清理网络错误事件。
+        /// </summary>
+        public override void Clear()
+        {
+            NetworkChannel = null;
+            ErrorCode = NetworkErrorCode.Unknown;
+            ErrorMessage = null;
+        }
+    }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventArgs/NetworkMissHeartBeatEvent.cs

@@ -71,4 +71,75 @@
             MissCount = 0;
         }
     }
+    
+    /// <summary>
+    /// 网络心跳包丢失事件。
+    /// </summary>
+    public sealed class NetworkMissHeartBeatEvent : GameEventArgs
+    {
+        /// <summary>
+        /// 网络心跳包丢失事件编号。
+        /// </summary>
+        public static readonly int EventId = typeof(NetworkMissHeartBeatEvent).GetHashCode();
+
+        /// <summary>
+        /// 初始化网络心跳包丢失事件的新实例。
+        /// </summary>
+        public NetworkMissHeartBeatEvent()
+        {
+            NetworkChannel = null;
+            MissCount = 0;
+        }
+
+        /// <summary>
+        /// 获取网络心跳包丢失事件编号。
+        /// </summary>
+        public override int Id
+        {
+            get
+            {
+                return EventId;
+            }
+        }
+
+        /// <summary>
+        /// 获取网络频道。
+        /// </summary>
+        public INetworkChannel NetworkChannel
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 获取心跳包已丢失次数。
+        /// </summary>
+        public int MissCount
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// 创建网络心跳包丢失事件。
+        /// </summary>
+        /// <param name="e">内部事件。</param>
+        /// <returns>创建的网络心跳包丢失事件。</returns>
+        public static NetworkMissHeartBeatEvent Create(NetworkMissHeartBeatEventArgs e)
+        {
+            NetworkMissHeartBeatEvent networkMissHeartBeatEventArgs = MemoryPool.Acquire<NetworkMissHeartBeatEvent>();
+            networkMissHeartBeatEventArgs.NetworkChannel = e.NetworkChannel;
+            networkMissHeartBeatEventArgs.MissCount = e.MissCount;
+            return networkMissHeartBeatEventArgs;
+        }
+
+        /// <summary>
+        /// 清理网络心跳包丢失事件。
+        /// </summary>
+        public override void Clear()
+        {
+            NetworkChannel = null;
+            MissCount = 0;
+        }
+    }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventManager.cs

@@ -44,7 +44,7 @@ namespace TEngine.Runtime
         /// </summary>
         /// <param name="elapseSeconds">逻辑流逝时间，以秒为单位。</param>
         /// <param name="realElapseSeconds">真实流逝时间，以秒为单位。</param>
-        internal void Update(float elapseSeconds, float realElapseSeconds)
+        public void Update(float elapseSeconds, float realElapseSeconds)
         {
             m_EventPool.Update(elapseSeconds, realElapseSeconds);
         }
@@ -52,7 +52,7 @@ namespace TEngine.Runtime
         /// <summary>
         /// 关闭并清理事件管理器。
         /// </summary>
-        internal void Shutdown()
+        public void Shutdown()
         {
             m_EventPool.Shutdown();
         }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/EventPool/EventPool.cs

@@ -188,7 +188,7 @@ namespace TEngine.Runtime
                 }
             }
 
-            if (!m_EventHandlers.Remove(id, handler))
+            if (m_EventHandlers.Count >=0 && !m_EventHandlers.Remove(id, handler))
             {
                 throw new Exception(Utility.Text.Format("Event '{0}' not exists specified handler.", id));
             }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/IEventManager.cs

@@ -71,5 +71,17 @@ namespace TEngine.Runtime
         /// <param name="sender">事件源。</param>
         /// <param name="e">事件参数。</param>
         void FireNow(object sender, GameEventArgs e);
+
+        /// <summary>
+        /// 事件管理器轮询。
+        /// </summary>
+        /// <param name="elapseSeconds">逻辑流逝时间，以秒为单位。</param>
+        /// <param name="realElapseSeconds">真实流逝时间，以秒为单位。</param>
+        void Update(float elapseSeconds, float realElapseSeconds);
+
+        /// <summary>
+        /// 关闭并清理事件管理器。
+        /// </summary>
+        void Shutdown();
     }
 }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Event/NetEvent.cs

@@ -1,4 +1,5 @@
 using System;
+using UnityEngine;
 
 namespace TEngine.Runtime
 {
@@ -38,7 +39,24 @@ namespace TEngine.Runtime
                 Log.Fatal("Event manager is invalid.");
                 return;
             }
-        }/// <summary>
+        }
+
+        public override void Update()
+        {
+            base.Update();
+            
+            if (m_EventManager != null)
+            {
+                m_EventManager.Update(Time.deltaTime, Time.unscaledDeltaTime);;
+            }
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+
+        /// <summary>
         /// 获取事件处理函数的数量。
         /// </summary>
         /// <param name="id">事件类型编号。</param>

Assets/TEngine/Scripts/Runtime/Core/NetWork/Helper/NetworkChannelHelper.cs

@@ -57,11 +57,11 @@ namespace TEngine.Runtime
                 }
             }
 
-            NetEvent.Instance.Subscribe(NetworkConnectedEventArgs.EventId, OnNetworkConnected);
+            NetEvent.Instance.Subscribe(NetworkConnectedEvent.EventId, OnNetworkConnected);
-            NetEvent.Instance.Subscribe(NetworkClosedEventArgs.EventId, OnNetworkClosed);
+            NetEvent.Instance.Subscribe(NetworkClosedEvent.EventId, OnNetworkClosed);
-            NetEvent.Instance.Subscribe(NetworkMissHeartBeatEventArgs.EventId, OnNetworkMissHeartBeat);
+            NetEvent.Instance.Subscribe(NetworkMissHeartBeatEvent.EventId, OnNetworkMissHeartBeat);
-            NetEvent.Instance.Subscribe(NetworkErrorEventArgs.EventId, OnNetworkError);
+            NetEvent.Instance.Subscribe(NetworkErrorEvent.EventId, OnNetworkError);
-            NetEvent.Instance.Subscribe(NetworkCustomErrorEventArgs.EventId, OnNetworkCustomError);
+            NetEvent.Instance.Subscribe(NetworkCustomErrorEvent.EventId, OnNetworkCustomError);
         }
 
         /// <summary>
@@ -182,11 +182,11 @@ namespace TEngine.Runtime
         /// </summary>
         public void Shutdown()
         {
-            NetEvent.Instance.Unsubscribe(NetworkConnectedEventArgs.EventId, OnNetworkConnected);
+            NetEvent.Instance.Unsubscribe(NetworkConnectedEvent.EventId, OnNetworkConnected);
-            NetEvent.Instance.Unsubscribe(NetworkClosedEventArgs.EventId, OnNetworkClosed);
+            NetEvent.Instance.Unsubscribe(NetworkClosedEvent.EventId, OnNetworkClosed);
-            NetEvent.Instance.Unsubscribe(NetworkMissHeartBeatEventArgs.EventId, OnNetworkMissHeartBeat);
+            NetEvent.Instance.Unsubscribe(NetworkMissHeartBeatEvent.EventId, OnNetworkMissHeartBeat);
-            NetEvent.Instance.Unsubscribe(NetworkErrorEventArgs.EventId, OnNetworkError);
+            NetEvent.Instance.Unsubscribe(NetworkErrorEvent.EventId, OnNetworkError);
-            NetEvent.Instance.Unsubscribe(NetworkCustomErrorEventArgs.EventId, OnNetworkCustomError);
+            NetEvent.Instance.Unsubscribe(NetworkCustomErrorEvent.EventId, OnNetworkCustomError);
 
             m_NetworkChannel = null;
         }
@@ -194,7 +194,7 @@ namespace TEngine.Runtime
         #region Handle
         private void OnNetworkConnected(object sender, GameEventArgs e)
         {
-            NetworkConnectedEventArgs ne = (NetworkConnectedEventArgs)e;
+            NetworkConnectedEvent ne = (NetworkConnectedEvent)e;
             if (ne.NetworkChannel != m_NetworkChannel)
             {
                 return;
@@ -204,7 +204,7 @@ namespace TEngine.Runtime
 
         private void OnNetworkClosed(object sender, GameEventArgs e)
         {
-            NetworkClosedEventArgs ne = (NetworkClosedEventArgs)e;
+            NetworkClosedEvent ne = (NetworkClosedEvent)e;
             if (ne.NetworkChannel != m_NetworkChannel)
             {
                 return;
@@ -214,7 +214,7 @@ namespace TEngine.Runtime
 
         private void OnNetworkMissHeartBeat(object sender, GameEventArgs e)
         {
-            NetworkMissHeartBeatEventArgs ne = (NetworkMissHeartBeatEventArgs)e;
+            NetworkMissHeartBeatEvent ne = (NetworkMissHeartBeatEvent)e;
             if (ne.NetworkChannel != m_NetworkChannel)
             {
                 return;
@@ -231,7 +231,7 @@ namespace TEngine.Runtime
 
         private void OnNetworkError(object sender, GameEventArgs e)
         {
-            NetworkErrorEventArgs ne = (NetworkErrorEventArgs)e;
+            NetworkErrorEvent ne = (NetworkErrorEvent)e;
             if (ne.NetworkChannel != m_NetworkChannel)
             {
                 return;
@@ -244,7 +244,7 @@ namespace TEngine.Runtime
 
         private void OnNetworkCustomError(object sender, GameEventArgs e)
         {
-            NetworkCustomErrorEventArgs ne = (NetworkCustomErrorEventArgs)e;
+            NetworkCustomErrorEvent ne = (NetworkCustomErrorEvent)e;
             if (ne.NetworkChannel != m_NetworkChannel)
             {
                 return;

Assets/TEngine/Scripts/Runtime/Core/NetWork/Helper/ProtoUtils.cs

@@ -41,7 +41,7 @@ namespace TEngine.Runtime
             }
             catch (IOException ex)
             {
-                Log.Error(($"[DeSerialize] 错误：{ex.Message}, {ex.Data["StackTrace"]}"));
+                Log.Error(($"[DeSerialize] Error：{ex.Message}, {ex.Data["StackTrace"]}"));
                 return null;
             }
         }

Assets/TEngine/Scripts/Runtime/Core/NetWork/Network.cs

@@ -34,6 +34,26 @@ namespace TEngine.Runtime
             base.OnLoad();
             
             GameEventMgr.Instance.AddEventListener(TEngineEvent.OnStartGame,OnStartGame);
+            
+            m_NetworkManager = new NetworkManager();
+            NetworkManager = m_NetworkManager as NetworkManager;
+            if (m_NetworkManager == null)
+            {
+                Log.Fatal("Network manager is invalid.");
+                return;
+            }
+
+            m_NetworkManager.NetworkConnected += OnNetworkConnected;
+            m_NetworkManager.NetworkClosed += OnNetworkClosed;
+            m_NetworkManager.NetworkMissHeartBeat += OnNetworkMissHeartBeat;
+            m_NetworkManager.NetworkError += OnNetworkError;
+            m_NetworkManager.NetworkCustomError += OnNetworkCustomError;
+            
+            if (NetEvent.Instance == null)
+            {
+                Log.Fatal("Event component is invalid.");
+                return;
+            }
         }
 
         private void Update()
@@ -55,25 +75,7 @@ namespace TEngine.Runtime
 
         private void OnStartGame()
         {
-            m_NetworkManager = new NetworkManager();
-            NetworkManager = m_NetworkManager as NetworkManager;
-            if (m_NetworkManager == null)
-            {
-                Log.Fatal("Network manager is invalid.");
-                return;
-            }
-
-            m_NetworkManager.NetworkConnected += OnNetworkConnected;
-            m_NetworkManager.NetworkClosed += OnNetworkClosed;
-            m_NetworkManager.NetworkMissHeartBeat += OnNetworkMissHeartBeat;
-            m_NetworkManager.NetworkError += OnNetworkError;
-            m_NetworkManager.NetworkCustomError += OnNetworkCustomError;
             
-            if (NetEvent.Instance == null)
-            {
-                Log.Fatal("Event component is invalid.");
-                return;
-            }
         }
         
         /// <summary>
@@ -138,27 +140,27 @@ namespace TEngine.Runtime
 
         private void OnNetworkConnected(object sender, NetworkConnectedEventArgs e)
         {
-            NetEvent.Instance.Fire(this, e);
+            NetEvent.Instance.Fire(this, NetworkConnectedEvent.Create(e));
         }
 
         private void OnNetworkClosed(object sender, NetworkClosedEventArgs e)
         {
-            NetEvent.Instance.Fire(this, e);
+            NetEvent.Instance.Fire(this, NetworkClosedEvent.Create(e));
         }
 
         private void OnNetworkMissHeartBeat(object sender, NetworkMissHeartBeatEventArgs e)
         {
-            NetEvent.Instance.Fire(this, e);
+            NetEvent.Instance.Fire(this, NetworkMissHeartBeatEvent.Create(e));
         }
 
         private void OnNetworkError(object sender, NetworkErrorEventArgs e)
         {
-            NetEvent.Instance.Fire(this, e);
+            NetEvent.Instance.Fire(this, NetworkErrorEvent.Create(e));
         }
 
         private void OnNetworkCustomError(object sender, NetworkCustomErrorEventArgs e)
         {
-            NetEvent.Instance.Fire(this, e);
+            NetEvent.Instance.Fire(this, NetworkCustomErrorEvent.Create(e));
         }
     }
 }