大量更新，编译通过，还没跑通

Server/App/Program.cs

@@ -12,7 +12,7 @@ namespace ET
 		private static void Main(string[] args)
 		{
 			// 异步方法全部会回掉到主线程
-			SynchronizationContext.SetSynchronizationContext(OneThreadSynchronizationContext.Instance);
+			SynchronizationContext.SetSynchronizationContext(ThreadSynchronizationContext.Instance);
 			
 			try
 			{		
@@ -26,10 +26,8 @@ namespace ET
 				Parser.Default.ParseArguments<Options>(args)
 						.WithNotParsed(error => throw new Exception($"命令行格式错误!"))
 						.WithParsed(o => { options = o; });
-				
-				Game.Scene.AddComponent(options);
-				
-				IdGenerater.Process = options.Process;
+
+				Game.Options = options;
 				
 				LogManager.Configuration.Variables["appIdFormat"] = $"{Game.Scene.Id:0000}";
 				
@@ -42,7 +40,7 @@ namespace ET
 					try
 					{
 						Thread.Sleep(1);
-						OneThreadSynchronizationContext.Instance.Update();
+						ThreadSynchronizationContext.Instance.Update();
 						Game.EventSystem.Update();
 					}
 					catch (Exception e)

Server/Hotfix/AppStart_Init.cs

@@ -1,5 +1,7 @@
 
 
+using System.Net;
+
 namespace ET
 {
     public class AppStart_Init: AEvent<EventType.AppStart>
@@ -8,8 +10,7 @@ namespace ET
         {
             Game.Scene.AddComponent<ConfigComponent>();
 
-            Options options = Game.Scene.GetComponent<Options>();
-            StartProcessConfig processConfig = StartProcessConfigCategory.Instance.Get(options.Process);
+            StartProcessConfig processConfig = StartProcessConfigCategory.Instance.Get(Game.Options.Process);
             
             Game.Scene.AddComponent<TimerComponent>();
             Game.Scene.AddComponent<OpcodeTypeComponent>();
@@ -24,12 +25,10 @@ namespace ET
             Game.Scene.AddComponent<ActorMessageDispatcherComponent>();
             // 数值订阅组件
             Game.Scene.AddComponent<NumericWatcherComponent>();
-            // 控制台组件
-            Game.Scene.AddComponent<ConsoleComponent>();
 				
-            Game.Scene.AddComponent<NetInnerComponent, string>(processConfig.InnerAddress);
+            Game.Scene.AddComponent<NetInnerComponent, IPEndPoint>(processConfig.InnerIPPort);
             
-            var processScenes = StartSceneConfigCategory.Instance.GetByProcess(IdGenerater.Process);
+            var processScenes = StartSceneConfigCategory.Instance.GetByProcess(Game.Options.Process);
             foreach (StartSceneConfig startConfig in processScenes)
             {
                 await SceneFactory.Create(Game.Scene, startConfig.SceneId, startConfig.Zone, startConfig.Name, startConfig.Type, startConfig);

Server/Hotfix/Demo/C2R_LoginHandler.cs

@@ -17,7 +17,7 @@ namespace ET
 			G2R_GetLoginKey g2RGetLoginKey = (G2R_GetLoginKey) await ActorMessageSenderComponent.Instance.Call(
 				config.SceneId, new R2G_GetLoginKey() {Account = request.Account});
 
-			response.Address = config.OuterAddress;
+			response.Address = config.OuterIPPort.ToString();
 			response.Key = g2RGetLoginKey.Key;
 			response.GateId = g2RGetLoginKey.GateId;
 			reply();

Server/Hotfix/Demo/G2M_CreateUnitHandler.cs

@@ -8,7 +8,7 @@ namespace ET
 	{
 		protected override async ETTask Run(Scene scene, G2M_CreateUnit request, M2G_CreateUnit response, Action reply)
 		{
-			Unit unit = EntityFactory.CreateWithId<Unit>(scene, IdGenerater.GenerateId());
+			Unit unit = EntityFactory.CreateWithId<Unit>(scene, IdGenerater.Instance.GenerateId());
 			unit.AddComponent<MoveComponent>();
 			unit.AddComponent<UnitPathComponent>();
 			unit.Position = new Vector3(-10, 0, -10);

Server/Hotfix/Handler/G2C_TestHandler.cs

@@ -1,15 +0,0 @@
-
-
-namespace ET
-{
-    [MessageHandler]
-    public class G2C_TestHandler: AMHandler<G2C_Test>
-    {
-        public static int count = 0;
-        protected override async ETTask Run(Session session, G2C_Test message)
-        {
-            count++;
-            await ETTask.CompletedTask;
-        }
-    }
-}

Server/Hotfix/Handler/M2A_ReloadHandler.cs

@@ -1,16 +0,0 @@
-using System;
-
-
-namespace ET
-{
-	[MessageHandler]
-	public class M2A_ReloadHandler : AMRpcHandler<M2A_Reload, A2M_Reload>
-	{
-		protected override async ETTask Run(Session session, M2A_Reload request, A2M_Reload response, Action reply)
-		{
-			Game.EventSystem.Add(DllHelper.GetHotfixAssembly());
-			reply();
-			await ETTask.CompletedTask;
-		}
-	}
-}

Server/Hotfix/Module/Actor/ActorHelper.cs

@@ -0,0 +1,34 @@
+using System;
+using System.IO;
+
+namespace ET
+{
+    public static class ActorHelper
+    {
+        public static IActorResponse CreateResponse(IActorRequest iActorRequest, int error)
+        {
+            Type responseType = OpcodeTypeComponent.Instance.GetResponseType(iActorRequest.GetType());
+            IActorResponse response = (IActorResponse)Activator.CreateInstance(responseType);
+            response.Error = error;
+            response.RpcId = iActorRequest.RpcId;
+            return response;
+        }
+        
+        public static object ToActorMessage(this MemoryStream memoryStream)
+        {
+            ushort opcode = BitConverter.ToUInt16(memoryStream.GetBuffer(), 8);
+            Type type = OpcodeTypeComponent.Instance.GetType(opcode);
+
+            if (opcode < MessageSerializeHelper.PbMaxOpcode)
+            {
+                return ProtobufHelper.FromBytes(type, memoryStream.GetBuffer(), 10, (int)memoryStream.Length - 10);
+            }
+            
+            if (opcode >= MessageSerializeHelper.JsonMinOpcode)
+            {
+                return JsonHelper.FromJson(type, memoryStream.GetBuffer().ToStr(10, (int)(memoryStream.Length - 10)));
+            }
+            return MongoHelper.FromBson(type, memoryStream.GetBuffer(), 10, (int)memoryStream.Length - 10);
+        }
+    }
+}

Server/Hotfix/Module/Actor/ActorMessageDispatcherComponentSystem.cs

@@ -1,77 +1,83 @@
 using System;
-using System.Collections.Generic;
-
 
 namespace ET
 {
-	public class ActorMessageDispatcherComponentAwakeSystem: AwakeSystem<ActorMessageDispatcherComponent>
-	{
-		public override void Awake(ActorMessageDispatcherComponent self)
-		{
-			ActorMessageDispatcherComponent.Instance = self;
-			self.Awake();
-		}
-	}
+    [ObjectSystem]
+    public class ActorMessageDispatcherComponentAwakeSystem: AwakeSystem<ActorMessageDispatcherComponent>
+    {
+        public override void Awake(ActorMessageDispatcherComponent self)
+        {
+            ActorMessageDispatcherComponent.Instance = self;
+            self.Awake();
+        }
+    }
+
+    [ObjectSystem]
+    public class ActorMessageDispatcherComponentLoadSystem: LoadSystem<ActorMessageDispatcherComponent>
+    {
+        public override void Load(ActorMessageDispatcherComponent self)
+        {
+            self.Load();
+        }
+    }
+
+    [ObjectSystem]
+    public class ActorMessageDispatcherComponentDestroySystem: DestroySystem<ActorMessageDispatcherComponent>
+    {
+        public override void Destroy(ActorMessageDispatcherComponent self)
+        {
+            self.ActorMessageHandlers.Clear();
+            ActorMessageDispatcherComponent.Instance = null;
+        }
+    }
 
-	public class ActorMessageDispatcherComponentLoadSystem: LoadSystem<ActorMessageDispatcherComponent>
-	{
-		public override void Load(ActorMessageDispatcherComponent self)
-		{
-			self.Load();
-		}
-	}
-	
-	public class ActorMessageDispatcherComponentDestroySystem: DestroySystem<ActorMessageDispatcherComponent>
-	{
-		public override void Destroy(ActorMessageDispatcherComponent self)
-		{
-			self.ActorMessageHandlers.Clear();
-			ActorMessageDispatcherComponent.Instance = null;
-		}
-	}
+    /// <summary>
+    /// Actor消息分发组件
+    /// </summary>
+    public static class ActorMessageDispatcherComponentHelper
+    {
+        public static void Awake(this ActorMessageDispatcherComponent self)
+        {
+            self.Load();
+        }
 
-	/// <summary>
-	/// Actor消息分发组件
-	/// </summary>
-	public static class ActorMessageDispatcherComponentHelper
-	{
-		public static void Awake(this ActorMessageDispatcherComponent self)
-		{
-			self.Load();
-		}
+        public static void Load(this ActorMessageDispatcherComponent self)
+        {
+            self.ActorMessageHandlers.Clear();
 
-		public static void Load(this ActorMessageDispatcherComponent self)
-		{
-			self.ActorMessageHandlers.Clear();
+            var types = Game.EventSystem.GetTypes(typeof (ActorMessageHandlerAttribute));
+            foreach (Type type in types)
+            {
+                object obj = Activator.CreateInstance(type);
 
-			HashSet<Type> types = Game.EventSystem.GetTypes(typeof (ActorMessageHandlerAttribute));
-			foreach (Type type in types)
-			{
-				object obj = Activator.CreateInstance(type);
+                IMActorHandler imHandler = obj as IMActorHandler;
+                if (imHandler == null)
+                {
+                    throw new Exception($"message handler not inherit IMActorHandler abstract class: {obj.GetType().FullName}");
+                }
 
-				IMActorHandler imHandler = obj as IMActorHandler;
-				if (imHandler == null)
-				{
-					throw new Exception($"message handler not inherit IMActorHandler abstract class: {obj.GetType().FullName}");
-				}
+                Type messageType = imHandler.GetRequestType();
+                self.ActorMessageHandlers.Add(messageType, imHandler);
+            }
+        }
 
-				Type messageType = imHandler.GetMessageType();
-				self.ActorMessageHandlers.Add(messageType, imHandler);
-			}
-		}
+        /// <summary>
+        /// 分发actor消息
+        /// </summary>
+        public static async ETTask Handle(
+            this ActorMessageDispatcherComponent self, Entity entity, object message, Action<IActorResponse> reply)
+        {
+            if (!self.ActorMessageHandlers.TryGetValue(message.GetType(), out IMActorHandler handler))
+            {
+                throw new Exception($"not found message handler: {message}");
+            }
 
-		/// <summary>
-		/// 分发actor消息
-		/// </summary>
-		public static async ETTask Handle(
-				this ActorMessageDispatcherComponent self, Entity entity, Session session, object message)
-		{
-			if (!self.ActorMessageHandlers.TryGetValue(message.GetType(), out IMActorHandler handler))
-			{
-				throw new Exception($"not found message handler: {message}");
-			}
+            await handler.Handle(entity, message, reply);
+        }
 
-			await handler.Handle(session, entity, message);
-		}
-	}
-}
+        public static bool TryGetHandler(this ActorMessageDispatcherComponent self,Type type, out IMActorHandler actorHandler)
+        {
+            return self.ActorMessageHandlers.TryGetValue(type, out actorHandler);
+        }
+    }
+}

Server/Hotfix/Module/Actor/ActorMessageSenderComponentSystem.cs

@@ -1,40 +1,61 @@
 using System;
-
+using System.IO;
 
 namespace ET
 {
-    public class ActorMessageSenderComponentAwakeSystem : AwakeSystem<ActorMessageSenderComponent>
+    [ObjectSystem]
+    public class ActorMessageSenderComponentAwakeSystem: AwakeSystem<ActorMessageSenderComponent>
     {
         public override void Awake(ActorMessageSenderComponent self)
         {
             ActorMessageSenderComponent.Instance = self;
 
-            self.TimeoutCheckTimer = TimerComponent.Instance.NewRepeatedTimer(10 * 1000, self.Check);
+            self.TimeoutCheckTimer = TimerComponent.Instance.NewRepeatedTimer(1000, self.Check);
         }
     }
-    
+
+    [ObjectSystem]
     public class ActorMessageSenderComponentDestroySystem: DestroySystem<ActorMessageSenderComponent>
     {
         public override void Destroy(ActorMessageSenderComponent self)
         {
             ActorMessageSenderComponent.Instance = null;
-            TimerComponent.Instance.Remove(self.TimeoutCheckTimer);
+            TimerComponent.Instance.Remove(ref self.TimeoutCheckTimer);
             self.TimeoutCheckTimer = 0;
             self.TimeoutActorMessageSenders.Clear();
         }
     }
-    
+
     public static class ActorMessageSenderComponentSystem
     {
-        public static void Check(this ActorMessageSenderComponent self, bool isTimeOut)
+        public static void Run(ActorMessageSender self, IActorResponse response)
+        {
+            if (response.Error == ErrorCode.ERR_ActorTimeout)
+            {
+                self.Tcs.SetException(new Exception($"Rpc error: request, 注意Actor消息超时，请注意查看是否死锁或者没有reply: actorId: {self.ActorId} {self.MemoryStream.ToActorMessage()}, response: {response}"));
+                return;
+            }
+
+            if (self.NeedException && ErrorCode.IsRpcNeedThrowException(response.Error))
+            {
+                self.Tcs.SetException(new Exception($"Rpc error: actorId: {self.ActorId} request: {self.MemoryStream.ToActorMessage()}, response: {response}"));
+                return;
+            }
+
+            self.Tcs.SetResult(response);
+        }
+        
+        public static void Check(this ActorMessageSenderComponent self)
         {
-            long timeNow = TimeHelper.Now();
+            long timeNow = TimeHelper.ServerNow();
             foreach ((int key, ActorMessageSender value) in self.requestCallback)
             {
+                // 因为是顺序发送的，所以，检测到第一个不超时的就退出
                 if (timeNow < value.CreateTime + ActorMessageSenderComponent.TIMEOUT_TIME)
                 {
-                    continue;
+                    break;
                 }
+
                 self.TimeoutActorMessageSenders.Add(key);
             }
 
@@ -42,74 +63,112 @@ namespace ET
             {
                 ActorMessageSender actorMessageSender = self.requestCallback[rpcId];
                 self.requestCallback.Remove(rpcId);
-                Log.Error($"actor request timeout: {rpcId}");
-                actorMessageSender.Callback.Invoke(new ActorResponse() {Error = ErrorCode.ERR_ActorTimeout});
+                try
+                {
+                    IActorResponse response = ActorHelper.CreateResponse((IActorRequest)actorMessageSender.MemoryStream.ToActorMessage(), ErrorCode.ERR_ActorTimeout);
+                    Run(actorMessageSender, response);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e.ToString());
+                }
             }
-            
+
             self.TimeoutActorMessageSenders.Clear();
         }
-        
-        public static void Send(this ActorMessageSenderComponent self, long actorId, IActorMessage message)
+
+        public static void Send(this ActorMessageSenderComponent self, long actorId, IMessage message)
         {
             if (actorId == 0)
             {
-                throw new Exception($"actor id is 0: {MongoHelper.ToJson(message)}");
+                throw new Exception($"actor id is 0: {message}");
             }
-            int process = IdGenerater.GetProcess(actorId);
-            string address = StartProcessConfigCategory.Instance.Get(process).InnerAddress;
-            Session session = NetInnerComponent.Instance.Get(address);
-            message.ActorId = actorId;
-            session.Send(message);
+            
+            ProcessActorId processActorId = new ProcessActorId(actorId);
+            Session session = NetInnerComponent.Instance.Get(processActorId.Process);
+            session.Send(processActorId.ActorId, message);
         }
-		
-        public static ETTask<IActorResponse> Call(this ActorMessageSenderComponent self, long actorId, IActorRequest message, bool exception = true)
+        
+        public static void Send(this ActorMessageSenderComponent self, long actorId, MemoryStream memoryStream)
         {
             if (actorId == 0)
             {
-                throw new Exception($"actor id is 0: {MongoHelper.ToJson(message)}");
+                throw new Exception($"actor id is 0: {memoryStream.ToActorMessage()}");
             }
+            
+            ProcessActorId processActorId = new ProcessActorId(actorId);
+            Session session = NetInnerComponent.Instance.Get(processActorId.Process);
+            session.Send(processActorId.ActorId, memoryStream);
+        }
 
-            var tcs = new ETTaskCompletionSource<IActorResponse>();
+
+        public static int GetRpcId(this ActorMessageSenderComponent self)
+        {
+            return ++self.RpcId;
+        }
+
+        public static async ETTask<IActorResponse> Call(
+                this ActorMessageSenderComponent self,
+                long actorId,
+                IActorRequest request,
+                bool needException = true
+        )
+        {
+            request.RpcId = self.GetRpcId();
             
-            int process = IdGenerater.GetProcess(actorId);
-            string address = StartProcessConfigCategory.Instance.Get(process).InnerAddress;
-            Session session = NetInnerComponent.Instance.Get(address);
-            InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
-            instanceIdStruct.Process = IdGenerater.Process;
-            message.ActorId = instanceIdStruct.ToLong();
-            message.RpcId = ++self.RpcId;
-
-            self.requestCallback.Add(message.RpcId, new ActorMessageSender((response) =>
+            if (actorId == 0)
             {
-                if (exception && ErrorCode.IsRpcNeedThrowException(response.Error))
-                {
-                    tcs.SetException(new Exception($"Rpc error: {MongoHelper.ToJson(response)}"));
-                    return;
-                }
+                throw new Exception($"actor id is 0: {request}");
+            }
 
-                tcs.SetResult(response);
-            }));
-            session.Send(message);
+            (ushort _, MemoryStream stream) = MessageSerializeHelper.MessageToStream(0, request);
 
-            return tcs.Task;
+            return await self.Call(actorId, request.RpcId, stream, needException);
         }
-		
-        public static async ETTask<IActorResponse> CallWithoutException(this ActorMessageSenderComponent self, long actorId,  IActorRequest message)
+        
+        public static async ETTask<IActorResponse> Call(
+                this ActorMessageSenderComponent self,
+                long actorId,
+                int rpcId,
+                MemoryStream memoryStream,
+                bool needException = true
+        )
         {
-            return await self.Call(actorId, message, false);
+            if (actorId == 0)
+            {
+                throw new Exception($"actor id is 0: {memoryStream.ToActorMessage()}");
+            }
+
+            var tcs = new ETTaskCompletionSource<IActorResponse>();
+            
+            self.requestCallback.Add(rpcId, new ActorMessageSender(actorId, memoryStream, tcs, needException));
+            
+            self.Send(actorId, memoryStream);
+
+            long beginTime = TimeHelper.ServerFrameTime();
+            IActorResponse response = await tcs.Task;
+            long endTime = TimeHelper.ServerFrameTime();
+
+            long costTime = endTime - beginTime;
+            if (costTime > 200)
+            {
+                Log.Warning("actor rpc time > 200: {0} {1}", costTime, memoryStream.ToActorMessage());
+            }
+            
+            return response;
         }
-		
-        public static void RunMessage(this ActorMessageSenderComponent self, IActorResponse response)
+
+        public static void RunMessage(this ActorMessageSenderComponent self, long actorId, IActorResponse response)
         {
             ActorMessageSender actorMessageSender;
             if (!self.requestCallback.TryGetValue(response.RpcId, out actorMessageSender))
             {
-                Log.Error($"not found rpc, maybe request timeout, response message: {StringHelper.MessageToStr(response)}");
                 return;
             }
+
             self.requestCallback.Remove(response.RpcId);
             
-            actorMessageSender.Callback(response);
+            Run(actorMessageSender, response);
         }
     }
 }

Server/Hotfix/Module/Actor/MailBoxComponentSystem.cs

@@ -1,52 +1,22 @@
-using System;
-
+using System;
 
 namespace ET
 {
-	public class MailBoxComponentAwakeSystem : AwakeSystem<MailBoxComponent>
-	{
-		public override void Awake(MailBoxComponent self)
-		{
-			self.MailboxType = MailboxType.MessageDispatcher;
-		}
-	}
-
-	public class MailBoxComponentAwake1System : AwakeSystem<MailBoxComponent, MailboxType>
-	{
-		public override void Awake(MailBoxComponent self, MailboxType mailboxType)
-		{
-			self.MailboxType = mailboxType;
-		}
-	}
-	
-	public static class MailBoxComponentSystem
-	{
-		public static async ETTask Handle(this MailBoxComponent self, Session session, IActorMessage message)
-		{
-			using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Mailbox, message.ActorId))
-			{
-				switch (self.MailboxType)
-				{
-					case MailboxType.GateSession:
-						IActorMessage iActorMessage = message as IActorMessage;
-						// 发送给客户端
-						Session clientSession = self.Parent as Session;
-						iActorMessage.ActorId = 0;
-						clientSession.Send(iActorMessage);
-						break;
-					case MailboxType.MessageDispatcher:
-						await ActorMessageDispatcherComponent.Instance.Handle(self.Parent, session, message);
-						break;
-					case MailboxType.UnOrderMessageDispatcher:
-						self.HandleInner(session, message).Coroutine();
-						break;
-				}
-			}
-		}
+    [ObjectSystem]
+    public class MailBoxComponentAwakeSystem: AwakeSystem<MailBoxComponent>
+    {
+        public override void Awake(MailBoxComponent self)
+        {
+            self.MailboxType = MailboxType.MessageDispatcher;
+        }
+    }
 
-		private static async ETVoid HandleInner(this MailBoxComponent self, Session session, IActorMessage message)
-		{
-			await ActorMessageDispatcherComponent.Instance.Handle(self.Parent, session, message);
-		}
-	}
+    [ObjectSystem]
+    public class MailBoxComponentAwake1System: AwakeSystem<MailBoxComponent, MailboxType>
+    {
+        public override void Awake(MailBoxComponent self, MailboxType mailboxType)
+        {
+            self.MailboxType = mailboxType;
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ActorLocationSenderComponentSystem.cs

@@ -1,37 +1,38 @@
-using System;
-
+using System;
+using System.IO;
 
 namespace ET
 {
-    public class ActorLocationSenderComponentAwakeSystem : AwakeSystem<ActorLocationSenderComponent>
+    [ObjectSystem]
+    public class ActorLocationSenderComponentAwakeSystem: AwakeSystem<ActorLocationSenderComponent>
     {
         public override void Awake(ActorLocationSenderComponent self)
         {
             ActorLocationSenderComponent.Instance = self;
-            
-            // 每10s扫描一次过期的actorproxy进行回收,过期时间是1分钟
+
+            // 每10s扫描一次过期的actorproxy进行回收,过期时间是2分钟
             // 可能由于bug或者进程挂掉，导致ActorLocationSender发送的消息没有确认，结果无法自动删除，每一分钟清理一次这种ActorLocationSender
             self.CheckTimer = TimerComponent.Instance.NewRepeatedTimer(10 * 1000, self.Check);
         }
     }
-    
+
+    [ObjectSystem]
     public class ActorLocationSenderComponentDestroySystem: DestroySystem<ActorLocationSenderComponent>
     {
         public override void Destroy(ActorLocationSenderComponent self)
         {
             ActorLocationSenderComponent.Instance = null;
-            TimerComponent.Instance.Remove(self.CheckTimer);
-            self.CheckTimer = 0;
+            TimerComponent.Instance.Remove(ref self.CheckTimer);
         }
     }
-    
+
     public static class ActorLocationSenderComponentSystem
     {
-        public static void Check(this ActorLocationSenderComponent self, bool isTimeOut)
+        public static void Check(this ActorLocationSenderComponent self)
         {
-            using (ListComponent<long> list = EntityFactory.Create<ListComponent<long>>(self.Domain))
+            using (ListComponent<long> list = ListComponent<long>.Create())
             {
-                long timeNow = TimeHelper.Now();
+                long timeNow = TimeHelper.ServerNow();
                 foreach ((long key, Entity value) in self.Children)
                 {
                     ActorLocationSender actorLocationMessageSender = (ActorLocationSender) value;
@@ -48,42 +49,145 @@ namespace ET
                 }
             }
         }
-        
-        private static ActorLocationSender Get(this ActorLocationSenderComponent self, long id)
+
+        private static ActorLocationSender GetOrCreate(this ActorLocationSenderComponent self, long id)
         {
             if (id == 0)
             {
                 throw new Exception($"actor id is 0");
             }
+
             if (self.Children.TryGetValue(id, out Entity actorLocationSender))
             {
-                return (ActorLocationSender)actorLocationSender;
+                return (ActorLocationSender) actorLocationSender;
             }
-			
-            actorLocationSender = EntityFactory.CreateWithId<ActorLocationSender>(self.Domain, id);
-            actorLocationSender.Parent = self;
-            return (ActorLocationSender)actorLocationSender;
+
+            actorLocationSender = EntityFactory.CreateWithParentAndId<ActorLocationSender>(self, id);
+            return (ActorLocationSender) actorLocationSender;
         }
-		
+
         private static void Remove(this ActorLocationSenderComponent self, long id)
         {
             if (!self.Children.TryGetValue(id, out Entity actorMessageSender))
             {
                 return;
             }
+
             actorMessageSender.Dispose();
         }
-        
-        public static void Send(this ActorLocationSenderComponent self, long entityId, IActorLocationMessage message)
+
+        public static void Send(this ActorLocationSenderComponent self, long entityId, IActorRequest message)
+        {
+            self.Call(entityId, message).Coroutine();
+        }
+
+        public static async ETTask<IActorResponse> Call(this ActorLocationSenderComponent self, long entityId, IActorRequest iActorRequest)
         {
-            ActorLocationSender actorLocationSender = self.Get(entityId);
-            actorLocationSender.Send(message);
+            ActorLocationSender actorLocationSender = self.GetOrCreate(entityId);
+
+            // 先序列化好
+            int rpcId = ActorMessageSenderComponent.Instance.GetRpcId();
+            iActorRequest.RpcId = rpcId;
+            (ushort _, MemoryStream stream) = MessageSerializeHelper.MessageToStream(0, iActorRequest);
+            
+            long actorLocationSenderInstanceId = actorLocationSender.InstanceId;
+            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, entityId))
+            {
+                if (actorLocationSender.InstanceId != actorLocationSenderInstanceId)
+                {
+                    throw new RpcException(ErrorCode.ERR_ActorTimeout, $"{stream.ToActorMessage()}");
+                }
+
+                // 队列中没处理的消息返回跟上个消息一样的报错
+                if (actorLocationSender.Error == ErrorCode.ERR_NotFoundActor)
+                {
+                    return ActorHelper.CreateResponse(iActorRequest, actorLocationSender.Error);
+                }
+                
+                try
+                {
+                    return await self.CallInner(actorLocationSender, rpcId, stream);
+                }
+                catch (RpcException)
+                {
+                    self.Remove(actorLocationSender.Id);
+                    throw;
+                }
+                catch (Exception e)
+                {
+                    self.Remove(actorLocationSender.Id);
+                    throw new Exception($"{stream.ToActorMessage()}", e);
+                }
+            }
         }
-		
-        public static async ETTask<IActorResponse> Call(this ActorLocationSenderComponent self, long entityId, IActorLocationRequest message)
+
+        private static async ETTask<IActorResponse> CallInner(this ActorLocationSenderComponent self, ActorLocationSender actorLocationSender, int rpcId, MemoryStream memoryStream)
         {
-            ActorLocationSender actorLocationSender = self.Get(entityId);
-            return await actorLocationSender.Call(message);
+            int failTimes = 0;
+            long instanceId = actorLocationSender.InstanceId;
+            actorLocationSender.LastSendOrRecvTime = TimeHelper.ServerNow();
+            
+            while (true)
+            {
+                if (actorLocationSender.ActorId == 0)
+                {
+                    actorLocationSender.ActorId = await LocationProxyComponent.Instance.Get(actorLocationSender.Id);
+                    if (actorLocationSender.InstanceId != instanceId)
+                    {
+                        throw new RpcException(ErrorCode.ERR_ActorLocationSenderTimeout2, $"{memoryStream.ToActorMessage()}");
+                    }
+                }
+
+                if (actorLocationSender.ActorId == 0)
+                {
+                    IActorRequest iActorRequest = (IActorRequest)memoryStream.ToActorMessage();
+                    return ActorHelper.CreateResponse(iActorRequest, ErrorCode.ERR_NotFoundActor);
+                }
+
+                IActorResponse response = await ActorMessageSenderComponent.Instance.Call(actorLocationSender.ActorId, rpcId, memoryStream, false);
+                if (actorLocationSender.InstanceId != instanceId)
+                {
+                    throw new RpcException(ErrorCode.ERR_ActorLocationSenderTimeout3, $"{memoryStream.ToActorMessage()}");
+                }
+
+                switch (response.Error)
+                {
+                    case ErrorCode.ERR_NotFoundActor:
+                    {
+                        // 如果没找到Actor,重试
+                        ++failTimes;
+                        if (failTimes > 20)
+                        {
+                            Log.Debug($"actor send message fail, actorid: {actorLocationSender.Id}");
+                            actorLocationSender.Error = ErrorCode.ERR_NotFoundActor;
+                            // 这里不能删除actor，要让后面等待发送的消息也返回ERR_NotFoundActor，直到超时删除
+                            return response;
+                        }
+
+                        // 等待0.5s再发送
+                        await TimerComponent.Instance.WaitAsync(500);
+                        if (actorLocationSender.InstanceId != instanceId)
+                        {
+                            throw new RpcException(ErrorCode.ERR_ActorLocationSenderTimeout4, $"{memoryStream.ToActorMessage()}");
+                        }
+
+                        actorLocationSender.ActorId = 0;
+                        continue;
+                    }
+                    case ErrorCode.ERR_ActorNoMailBoxComponent:
+                    case ErrorCode.ERR_ActorTimeout:
+                    {
+                        throw new RpcException(response.Error, $"{memoryStream.ToActorMessage()}");
+                    }
+                }
+
+                if (ErrorCode.IsRpcNeedThrowException(response.Error))
+                {
+                    throw new RpcException(response.Error, $"Message: {response.Message} Request: {memoryStream.ToActorMessage()}");
+                }
+
+                return response;
+            }
         }
     }
 }

Server/Hotfix/Module/ActorLocation/ActorLocationSenderSystem.cs

@@ -1,28 +1,19 @@
-using System;
-
+using System;
 
 namespace ET
 {
+    [ObjectSystem]
     public class ActorLocationSenderAwakeSystem: AwakeSystem<ActorLocationSender>
     {
         public override void Awake(ActorLocationSender self)
         {
-            self.LastSendOrRecvTime = TimeHelper.Now();
-            self.FailTimes = 0;
+            self.LastSendOrRecvTime = TimeHelper.ServerNow();
             self.ActorId = 0;
-
-            StartAsync(self).Coroutine();
-        }
-
-        public async ETVoid StartAsync(ActorLocationSender self)
-        {
-            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, self.Id))
-            {
-                self.ActorId = await Game.Scene.GetComponent<LocationProxyComponent>().Get(self.Id);
-            }
+            self.Error = 0;
         }
     }
 
+    [ObjectSystem]
     public class ActorLocationSenderDestroySystem: DestroySystem<ActorLocationSender>
     {
         public override void Destroy(ActorLocationSender self)
@@ -30,100 +21,7 @@ namespace ET
             Log.Debug($"actor location remove: {self.Id}");
             self.LastSendOrRecvTime = 0;
             self.ActorId = 0;
-            self.FailTimes = 0;
-        }
-    }
-
-    public static class ActorLocationSenderHelper
-    {
-        private static async ETTask<IActorResponse> Run(this ActorLocationSender self, IActorRequest iActorRequest)
-        {
-            long instanceId = self.InstanceId;
-            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, self.Id))
-            {
-                if (self.InstanceId != instanceId)
-                {
-                    throw new RpcException(ErrorCode.ERR_ActorRemove, $"{MongoHelper.ToJson(iActorRequest)}");
-                }
-
-                return await self.RunInner(iActorRequest);
-            }
-        }
-
-        private static async ETTask<IActorResponse> RunInner(this ActorLocationSender self, IActorRequest iActorRequest)
-        {
-            try
-            {
-                if (self.ActorId == 0)
-                {
-                    Log.Info($"actor send message fail, actorid: {self.Id}");
-                    self.Dispose();
-                    return new ActorResponse() { Error = ErrorCode.ERR_ActorNotOnline };
-                }
-
-                self.LastSendOrRecvTime = TimeHelper.Now();
-                IActorResponse response = await ActorMessageSenderComponent.Instance.CallWithoutException(self.ActorId, iActorRequest);
-
-                switch (response.Error)
-                {
-                    case ErrorCode.ERR_NotFoundActor:
-                    {
-                        // 如果没找到Actor,重试
-                        ++self.FailTimes;
-                        if (self.FailTimes > ActorLocationSender.MaxFailTimes)
-                        {
-                            Log.Info($"actor send message fail, actorid: {self.Id}");
-                            self.Dispose();
-                            return response;
-                        }
-
-                        // 等待0.5s再发送
-                        long instanceId = self.InstanceId;
-                        await TimerComponent.Instance.WaitAsync(500);
-                        if (self.InstanceId != instanceId)
-                        {
-                            throw new RpcException(ErrorCode.ERR_ActorRemove, $"{MongoHelper.ToJson(iActorRequest)}");
-                        }
-                        self.ActorId = await LocationProxyComponent.Instance.Get(self.Id);
-                        return await self.RunInner(iActorRequest);
-                    }
-                }
-
-                self.LastSendOrRecvTime = TimeHelper.Now();
-                self.FailTimes = 0;
-
-                return response;
-            }
-            catch (RpcException)
-            {
-                self.Dispose();
-                throw;
-            }
-            catch (Exception e)
-            {
-                self.Dispose();
-                throw new Exception($"{MongoHelper.ToJson(iActorRequest)}\n{e}");
-            }
-        }
-
-        public static void Send(this ActorLocationSender self, IActorLocationMessage request)
-        {
-            if (request == null)
-            {
-                throw new Exception($"actor location send message is null");
-            }
-
-            self.Run(request).Coroutine();
-        }
-
-        public static async ETTask<IActorResponse> Call(this ActorLocationSender self, IActorLocationRequest request)
-        {
-            if (request == null)
-            {
-                throw new Exception($"actor location call message is null");
-            }
-
-            return await self.Run(request);
+            self.Error = 0;
         }
     }
 }

Server/Hotfix/Module/ActorLocation/LocationProxyComponentSystem.cs

@@ -1,72 +1,78 @@
 using System;
 
-
 namespace ET
 {
-	public class LocationProxyComponentSystem : AwakeSystem<LocationProxyComponent>
-	{
-		public override void Awake(LocationProxyComponent self)
-		{
-			self.Awake();
-		}
-	}
-	
-	public static class LocationProxyComponentEx
-	{
-		public static void Awake(this LocationProxyComponent self)
-		{
-			LocationProxyComponent.Instance = self;
-		}
+    [ObjectSystem]
+    public class LocationProxyComponentSystem: AwakeSystem<LocationProxyComponent>
+    {
+        public override void Awake(LocationProxyComponent self)
+        {
+            self.Awake();
+        }
+    }
+
+    public static class LocationProxyComponentEx
+    {
+        public static void Awake(this LocationProxyComponent self)
+        {
+            LocationProxyComponent.Instance = self;
+        }
+        
+        private static long GetLocationSceneId(long key)
+        {
+            return StartSceneConfigCategory.Instance.LocationConfig.SceneId;
+        }
+
+        public static async ETTask Add(this LocationProxyComponent self, long key, long instanceId)
+        {
+            Log.Info($"location proxy add {key}, {instanceId} {TimeHelper.ServerNow()}");
+            await MessageHelper.CallActor(GetLocationSceneId(key),
+                new ObjectAddRequest() { Key = key, InstanceId = instanceId });
+        }
+
+        public static async ETTask Lock(this LocationProxyComponent self, long key, long instanceId, int time = 1000)
+        {
+            Log.Info($"location proxy lock {key}, {instanceId} {TimeHelper.ServerNow()}");
+            await MessageHelper.CallActor(GetLocationSceneId(key),
+                new ObjectLockRequest() { Key = key, InstanceId = instanceId, Time = time });
+        }
 
-		public static async ETTask Add(this LocationProxyComponent self, long key, long instanceId)
-		{
-			await MessageHelper.CallActor(
-				StartSceneConfigCategory.Instance.LocationConfig.SceneId, 
-				new ObjectAddRequest() { Key = key, InstanceId = instanceId });
-		}
+        public static async ETTask UnLock(this LocationProxyComponent self, long key, long oldInstanceId, long instanceId)
+        {
+            Log.Info($"location proxy unlock {key}, {instanceId} {TimeHelper.ServerNow()}");
+            await MessageHelper.CallActor(GetLocationSceneId(key),
+                new ObjectUnLockRequest() { Key = key, OldInstanceId = oldInstanceId, InstanceId = instanceId });
+        }
 
-		public static async ETTask Lock(this LocationProxyComponent self, long key, long instanceId, int time = 1000)
-		{
-			await MessageHelper.CallActor(
-				StartSceneConfigCategory.Instance.LocationConfig.SceneId, 
-				new ObjectLockRequest() { Key = key, InstanceId = instanceId, Time = time });
-		}
+        public static async ETTask Remove(this LocationProxyComponent self, long key)
+        {
+            Log.Info($"location proxy add {key}, {TimeHelper.ServerNow()}");
+            await MessageHelper.CallActor(GetLocationSceneId(key),
+                new ObjectRemoveRequest() { Key = key });
+        }
 
-		public static async ETTask UnLock(this LocationProxyComponent self, long key, long oldInstanceId, long instanceId)
-		{
-			await MessageHelper.CallActor(
-				StartSceneConfigCategory.Instance.LocationConfig.SceneId,
-				new ObjectUnLockRequest() { Key = key, OldInstanceId = oldInstanceId, InstanceId = instanceId });
-		}
+        public static async ETTask<long> Get(this LocationProxyComponent self, long key)
+        {
+            if (key == 0)
+            {
+                throw new Exception($"get location key 0");
+            }
 
-		public static async ETTask Remove(this LocationProxyComponent self, long key)
-		{
-			await MessageHelper.CallActor(
-				StartSceneConfigCategory.Instance.LocationConfig.SceneId,
-				new ObjectRemoveRequest() { Key = key });
-		}
+            // location server配置到共享区，一个大战区可以配置N多个location server,这里暂时为1
+            ObjectGetResponse response =
+                    (ObjectGetResponse) await MessageHelper.CallActor(GetLocationSceneId(key),
+                        new ObjectGetRequest() { Key = key });
+            return response.InstanceId;
+        }
 
-		public static async ETTask<long> Get(this LocationProxyComponent self, long key)
-		{
-			if (key == 0)
-			{
-				throw new Exception($"get location key 0");
-			}
-			ObjectGetResponse response =
-					(ObjectGetResponse)await MessageHelper.CallActor(
-						StartSceneConfigCategory.Instance.LocationConfig.SceneId, 
-						new ObjectGetRequest() { Key = key });
-			return response.InstanceId;
-		}
-		
-		public static async ETTask AddLocation(this Entity self)
-		{
-			await Game.Scene.GetComponent<LocationProxyComponent>().Add(self.Id, self.InstanceId);
-		}
+        public static async ETTask AddLocation(this Entity self)
+        {
+            await LocationProxyComponent.Instance.Add(self.Id, self.InstanceId);
+        }
 
-		public static async ETTask RemoveLocation(this Entity self)
-		{
-			await Game.Scene.GetComponent<LocationProxyComponent>().Remove(self.Id);
-		}
-	}
+        public static async ETTask RemoveLocation(this Entity self)
+        {
+            await LocationProxyComponent.Instance.Remove(self.Id);
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ObjectAddRequestHandler.cs

@@ -1,15 +1,17 @@
 using System;
 
-
 namespace ET
 {
-	[ActorMessageHandler]
-	public class ObjectAddRequestHandler : AMActorRpcHandler<Scene, ObjectAddRequest, ObjectAddResponse>
-	{
-		protected override async ETTask Run(Scene scene, ObjectAddRequest request, ObjectAddResponse response, Action reply)
-		{
-			await scene.GetComponent<LocationComponent>().Add(request.Key, request.InstanceId);
-			reply();
-		}
-	}
+    [ActorMessageHandler]
+    public class ObjectAddRequestHandler: AMActorRpcHandler<Scene, ObjectAddRequest, ObjectAddResponse>
+    {
+        protected override async ETTask Run(Scene scene, ObjectAddRequest request, ObjectAddResponse response, Action reply)
+        {
+            await scene.GetComponent<LocationComponent>().Add(request.Key, request.InstanceId);
+
+            reply();
+
+            await ETTask.CompletedTask;
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ObjectGetRequestHandler.cs

@@ -1,20 +1,15 @@
 using System;
 
-
 namespace ET
 {
-	[ActorMessageHandler]
-	public class ObjectGetRequestHandler : AMActorRpcHandler<Scene, ObjectGetRequest, ObjectGetResponse>
-	{
-		protected override async ETTask Run(Scene scene, ObjectGetRequest request, ObjectGetResponse response, Action reply)
-		{
-			long instanceId = await scene.GetComponent<LocationComponent>().Get(request.Key);
-			if (instanceId == 0)
-			{
-				response.Error = ErrorCode.ERR_ActorLocationNotFound;
-			}
-			response.InstanceId = instanceId;
-			reply();
-		}
-	}
+    [ActorMessageHandler]
+    public class ObjectGetRequestHandler: AMActorRpcHandler<Scene, ObjectGetRequest, ObjectGetResponse>
+    {
+        protected override async ETTask Run(Scene scene, ObjectGetRequest request, ObjectGetResponse response, Action reply)
+        {
+            long instanceId = await scene.GetComponent<LocationComponent>().Get(request.Key);
+            response.InstanceId = instanceId;
+            reply();
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ObjectLockRequestHandler.cs

@@ -1,17 +1,17 @@
 using System;
 
-
 namespace ET
 {
-	[ActorMessageHandler]
-	public class ObjectLockRequestHandler : AMActorRpcHandler<Scene, ObjectLockRequest, ObjectLockResponse>
-	{
-		protected override async ETTask Run(Scene scene, ObjectLockRequest request, ObjectLockResponse response, Action reply)
-		{
-			scene.GetComponent<LocationComponent>().Lock(request.Key, request.InstanceId, request.Time).Coroutine();
-			reply();
-			
-			await ETTask.CompletedTask;
-		}
-	}
+    [ActorMessageHandler]
+    public class ObjectLockRequestHandler: AMActorRpcHandler<Scene, ObjectLockRequest, ObjectLockResponse>
+    {
+        protected override async ETTask Run(Scene scene, ObjectLockRequest request, ObjectLockResponse response, Action reply)
+        {
+            scene.GetComponent<LocationComponent>().Lock(request.Key, request.InstanceId, request.Time).Coroutine();
+
+            reply();
+
+            await ETTask.CompletedTask;
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ObjectRemoveRequestHandler.cs

@@ -1,16 +1,15 @@
 using System;
 
-
 namespace ET
 {
-	[ActorMessageHandler]
-	public class ObjectRemoveRequestHandler : AMActorRpcHandler<Scene, ObjectRemoveRequest, ObjectRemoveResponse>
-	{
-		protected override async ETTask Run(Scene scene, ObjectRemoveRequest request, ObjectRemoveResponse response, Action reply)
-		{
-			await scene.GetComponent<LocationComponent>().Remove(request.Key);
-			reply();
-			await ETTask.CompletedTask;
-		}
-	}
+    [ActorMessageHandler]
+    public class ObjectRemoveRequestHandler: AMActorRpcHandler<Scene, ObjectRemoveRequest, ObjectRemoveResponse>
+    {
+        protected override async ETTask Run(Scene scene, ObjectRemoveRequest request, ObjectRemoveResponse response, Action reply)
+        {
+            await scene.GetComponent<LocationComponent>().Remove(request.Key);
+
+            reply();
+        }
+    }
 }

Server/Hotfix/Module/ActorLocation/ObjectUnLockRequestHandler.cs

@@ -1,16 +1,17 @@
 using System;
 
-
 namespace ET
 {
-	[ActorMessageHandler]
-	public class ObjectUnLockRequestHandler : AMActorRpcHandler<Scene, ObjectUnLockRequest, ObjectUnLockResponse>
-	{
-		protected override async ETTask Run(Scene scene, ObjectUnLockRequest request, ObjectUnLockResponse response, Action reply)
-		{
-			scene.GetComponent<LocationComponent>().UnLock(request.Key, request.OldInstanceId, request.InstanceId);
-			reply();
-			await ETTask.CompletedTask;
-		}
-	}
+    [ActorMessageHandler]
+    public class ObjectUnLockRequestHandler: AMActorRpcHandler<Scene, ObjectUnLockRequest, ObjectUnLockResponse>
+    {
+        protected override async ETTask Run(Scene scene, ObjectUnLockRequest request, ObjectUnLockResponse response, Action reply)
+        {
+            scene.GetComponent<LocationComponent>().UnLock(request.Key, request.OldInstanceId, request.InstanceId);
+
+            reply();
+
+            await ETTask.CompletedTask;
+        }
+    }
 }

Server/Hotfix/Module/Benchmark/BenchmarkComponentSystem.cs

@@ -1,78 +0,0 @@
-using System;
-using System.Net;
-using System.Threading.Tasks;
-
-
-namespace ET
-{
-	public class BenchmarkComponentSystem : AwakeSystem<BenchmarkComponent, string>
-	{
-		public override void Awake(BenchmarkComponent self, string a)
-		{
-			self.Awake(a);
-		}
-	}
-
-	public static class BenchmarkComponentHelper
-	{
-		public static void Awake(this BenchmarkComponent self, string address)
-		{
-			try
-			{
-				IPEndPoint ipEndPoint = NetworkHelper.ToIPEndPoint(address);
-				NetOuterComponent networkComponent = Game.Scene.GetComponent<NetOuterComponent>();
-				for (int i = 0; i < 2000; i++)
-				{
-					self.TestAsync(networkComponent, ipEndPoint, i);
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-
-		public static async void TestAsync(this BenchmarkComponent self, NetOuterComponent networkComponent, IPEndPoint ipEndPoint, int j)
-		{
-			try
-			{
-				using (Session session = networkComponent.Create(ipEndPoint))
-				{
-					int i = 0;
-					while (i < 100000000)
-					{
-						++i;
-						await self.Send(session, j);
-					}
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-
-		public static async Task Send(this BenchmarkComponent self, Session session, int j)
-		{
-			try
-			{
-				await session.Call(new C2R_Ping());
-				++self.k;
-
-				if (self.k % 100000 != 0)
-				{
-					return;
-				}
-
-				long time2 = TimeHelper.ClientNow();
-				long time = time2 - self.time1;
-				self.time1 = time2;
-				Log.Info($"Benchmark k: {self.k} 每10W次耗时: {time} ms {session.Network.Count}");
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-	}
-}

Server/Hotfix/Module/Benchmark/WebSocketBenchmarkComponentSystem.cs

@@ -1,79 +0,0 @@
-using System;
-
-
-namespace ET
-{
-	public class WebSocketBenchmarkComponentSystem : AwakeSystem<WebSocketBenchmarkComponent, string>
-	{
-		public override void Awake(WebSocketBenchmarkComponent self, string address)
-		{
-			self.Awake(address);
-		}
-	}
-
-	public static class WebSocketBenchmarkComponentHelper
-	{
-		public static void Awake(this WebSocketBenchmarkComponent self, string address)
-		{
-			try
-			{
-				NetOuterComponent networkComponent = Game.Scene.GetComponent<NetOuterComponent>();
-				for (int i = 0; i < 1000; i++)
-				{
-					self.TestAsync(networkComponent, i, address).Coroutine();
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-		
-		public static async ETVoid TestAsync(this WebSocketBenchmarkComponent self, NetOuterComponent networkComponent, int j, string address)
-		{
-			try
-			{
-				using (Session session = networkComponent.Create(address))
-				{
-					int i = 0;
-					while (i < 100000000)
-					{
-						++i;
-						await self.Send(session, j);
-					}
-				}
-			}
-			catch (RpcException e)
-			{
-				Log.Error(e);
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-		
-		public static async ETTask Send(this WebSocketBenchmarkComponent self, Session session, int j)
-		{
-			try
-			{
-				await session.Call(new C2R_Ping());
-				++self.k;
-
-				if (self.k % 10000 != 0)
-				{
-					return;
-				}
-
-				long time2 = TimeHelper.ClientNow();
-				long time = time2 - self.time1;
-				self.time1 = time2;
-				Log.Info($"Benchmark k: {self.k} 每1W次耗时: {time} ms {session.Network.Count}");
-			}
-			catch (Exception e)
-			{
-				Log.Error(e);
-			}
-		}
-	}
-}

Server/Hotfix/Module/Message/InnerMessageDispatcher.cs

@@ -1,37 +1,108 @@
-
+using System;
+using System.IO;
+using System.Net;
 
 namespace ET
 {
     public class InnerMessageDispatcher: IMessageDispatcher
     {
-        public void Dispatch(Session session, ushort opcode, object message)
+        public void Dispatch(Session session, MemoryStream memoryStream)
         {
-            // 收到actor消息,放入actor队列
-            switch (message)
+            ushort opcode = 0;
+            try
             {
-                case IActorRequest iActorRequest:
-                {
-                    InnerMessageDispatcherHelper.HandleIActorRequest(session, iActorRequest).Coroutine();
-                    return;
-                }
-                case IActorMessage iactorMessage:
+                long actorId = BitConverter.ToInt64(memoryStream.GetBuffer(), Packet.ActorIdIndex);
+                opcode = BitConverter.ToUInt16(memoryStream.GetBuffer(), Packet.OpcodeIndex);
+                Type type = null;
+                object message = null;
+#if SERVER   
+
+                // 内网收到外网消息，有可能是gateUnit消息，还有可能是gate广播消息
+                if (OpcodeTypeComponent.Instance.IsOutrActorMessage(opcode))
                 {
-                    InnerMessageDispatcherHelper.HandleIActorMessage(session, iactorMessage).Coroutine();
-                    return;
+                    InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
+                    instanceIdStruct.Process = Game.Options.Process;
+                    long realActorId = instanceIdStruct.ToLong();
+                    
+                    
+                    Entity entity = Game.EventSystem.Get(realActorId);
+                    if (entity == null)
+                    {
+                        type = OpcodeTypeComponent.Instance.GetType(opcode);
+                        message = MessageSerializeHelper.DeserializeFrom(opcode, type, memoryStream);
+                        Log.Error($"not found actor: {session.DomainScene().Name}  {opcode} {realActorId} {message}");
+                        return;
+                    }
+                    
+                    if (entity is Session gateSession)
+                    {
+                        // 发送给客户端
+                        memoryStream.Seek(Packet.OpcodeIndex, SeekOrigin.Begin);
+                        gateSession.Send(0, memoryStream);
+                        return;
+                    }
                 }
-                case IActorResponse iActorResponse:
+#endif
+                        
+                        
+                type = OpcodeTypeComponent.Instance.GetType(opcode);
+                message = MessageSerializeHelper.DeserializeFrom(opcode, type, memoryStream);
+
+                if (message is IResponse iResponse && !(message is IActorResponse))
                 {
-                    InnerMessageDispatcherHelper.HandleIActorResponse(session, iActorResponse).Coroutine();
+                    session.OnRead(opcode, iResponse);
                     return;
                 }
-                default:
+
+                OpcodeHelper.LogMsg(session.DomainZone(), opcode, message);
+
+                // 收到actor消息,放入actor队列
+                switch (message)
                 {
-                    MessageDispatcherComponent.Instace.Handle(session, new MessageInfo(opcode, message));
-                    break;
+                    case IActorRequest iActorRequest:
+                    {
+                        InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
+                        int fromProcess = instanceIdStruct.Process;
+                        instanceIdStruct.Process = Game.Options.Process;
+                        long realActorId = instanceIdStruct.ToLong();
+                        
+                        void Reply(IActorResponse response)
+                        {
+                            Session replySession = NetInnerComponent.Instance.Get(fromProcess);
+                            // 发回真实的actorId 做查问题使用
+                            replySession.Send(realActorId, response);
+                        }
+
+                        InnerMessageDispatcherHelper.HandleIActorRequest(opcode, realActorId, iActorRequest, Reply);
+                        return;
+                    }
+                    case IActorResponse iActorResponse:
+                    {
+                        InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
+                        instanceIdStruct.Process = Game.Options.Process;
+                        long realActorId = instanceIdStruct.ToLong();
+                        InnerMessageDispatcherHelper.HandleIActorResponse(opcode, realActorId, iActorResponse);
+                        return;
+                    }
+                    case IActorMessage iactorMessage:
+                    {
+                        InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
+                        instanceIdStruct.Process = Game.Options.Process;
+                        long realActorId = instanceIdStruct.ToLong();
+                        InnerMessageDispatcherHelper.HandleIActorMessage(opcode, realActorId, iactorMessage);
+                        return;
+                    }
+                    default:
+                    {
+                        MessageDispatcherComponent.Instance.Handle(session, opcode, message);
+                        break;
+                    }
                 }
             }
+            catch (Exception e)
+            {
+                Log.Error($"InnerMessageDispatcher error: {opcode}\n{e}");
+            }
         }
-		
-
     }
 }

Server/Hotfix/Module/Message/InnerMessageDispatcherHelper.cs

@@ -1,76 +1,113 @@
-
+using System;
+using System.IO;
 
- namespace ET
+namespace ET
 {
     public static class InnerMessageDispatcherHelper
     {
-        public static async ETVoid HandleIActorResponse(Session session, IActorResponse iActorResponse)
-		{
-			ActorMessageSenderComponent.Instance.RunMessage(iActorResponse);
-			await ETTask.CompletedTask;
-		}
+        public static void HandleIActorResponse(ushort opcode, long actorId, IActorResponse iActorResponse)
+        {
+            ActorMessageSenderComponent.Instance.RunMessage(actorId, iActorResponse);
+        }
 
-		public static async ETVoid HandleIActorRequest(Session session, IActorRequest iActorRequest)
-		{
-			InstanceIdStruct instanceIdStruct = new InstanceIdStruct(iActorRequest.ActorId);
-			int replyId = instanceIdStruct.Process;
-			instanceIdStruct.Process = IdGenerater.Process;
-			iActorRequest.ActorId = instanceIdStruct.ToLong();
+        public static void HandleIActorRequest(ushort opcode, long actorId, IActorRequest iActorRequest, Action<IActorResponse> reply)
+        {
+            Entity entity = Game.EventSystem.Get(actorId);
+            if (entity == null)
+            {
+                FailResponse(iActorRequest, ErrorCode.ERR_NotFoundActor, reply);
+                return;
+            }
 
-			string address = StartProcessConfigCategory.Instance.Get(replyId).InnerAddress;
-			Session ss = NetInnerComponent.Instance.Get(address);
-			Entity entity = Game.EventSystem.Get(iActorRequest.ActorId);
-			if (entity == null)
-			{
-				Log.Warning($"not found actor: {MongoHelper.ToJson(iActorRequest)}");
-				ActorResponse response = new ActorResponse
-				{
-					Error = ErrorCode.ERR_NotFoundActor,
-					RpcId = iActorRequest.RpcId,
-				};
-				ss.Reply(response);
-				return;
-			}
-	
-			MailBoxComponent mailBoxComponent = entity.GetComponent<MailBoxComponent>();
-			if (mailBoxComponent == null)
-			{
-				ActorResponse response = new ActorResponse
-				{
-					Error = ErrorCode.ERR_ActorNoMailBoxComponent,
-					RpcId = iActorRequest.RpcId,
-				};
-				ss.Reply(response);
-				Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorRequest}");
-				return;
-			}
-			
-			await mailBoxComponent.Handle(ss, iActorRequest);
-		}
+            MailBoxComponent mailBoxComponent = entity.GetComponent<MailBoxComponent>();
+            if (mailBoxComponent == null)
+            {
+                FailResponse(iActorRequest, ErrorCode.ERR_ActorNoMailBoxComponent, reply);
+                return;
+            }
 
-		public static async ETVoid HandleIActorMessage(Session session, IActorMessage iActorMessage)
-		{
-			InstanceIdStruct instanceIdStruct = new InstanceIdStruct(iActorMessage.ActorId);
-			int replyId = instanceIdStruct.Process;
-			instanceIdStruct.Process = IdGenerater.Process;
-			iActorMessage.ActorId = instanceIdStruct.ToLong();
-			
-			Entity entity = Game.EventSystem.Get(iActorMessage.ActorId);
-			if (entity == null)
-			{
-				Log.Error($"not found actor: {MongoHelper.ToJson(iActorMessage)}");
-				return;
-			}
-	
-			MailBoxComponent mailBoxComponent = entity.GetComponent<MailBoxComponent>();
-			if (mailBoxComponent == null)
-			{
-				Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorMessage}");
-				return;
-			}
-			
-			Session ss = NetInnerComponent.Instance.Get(replyId);
-			await mailBoxComponent.Handle(ss, iActorMessage);
-		}
+            switch (mailBoxComponent.MailboxType)
+            {
+                case MailboxType.MessageDispatcher:
+                {
+                    async ETVoid MessageDispatcherHandler()
+                    {
+                        long instanceId = entity.InstanceId;
+                        using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Mailbox, actorId))
+                        {
+                            if (entity.InstanceId != instanceId)
+                            {
+                                FailResponse(iActorRequest, ErrorCode.ERR_NotFoundActor, reply);
+                                return;
+                            }
+
+                            await ActorMessageDispatcherComponent.Instance.Handle(entity, iActorRequest, reply);
+                        }
+                    }
+                    
+                    MessageDispatcherHandler().Coroutine();
+                    break;
+                }
+                case MailboxType.UnOrderMessageDispatcher:
+                {
+                    ActorMessageDispatcherComponent.Instance.Handle(entity, iActorRequest, reply).Coroutine();
+                    break;
+                }
+            }
+        }
+
+        private static void FailResponse(IActorRequest iActorRequest, int error, Action<IActorResponse> reply)
+        {
+            IActorResponse response = ActorHelper.CreateResponse(iActorRequest, error);
+            reply.Invoke(response);
+        }
+
+
+        public static void HandleIActorMessage(ushort opcode, long actorId, IActorMessage iActorMessage)
+        {
+            OpcodeHelper.LogMsg(opcode, actorId, iActorMessage);
+
+            Entity entity = Game.EventSystem.Get(actorId);
+            if (entity == null)
+            {
+                Log.Error($"not found actor: {actorId} {iActorMessage}");
+                return;
+            }
+
+            MailBoxComponent mailBoxComponent = entity.GetComponent<MailBoxComponent>();
+            if (mailBoxComponent == null)
+            {
+                Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorMessage}");
+                return;
+            }
+
+            switch (mailBoxComponent.MailboxType)
+            {
+                
+                case MailboxType.MessageDispatcher:
+                {
+                    async ETVoid MessageDispatcherHandler()
+                    {
+                        long instanceId = entity.InstanceId;
+                        using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Mailbox, actorId))
+                        {
+                            if (entity.InstanceId != instanceId)
+                            {
+                                return;
+                            }
+
+                            await ActorMessageDispatcherComponent.Instance.Handle(entity, iActorMessage, null);
+                        }
+                    }
+                    MessageDispatcherHandler().Coroutine();
+                    break;
+                }
+                case MailboxType.UnOrderMessageDispatcher:
+                {
+                    ActorMessageDispatcherComponent.Instance.Handle(entity, iActorMessage, null).Coroutine();
+                    break;
+                }
+            }
+        }
     }
 }

Server/Hotfix/Module/Message/MessageDispatherComponentSystem.cs

@@ -1,95 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-
-namespace ET
-{
-	public class MessageDispatcherComponentAwakeSystem : AwakeSystem<MessageDispatcherComponent>
-	{
-		public override void Awake(MessageDispatcherComponent self)
-		{
-			MessageDispatcherComponent.Instace = self;
-			self.Load();
-		}
-	}
-
-	public class MessageDispatcherComponentLoadSystem : LoadSystem<MessageDispatcherComponent>
-	{
-		public override void Load(MessageDispatcherComponent self)
-		{
-			self.Load();
-		}
-	}
-	
-	public class MessageDispatcherComponentDestroySystem: DestroySystem<MessageDispatcherComponent>
-	{
-		public override void Destroy(MessageDispatcherComponent self)
-		{
-			MessageDispatcherComponent.Instace = null;
-			self.Handlers.Clear();
-		}
-	}
-
-	/// <summary>
-	/// 消息分发组件
-	/// </summary>
-	public static class MessageDispatcherComponentHelper
-	{
-		public static void Load(this MessageDispatcherComponent self)
-		{
-			self.Handlers.Clear();
-
-			HashSet<Type> types = Game.EventSystem.GetTypes(typeof(MessageHandlerAttribute));
-
-			foreach (Type type in types)
-			{
-				IMHandler iMHandler = Activator.CreateInstance(type) as IMHandler;
-				if (iMHandler == null)
-				{
-					Log.Error($"message handle {type.Name} 需要继承 IMHandler");
-					continue;
-				}
-
-				Type messageType = iMHandler.GetMessageType();
-				ushort opcode = OpcodeTypeComponent.Instance.GetOpcode(messageType);
-				if (opcode == 0)
-				{
-					Log.Error($"消息opcode为0: {messageType.Name}");
-					continue;
-				}
-				self.RegisterHandler(opcode, iMHandler);
-			}
-		}
-
-		public static void RegisterHandler(this MessageDispatcherComponent self, ushort opcode, IMHandler handler)
-		{
-			if (!self.Handlers.ContainsKey(opcode))
-			{
-				self.Handlers.Add(opcode, new List<IMHandler>());
-			}
-			self.Handlers[opcode].Add(handler);
-		}
-
-		public static void Handle(this MessageDispatcherComponent self, Session session, MessageInfo messageInfo)
-		{
-			List<IMHandler> actions;
-			if (!self.Handlers.TryGetValue(messageInfo.Opcode, out actions))
-			{
-				Log.Error($"消息没有处理: {messageInfo.Opcode} {JsonHelper.ToJson(messageInfo.Message)}");
-				return;
-			}
-			
-			foreach (IMHandler ev in actions)
-			{
-				try
-				{
-					ev.Handle(session, messageInfo.Message);
-				}
-				catch (Exception e)
-				{
-					Log.Error(e);
-				}
-			}
-		}
-	}
-}

Server/Hotfix/Module/Message/NetInnerComponentSystem.cs

@@ -1,40 +1,131 @@
-
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading;
 
 namespace ET
 {
-	public class NetInnerComponentAwakeSystem : AwakeSystem<NetInnerComponent>
-	{
-		public override void Awake(NetInnerComponent self)
-		{
-			NetInnerComponent.Instance = self;
-			self.Awake(NetworkProtocol.TCP);
-			self.MessageDispatcher = new InnerMessageDispatcher();
-		}
-	}
-
-	public class NetInnerComponentAwake1System : AwakeSystem<NetInnerComponent, string>
-	{
-		public override void Awake(NetInnerComponent self, string a)
-		{
-			NetInnerComponent.Instance = self;
-			self.Awake(NetworkProtocol.TCP, a);
-			self.MessageDispatcher = new InnerMessageDispatcher();
-		}
-	}
-	
-	public class NetInnerComponentLoadSystem : LoadSystem<NetInnerComponent>
-	{
-		public override void Load(NetInnerComponent self)
-		{
-			self.MessageDispatcher = new InnerMessageDispatcher();
-		}
-	}
-
-	public class NetInnerComponentUpdateSystem : UpdateSystem<NetInnerComponent>
-	{
-		public override void Update(NetInnerComponent self)
-		{
-			self.Update();
-		}
-	}
+    [ObjectSystem]
+    public class NetInnerComponentAwakeSystem: AwakeSystem<NetInnerComponent>
+    {
+        public override void Awake(NetInnerComponent self)
+        {
+            NetInnerComponent.Instance = self;
+            self.MessageDispatcher = new InnerMessageDispatcher();
+            
+            self.Service = new TService(NetThreadComponent.Instance.ThreadSynchronizationContext, ServiceType.Inner);
+            self.Service.ErrorCallback += self.OnError;
+            self.Service.ReadCallback += self.OnRead;
+
+            NetThreadComponent.Instance.Add(self.Service);
+        }
+    }
+
+    [ObjectSystem]
+    public class NetInnerComponentAwake1System: AwakeSystem<NetInnerComponent, IPEndPoint>
+    {
+        public override void Awake(NetInnerComponent self, IPEndPoint address)
+        {
+            NetInnerComponent.Instance = self;
+            self.MessageDispatcher = new InnerMessageDispatcher();
+
+            self.Service = new TService(NetThreadComponent.Instance.ThreadSynchronizationContext, address, ServiceType.Inner);
+            self.Service.ErrorCallback += self.OnError;
+            self.Service.ReadCallback += self.OnRead;
+            self.Service.AcceptCallback += self.OnAccept;
+
+            NetThreadComponent.Instance.Add(self.Service);
+        }
+    }
+
+    [ObjectSystem]
+    public class NetInnerComponentLoadSystem: LoadSystem<NetInnerComponent>
+    {
+        public override void Load(NetInnerComponent self)
+        {
+            self.MessageDispatcher = new InnerMessageDispatcher();
+        }
+    }
+
+    [ObjectSystem]
+    public class NetInnerComponentDestroySystem: DestroySystem<NetInnerComponent>
+    {
+        public override void Destroy(NetInnerComponent self)
+        {
+            NetThreadComponent.Instance.Remove(self.Service);
+            self.Service.Destroy();
+        }
+    }
+
+    public static class NetInnerComponentSystem
+    {
+        public static void OnRead(this NetInnerComponent self, long channelId, MemoryStream memoryStream)
+        {
+            Session session = self.GetChild<Session>(channelId);
+            if (session == null)
+            {
+                return;
+            }
+
+            session.LastRecvTime = TimeHelper.ClientNow();
+            self.MessageDispatcher.Dispatch(session, memoryStream);
+        }
+
+        public static void OnError(this NetInnerComponent self, long channelId, int error)
+        {
+            Session session = self.GetChild<Session>(channelId);
+            if (session == null)
+            {
+                return;
+            }
+
+            session.Error = error;
+            session.Dispose();
+        }
+
+        // 这个channelId是由CreateAcceptChannelId生成的
+        public static void OnAccept(this NetInnerComponent self, long channelId, IPEndPoint ipEndPoint)
+        {
+            Session session = EntityFactory.CreateWithParentAndId<Session, AService>(self, channelId, self.Service);
+            session.RemoteAddress = ipEndPoint;
+            //session.AddComponent<SessionIdleCheckerComponent, int, int, int>(NetThreadComponent.checkInteral, NetThreadComponent.recvMaxIdleTime, NetThreadComponent.sendMaxIdleTime);
+        }
+
+        // 这个channelId是由CreateConnectChannelId生成的
+        public static Session Create(this NetInnerComponent self, IPEndPoint ipEndPoint)
+        {
+            uint localConn = self.Service.CreateRandomLocalConn(self.Random);
+            long channelId = self.Service.CreateConnectChannelId(localConn);
+            Session session = self.CreateInner(channelId, ipEndPoint);
+            return session;
+        }
+
+        private static Session CreateInner(this NetInnerComponent self, long channelId, IPEndPoint ipEndPoint)
+        {
+            Session session = EntityFactory.CreateWithParentAndId<Session, AService>(self, channelId, self.Service);
+
+            session.RemoteAddress = ipEndPoint;
+
+            self.Service.GetOrCreate(channelId, ipEndPoint);
+
+            //session.AddComponent<InnerPingComponent>();
+            //session.AddComponent<SessionIdleCheckerComponent, int, int, int>(NetThreadComponent.checkInteral, NetThreadComponent.recvMaxIdleTime, NetThreadComponent.sendMaxIdleTime);
+
+            return session;
+        }
+
+        // 内网actor session，channelId是进程号
+        public static Session Get(this NetInnerComponent self, long channelId)
+        {
+            Session session = self.GetChild<Session>(channelId);
+            if (session == null)
+            {
+                IPEndPoint ipEndPoint = StartProcessConfigCategory.Instance.Get((int) channelId).InnerIPPort;
+                session = self.CreateInner(channelId, ipEndPoint);
+            }
+
+            return session;
+        }
+    }
 }

Server/Hotfix/Module/Message/OuterMessageDispatcher.cs

@@ -1,11 +1,26 @@
 
 
+using System;
+using System.IO;
+
 namespace ET
 {
 	public class OuterMessageDispatcher: IMessageDispatcher
 	{
-		public void Dispatch(Session session, ushort opcode, object message)
+		public void Dispatch(Session session, MemoryStream memoryStream)
 		{
+			ushort opcode = BitConverter.ToUInt16(memoryStream.GetBuffer(), Packet.KcpOpcodeIndex);
+			Type type = OpcodeTypeComponent.Instance.GetType(opcode);
+			object message = MessageSerializeHelper.DeserializeFrom(opcode, type, memoryStream);
+
+			if (message is IResponse response)
+			{
+				session.OnRead(opcode, response);
+				return;
+			}
+
+			OpcodeHelper.LogMsg(session.DomainZone(), opcode, message);
+			
 			DispatchAsync(session, opcode, message).Coroutine();
 		}
 		
@@ -46,7 +61,7 @@ namespace ET
 				default:
 				{
 					// 非Actor消息
-					MessageDispatcherComponent.Instace.Handle(session, new MessageInfo(opcode, message));
+					MessageDispatcherComponent.Instance.Handle(session, opcode, message);
 					break;
 				}
 			}

Server/Hotfix/Scene/SceneFactory.cs

@@ -1,12 +1,14 @@
 
 
+using System.Net;
+
 namespace ET
 {
     public static class SceneFactory
     {
         public static async ETTask<Scene> Create(Entity parent, string name, SceneType sceneType)
         {
-            long id = IdGenerater.GenerateId();
+            long id = IdGenerater.Instance.GenerateId();
             return await Create(parent, id, parent.DomainZone(), name, sceneType);
         }
         
@@ -21,10 +23,10 @@ namespace ET
             switch (scene.SceneType)
             {
                 case SceneType.Realm:
-                    scene.AddComponent<NetOuterComponent, string>(startSceneConfig.OuterAddress);
+                    scene.AddComponent<NetKcpComponent, IPEndPoint>(startSceneConfig.OuterIPPort);
                     break;
                 case SceneType.Gate:
-                    scene.AddComponent<NetOuterComponent, string>(startSceneConfig.OuterAddress);
+                    scene.AddComponent<NetKcpComponent, IPEndPoint>(startSceneConfig.OuterIPPort);
                     scene.AddComponent<PlayerComponent>();
                     scene.AddComponent<GateSessionKeyComponent>();
                     break;

Server/Hotfix/Scene/SceneHelper.cs

@@ -2,14 +2,5 @@ namespace ET
 {
     public static class SceneHelper
     {
-        public static int DomainZone(this Entity entity)
-        {
-            return ((Scene) entity.Domain).Zone;
-        }
-        
-        public static Scene DomainScene(this Entity entity)
-        {
-            return (Scene) entity.Domain;
-        }
     }
 }

Server/Hotfix/Server.Hotfix.csproj

@@ -20,8 +20,20 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Other\**" />
-    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\NetOuterComponentSystem.cs">
-      <Link>Module\Message\NetOuterComponentSystem.cs</Link>
+    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\MessageDispatcherComponentSystem.cs">
+      <Link>Module\Message\MessageDispatcherComponentSystem.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\NetKcpComponentSystem.cs">
+      <Link>Module\Message\NetKcpComponentSystem.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\NetThreadComponentSystem.cs">
+      <Link>Module\Message\NetThreadComponentSystem.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\SessionAcceptTimeoutComponentSystem.cs">
+      <Link>Module\Message\SessionAcceptTimeoutComponentSystem.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Hotfix\Module\Message\SessionIdleCheckerComponentSystem.cs">
+      <Link>Module\Message\SessionIdleCheckerComponentSystem.cs</Link>
     </Compile>
     <Compile Include="..\..\Unity\Assets\Hotfix\Module\Numeric\NumericChangeEvent_NotifyWatcher.cs">
       <Link>Module\Numeric\NumericChangeEvent_NotifyWatcher.cs</Link>

Server/Model/Base/DllHelper.cs

@@ -0,0 +1,16 @@
+using System.IO;
+using System.Reflection;
+
+namespace ET
+{
+    public static class DllHelper
+    {
+        public static Assembly GetHotfixAssembly()
+        {
+            byte[] dllBytes = File.ReadAllBytes("./Server.Hotfix.dll");
+            byte[] pdbBytes = File.ReadAllBytes("./Server.Hotfix.pdb");
+            Assembly assembly = Assembly.Load(dllBytes, pdbBytes);
+            return assembly;
+        }
+    }
+}

Server/Model/Base/Helper/DllHelper.cs

@@ -1,16 +0,0 @@
-using System.IO;
-using System.Reflection;
-
-namespace ET
-{
-	public static class DllHelper
-	{
-		public static Assembly GetHotfixAssembly()
-		{
-			byte[] dllBytes = File.ReadAllBytes("./Hotfix.dll");
-			byte[] pdbBytes = File.ReadAllBytes("./Hotfix.pdb");
-			Assembly assembly = Assembly.Load(dllBytes, pdbBytes);
-			return assembly;
-		}
-	}
-}

Server/Model/Base/Log.cs

@@ -1,54 +0,0 @@
-using System;
-
-namespace ET
-{
-	public static class Log
-	{
-		private static readonly ILog globalLog = new NLogAdapter();
-
-		public static void Trace(string message)
-		{
-			globalLog.Trace(message);
-		}
-
-		public static void Warning(string message)
-		{
-			globalLog.Warning(message);
-		}
-
-		public static void Info(string message)
-		{
-			globalLog.Info(message);
-		}
-
-		public static void Debug(string message)
-		{
-			globalLog.Debug(message);
-		}
-
-		public static void Error(Exception e)
-		{
-			globalLog.Error(e.ToString());
-		}
-
-		public static void Error(string message)
-		{
-			globalLog.Error(message);
-		}
-
-        public static void Fatal(Exception e)
-        {
-            globalLog.Fatal(e.ToString());
-        }
-
-        public static void Fatal(string message)
-        {
-            globalLog.Fatal(message);
-        }
-
-		public static void Msg(object message)
-		{
-			globalLog.Debug(MongoHelper.ToJson(message));
-		}
-    }
-}

Server/Model/Base/Logger/ILog.cs

@@ -1,18 +0,0 @@
-namespace ET
-{
-	public interface ILog
-	{
-		void Trace(string message);
-		void Warning(string message);
-		void Info(string message);
-		void Debug(string message);
-		void Error(string message);
-        void Fatal(string message);
-		void Trace(string message, params object[] args);
-		void Warning(string message, params object[] args);
-		void Info(string message, params object[] args);
-		void Debug(string message, params object[] args);
-		void Error(string message, params object[] args);
-		void Fatal(string message, params object[] args);
-    }
-}

Server/Model/Base/Logger/NLogAdapter.cs

@@ -1,69 +0,0 @@
-using NLog;
-
-namespace ET
-{
-	public class NLogAdapter: ILog
-	{
-		private readonly Logger logger = LogManager.GetLogger("Logger");
-
-		public void Trace(string message)
-		{
-			this.logger.Trace(message);
-		}
-
-		public void Warning(string message)
-		{
-			this.logger.Warn(message);
-		}
-
-		public void Info(string message)
-		{
-			this.logger.Info(message);
-		}
-
-		public void Debug(string message)
-		{
-			this.logger.Debug(message);
-		}
-
-		public void Error(string message)
-		{
-			this.logger.Error(message);
-		}
-
-        public void Fatal(string message)
-        {
-            this.logger.Fatal(message);
-        }
-
-		public void Trace(string message, params object[] args)
-		{
-			this.logger.Trace(message, args);
-		}
-
-		public void Warning(string message, params object[] args)
-		{
-			this.logger.Warn(message, args);
-		}
-
-		public void Info(string message, params object[] args)
-		{
-			this.logger.Info(message, args);
-		}
-
-		public void Debug(string message, params object[] args)
-		{
-			this.logger.Debug(message, args);
-		}
-
-		public void Error(string message, params object[] args)
-		{
-			this.logger.Error(message, args);
-		}
-
-		public void Fatal(string message, params object[] args)
-		{
-			this.logger.Fatal(message, args);
-		}
-	}
-}

Server/Model/ConfigPartial/StartProcessConfig.cs

@@ -1,44 +1,37 @@
-using System.ComponentModel;
+using System.Net;
 
 namespace ET
 {
-	public partial class StartProcessConfigCategory
-	{
-		public override void EndInit()
-		{
-		}
-	}
-	
-	public partial class StartProcessConfig: ISupportInitialize
-	{
-		private string innerAddress;
-
-		public string InnerAddress
-		{
-			get
-			{
-				if (this.innerAddress == null)
-				{
-					this.innerAddress = $"{StartMachineConfigCategory.Instance.Get(this.MachineId).InnerIP}:{this.InnerPort}";
-				}
-				return this.innerAddress;
-			}
-		}
-
-		public string OuterIP
-		{
-			get
-			{
-				return StartMachineConfigCategory.Instance.Get(this.MachineId).OuterIP;
-			}
-		}
-
-		public void BeginInit()
-		{
-		}
-
-		public void EndInit()
-		{
-		}
-	}
-}
+    public partial class StartProcessConfig
+    {
+        private IPEndPoint innerIPPort;
+
+        public long SceneId;
+
+        public IPEndPoint InnerIPPort
+        {
+            get
+            {
+                if (this.innerIPPort == null)
+                {
+                    this.innerIPPort = NetworkHelper.ToIPEndPoint($"{this.InnerIP}:{this.InnerPort}");
+                }
+
+                return this.innerIPPort;
+            }
+        }
+
+        public string InnerIP => this.StartMachineConfig.InnerIP;
+
+        public string OuterIP => this.StartMachineConfig.OuterIP;
+
+        public StartMachineConfig StartMachineConfig => StartMachineConfigCategory.Instance.Get(this.MachineId);
+
+        public void EndInit()
+        {
+            InstanceIdStruct instanceIdStruct = new InstanceIdStruct((int)this.Id, 0);
+            this.SceneId = instanceIdStruct.ToLong();
+            Log.Info($"StartProcess info: {this.MachineId} {this.Id} {this.SceneId}");
+        }
+    }
+}

Server/Model/ConfigPartial/StartSceneConfig.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Net;
 
 namespace ET
 {
@@ -70,31 +71,35 @@ namespace ET
             }
         }
 
-        private string outerAddress;
-        
-        public string OuterAddress
+        // 内网地址外网端口，通过防火墙映射端口过来
+        private IPEndPoint innerIPOutPort;
+
+        public IPEndPoint InnerIPOutPort
         {
             get
             {
-                if (this.outerAddress == null)
+                if (innerIPOutPort == null)
                 {
-                    this.outerAddress = $"{this.StartProcessConfig.OuterIP}:{this.OuterPort}";
+                    this.innerIPOutPort = NetworkHelper.ToIPEndPoint($"{this.StartProcessConfig.InnerIP}:{this.OuterPort}");
                 }
-                return this.outerAddress;
+
+                return this.innerIPOutPort;
             }
         }
-        
-        private string innerOuterAddress;
-        
-        public string InnerOuterAddress
+
+        private IPEndPoint outerIPPort;
+
+        // 外网地址外网端口
+        public IPEndPoint OuterIPPort
         {
             get
             {
-                if (this.innerOuterAddress == null)
+                if (this.outerIPPort == null)
                 {
-                    this.innerOuterAddress = $"{this.StartProcessConfig.InnerAddress}:{this.OuterPort}";
+                    this.outerIPPort = NetworkHelper.ToIPEndPoint($"{this.StartProcessConfig.OuterIP}:{this.OuterPort}");
                 }
-                return this.innerOuterAddress;
+
+                return this.outerIPPort;
             }
         }
 

Server/Model/Demo/MoveComponent.cs

@@ -25,7 +25,7 @@ namespace ET
         {
             Unit unit = this.GetParent<Unit>();
             this.StartPos = unit.Position;
-            this.StartTime = TimeHelper.Now();
+            this.StartTime = TimeHelper.ClientNow();
             float distance = (this.Target - this.StartPos).magnitude;
             if (Math.Abs(distance) < 0.1f)
             {
@@ -37,9 +37,9 @@ namespace ET
             TimerComponent timerComponent = Game.Scene.GetComponent<TimerComponent>();
             
             // 协程如果取消，将算出玩家的真实位置，赋值给玩家
-            cancellationToken.Register(() =>
+            cancellationToken.Add(() =>
             {
-                long timeNow = TimeHelper.Now();
+                long timeNow = TimeHelper.ClientNow();
                 if (timeNow - this.StartTime >= this.needTime)
                 {
                     unit.Position = this.Target;
@@ -55,7 +55,7 @@ namespace ET
             {
                 await timerComponent.WaitAsync(50, cancellationToken);
                 
-                long timeNow = TimeHelper.Now();
+                long timeNow = TimeHelper.ClientNow();
                 
                 if (timeNow - this.StartTime >= this.needTime)
                 {

Server/Model/Generate/InnerProtoOpcode.cs

@@ -0,0 +1,29 @@
+namespace ET
+{
+    public static partial class InnerOpcode
+    {
+        public const ushort M2M_TrasferUnitRequest = 10001;
+        public const ushort M2M_TrasferUnitResponse = 10002;
+        public const ushort M2A_Reload = 10003;
+        public const ushort A2M_Reload = 10004;
+        public const ushort G2G_LockRequest = 10005;
+        public const ushort G2G_LockResponse = 10006;
+        public const ushort G2G_LockReleaseRequest = 10007;
+        public const ushort G2G_LockReleaseResponse = 10008;
+        public const ushort ObjectAddRequest = 10009;
+        public const ushort ObjectAddResponse = 10010;
+        public const ushort ObjectLockRequest = 10011;
+        public const ushort ObjectLockResponse = 10012;
+        public const ushort ObjectUnLockRequest = 10013;
+        public const ushort ObjectUnLockResponse = 10014;
+        public const ushort ObjectRemoveRequest = 10015;
+        public const ushort ObjectRemoveResponse = 10016;
+        public const ushort ObjectGetRequest = 10017;
+        public const ushort ObjectGetResponse = 10018;
+        public const ushort R2G_GetLoginKey = 10019;
+        public const ushort G2R_GetLoginKey = 10020;
+        public const ushort G2M_CreateUnit = 10021;
+        public const ushort M2G_CreateUnit = 10022;
+        public const ushort G2M_SessionDisconnect = 10023;
+    }
+}

Server/Model/Generate/OuterProtoOpcode.cs

@@ -0,0 +1,31 @@
+namespace ET
+{
+    public static partial class OuterOpcode
+    {
+        public const ushort C2M_TestRequest = 20001;
+        public const ushort M2C_TestResponse = 20002;
+        public const ushort Actor_TransferRequest = 20003;
+        public const ushort Actor_TransferResponse = 20004;
+        public const ushort C2G_EnterMap = 20005;
+        public const ushort G2C_EnterMap = 20006;
+        public const ushort UnitInfo = 20007;
+        public const ushort M2C_CreateUnits = 20008;
+        public const ushort Frame_ClickMap = 20009;
+        public const ushort M2C_PathfindingResult = 20010;
+        public const ushort C2R_Ping = 20011;
+        public const ushort R2C_Ping = 20012;
+        public const ushort G2C_Test = 20013;
+        public const ushort C2M_Reload = 20014;
+        public const ushort M2C_Reload = 20015;
+        public const ushort C2R_Login = 20016;
+        public const ushort R2C_Login = 20017;
+        public const ushort C2G_LoginGate = 20018;
+        public const ushort G2C_LoginGate = 20019;
+        public const ushort G2C_TestHotfixMessage = 20020;
+        public const ushort C2M_TestActorRequest = 20021;
+        public const ushort M2C_TestActorResponse = 20022;
+        public const ushort PlayerInfo = 20023;
+        public const ushort C2G_PlayerInfo = 20024;
+        public const ushort G2C_PlayerInfo = 20025;
+    }
+}

Server/Model/Module/Actor/AMActorHandler.cs

@@ -2,38 +2,43 @@
 
 namespace ET
 {
-	public abstract class AMActorHandler<E, Message>: IMActorHandler where E: Entity where Message : class, IActorMessage
-	{
-		protected abstract ETTask Run(E entity, Message message);
+    [ActorMessageHandler]
+    public abstract class AMActorHandler<E, Message>: IMActorHandler where E : Entity where Message : class, IActorMessage
+    {
+        protected abstract ETTask Run(E entity, Message message);
 
-		public async ETTask Handle(Session session, Entity entity, object actorMessage)
-		{
-			Message msg = actorMessage as Message;
-			if (msg == null)
-			{
-				Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Message).Name}");
-				return;
-			}
-			E e = entity as E;
-			if (e == null)
-			{
-				Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
-				return;
-			}
+        public async ETTask Handle(Entity entity, object actorMessage, Action<IActorResponse> reply)
+        {
+            Message msg = actorMessage as Message;
+            if (msg == null)
+            {
+                Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Message).Name}");
+                return;
+            }
 
-			try
-			{
-				await this.Run(e, msg);
-			}
-			catch (Exception exception)
-			{
-				Log.Error(exception);
-			}
-		}
+            E e = entity as E;
+            if (e == null)
+            {
+                Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof (E).Name} --{typeof (Message).Name}");
+                return;
+            }
 
-		public Type GetMessageType()
-		{
-			return typeof (Message);
-		}
-	}
+            await this.Run(e, msg);
+        }
+
+        public Type GetRequestType()
+        {
+            if (typeof (IActorLocationMessage).IsAssignableFrom(typeof (Message)))
+            {
+                Log.Error($"message is IActorLocationMessage but handler is AMActorHandler: {typeof (Message)}");
+            }
+
+            return typeof (Message);
+        }
+
+        public Type GetResponseType()
+        {
+            return null;
+        }
+    }
 }

Server/Model/Module/Actor/AMActorRpcHandler.cs

@@ -2,64 +2,69 @@
 
 namespace ET
 {
-	public abstract class AMActorRpcHandler<E, Request, Response>: IMActorHandler where E: Entity where Request: class, IActorRequest where Response : class, IActorResponse
-	{
-		protected abstract ETTask Run(E unit, Request request, Response response, Action reply);
+    [ActorMessageHandler]
+    public abstract class AMActorRpcHandler<E, Request, Response>: IMActorHandler where E : Entity where Request : class, IActorRequest where Response : class, IActorResponse
+    {
+        protected abstract ETTask Run(E unit, Request request, Response response, Action reply);
 
-		public async ETTask Handle(Session session, Entity entity, object actorMessage)
-		{
-			try
-			{
-				Request request = actorMessage as Request;
-				if (request == null)
-				{
-					Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Request).Name}");
-					return;
-				}
-				E e = entity as E;
-				if (e == null)
-				{
-					Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
-					return;
-				}
+        public async ETTask Handle(Entity entity, object actorMessage, Action<IActorResponse> reply)
+        {
+            try
+            {
+                Request request = actorMessage as Request;
+                if (request == null)
+                {
+                    Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Request).Name}");
+                    return;
+                }
 
-				int rpcId = request.RpcId;
-				long instanceId = session.InstanceId;
-				Response response = Activator.CreateInstance<Response>();
+                E ee = entity as E;
+                if (ee == null)
+                {
+                    Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof (E).Name} --{typeof (Request).Name}");
+                    return;
+                }
 
-				void Reply()
-				{
-					// 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
-					if (session.InstanceId != instanceId)
-					{
-						return;
-					}
+                int rpcId = request.RpcId;
+                Response response = Activator.CreateInstance<Response>();
 
-					response.RpcId = rpcId;
-					session.Reply(response);
-				}
+                void Reply()
+                {
+                    response.RpcId = rpcId;
+                    reply.Invoke(response);
+                }
 
-				try
-				{
-					await this.Run(e, request, response, Reply);
-				}
-				catch (Exception exception)
-				{
-					Log.Error(exception);
-					response.Error = ErrorCode.ERR_RpcFail;
-					response.Message = e.ToString();
-					Reply();
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error($"解释消息失败: {actorMessage.GetType().FullName}\n{e}");
-			}
-		}
+                try
+                {
+                    await this.Run(ee, request, response, Reply);
+                }
+                catch (Exception exception)
+                {
+                    Log.Error(exception);
+                    response.Error = ErrorCode.ERR_RpcFail;
+                    response.Message = exception.ToString();
+                    Reply();
+                }
+            }
+            catch (Exception e)
+            {
+                throw new Exception($"解释消息失败: {actorMessage.GetType().FullName}", e);
+            }
+        }
 
-		public Type GetMessageType()
-		{
-			return typeof (Request);
-		}
-	}
+        public Type GetRequestType()
+        {
+            if (typeof (IActorLocationRequest).IsAssignableFrom(typeof (Request)))
+            {
+                Log.Error($"message is IActorLocationMessage but handler is AMActorRpcHandler: {typeof (Request)}");
+            }
+
+            return typeof (Request);
+        }
+
+        public Type GetResponseType()
+        {
+            return typeof (Response);
+        }
+    }
 }

Server/Model/Module/Actor/ActorMessageAttribute.cs

@@ -2,13 +2,13 @@
 
 namespace ET
 {
-	public class ActorMessageAttribute : Attribute
-	{
-		public ushort Opcode { get; private set; }
+    public class ActorMessageAttribute: Attribute
+    {
+        public ushort Opcode { get; private set; }
 
-		public ActorMessageAttribute(ushort opcode)
-		{
-			this.Opcode = opcode;
-		}
-	}
+        public ActorMessageAttribute(ushort opcode)
+        {
+            this.Opcode = opcode;
+        }
+    }
 }

Server/Model/Module/Actor/ActorMessageDispatcherComponent.cs

@@ -3,13 +3,13 @@ using System.Collections.Generic;
 
 namespace ET
 {
-	/// <summary>
-	/// Actor消息分发组件
-	/// </summary>
-	public class ActorMessageDispatcherComponent : Entity
-	{
-		public static ActorMessageDispatcherComponent Instance;
-		
-		public readonly Dictionary<Type, IMActorHandler> ActorMessageHandlers = new Dictionary<Type, IMActorHandler>();
-	}
+    /// <summary>
+    /// Actor消息分发组件
+    /// </summary>
+    public class ActorMessageDispatcherComponent: Entity
+    {
+        public static ActorMessageDispatcherComponent Instance;
+
+        public readonly Dictionary<Type, IMActorHandler> ActorMessageHandlers = new Dictionary<Type, IMActorHandler>();
+    }
 }

Server/Model/Module/Actor/ActorMessageHandlerAttribute.cs

@@ -1,6 +1,6 @@
 namespace ET
 {
-	public class ActorMessageHandlerAttribute : BaseAttribute
-	{
-	}
+    public class ActorMessageHandlerAttribute: BaseAttribute
+    {
+    }
 }

Server/Model/Module/Actor/ActorMessageSender.cs

@@ -1,19 +1,28 @@
-using System;
+using System.IO;
 
 namespace ET
 {
-	// 知道对方的instanceId，使用这个类发actor消息
-	public struct ActorMessageSender
-	{
-		// 最近接收或者发送消息的时间
-		public long CreateTime { get; }
-		// actor的地址
-		public Action<IActorResponse> Callback { get; }
+    // 知道对方的instanceId，使用这个类发actor消息
+    public readonly struct ActorMessageSender
+    {
+        public long ActorId { get; }
 
-		public ActorMessageSender(Action<IActorResponse> callback)
-		{
-			this.CreateTime = TimeHelper.Now();
-			this.Callback = callback;
-		}
-	}
+        // 最近接收或者发送消息的时间
+        public long CreateTime { get; }
+        
+        public MemoryStream MemoryStream { get; }
+
+        public bool NeedException { get; }
+
+        public ETTaskCompletionSource<IActorResponse> Tcs { get; }
+
+        public ActorMessageSender(long actorId, MemoryStream memoryStream, ETTaskCompletionSource<IActorResponse> tcs, bool needException)
+        {
+            this.ActorId = actorId;
+            this.MemoryStream = memoryStream;
+            this.CreateTime = TimeHelper.ServerNow();
+            this.Tcs = tcs;
+            this.NeedException = needException;
+        }
+    }
 }

Server/Model/Module/Actor/ActorMessageSenderComponent.cs

@@ -2,18 +2,18 @@
 
 namespace ET
 {
-	public class ActorMessageSenderComponent: Entity
-	{
-		public static long TIMEOUT_TIME = 30 * 1000;
-		
-		public static ActorMessageSenderComponent Instance { get; set; }
-		
-		public int RpcId;
-		
-		public readonly Dictionary<int, ActorMessageSender> requestCallback = new Dictionary<int, ActorMessageSender>();
+    public class ActorMessageSenderComponent: Entity
+    {
+        public static long TIMEOUT_TIME = 40 * 1000;
 
-		public long TimeoutCheckTimer;
-		
-		public List<int> TimeoutActorMessageSenders = new List<int>();
-	}
-}
+        public static ActorMessageSenderComponent Instance { get; set; }
+
+        public int RpcId;
+
+        public readonly SortedDictionary<int, ActorMessageSender> requestCallback = new SortedDictionary<int, ActorMessageSender>();
+
+        public long TimeoutCheckTimer;
+
+        public List<int> TimeoutActorMessageSenders = new List<int>();
+    }
+}

Server/Model/Module/Actor/ActorResponse.cs

@@ -1,15 +0,0 @@
-namespace ET
-{
-	/// <summary>
-	/// actor RPC消息响应
-	/// </summary>
-	[Message(Opcode.ActorResponse)]
-	public class ActorResponse : IActorLocationResponse
-	{
-		public int RpcId { get; set; }
-
-		public int Error { get; set; }
-
-		public string Message { get; set; }
-	}
-}

Server/Model/Module/Actor/ActorTask.cs

@@ -1,21 +0,0 @@
-namespace ET
-{
-	public struct ActorTask
-	{
-		public IActorRequest ActorRequest;
-		
-		public ETTaskCompletionSource<IActorLocationResponse> Tcs;
-
-		public ActorTask(IActorLocationMessage actorRequest)
-		{
-			this.ActorRequest = actorRequest;
-			this.Tcs = null;
-		}
-		
-		public ActorTask(IActorLocationRequest actorRequest, ETTaskCompletionSource<IActorLocationResponse> tcs)
-		{
-			this.ActorRequest = actorRequest;
-			this.Tcs = tcs;
-		}
-	}
-}

Server/Model/Module/Actor/IMActorHandler.cs

@@ -2,9 +2,10 @@
 
 namespace ET
 {
-	public interface IMActorHandler
-	{
-		ETTask Handle(Session session, Entity entity, object actorMessage);
-		Type GetMessageType();
-	}
+    public interface IMActorHandler
+    {
+        ETTask Handle(Entity entity, object actorMessage, Action<IActorResponse> reply);
+        Type GetRequestType();
+        Type GetResponseType();
+    }
 }

Server/Model/Module/Actor/MailBoxComponent.cs

@@ -1,11 +1,11 @@
 namespace ET
 {
-	/// <summary>
-	/// 挂上这个组件表示该Entity是一个Actor,接收的消息将会队列处理
-	/// </summary>
-	public class MailBoxComponent: Entity
-	{
-		// Mailbox的类型
-		public MailboxType MailboxType;
-	}
+    /// <summary>
+    /// 挂上这个组件表示该Entity是一个Actor,接收的消息将会队列处理
+    /// </summary>
+    public class MailBoxComponent: Entity
+    {
+        // Mailbox的类型
+        public MailboxType MailboxType;
+    }
 }

Server/Model/Module/Actor/MailboxType.cs

@@ -1,9 +1,9 @@
 namespace ET
 {
-	public enum MailboxType
-	{
-		MessageDispatcher,
-		UnOrderMessageDispatcher,
-		GateSession,
-	}
-}
+    public enum MailboxType
+    {
+        MessageDispatcher,
+        UnOrderMessageDispatcher,
+        GateSession,
+    }
+}

Server/Model/Module/ActorLocation/AMActorLocationHandler.cs

@@ -2,42 +2,42 @@
 
 namespace ET
 {
-	public abstract class AMActorLocationHandler<E, Message>: IMActorHandler where E: Entity where Message : class, IActorLocationMessage
-	{
-		protected abstract ETTask Run(E entity, Message message);
+    [ActorMessageHandler]
+    public abstract class AMActorLocationHandler<E, Message>: IMActorHandler where E : Entity where Message : class, IActorLocationMessage
+    {
+        protected abstract ETTask Run(E entity, Message message);
 
-		public async ETTask Handle(Session session, Entity entity, object actorMessage)
-		{
-			Message msg = actorMessage as Message;
-			if (msg == null)
-			{
-				Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Message).Name}");
-				return;
-			}
-			E e = entity as E;
-			if (e == null)
-			{
-				Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
-				return;
-			}
-			
-			ActorResponse actorResponse = new ActorResponse();
-			actorResponse.RpcId = msg.RpcId;
-			session.Reply(actorResponse);
+        public async ETTask Handle(Entity entity, object actorMessage, Action<IActorResponse> reply)
+        {
+            Message msg = actorMessage as Message;
+            if (msg == null)
+            {
+                Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Message).Name}");
+                return;
+            }
 
-			try
-			{
-				await this.Run(e, msg);
-			}
-			catch (Exception exception)
-			{
-				Log.Error(exception);
-			}
-		}
+            E e = entity as E;
+            if (e == null)
+            {
+                Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof (E).Name} --{typeof (Message).Name}");
+                return;
+            }
 
-		public Type GetMessageType()
-		{
-			return typeof (Message);
-		}
-	}
+            IActorResponse response = (IActorResponse) Activator.CreateInstance(GetResponseType());
+            response.RpcId = msg.RpcId;
+            reply.Invoke(response);
+
+            await this.Run(e, msg);
+        }
+
+        public Type GetRequestType()
+        {
+            return typeof (Message);
+        }
+
+        public Type GetResponseType()
+        {
+            return typeof (ActorResponse);
+        }
+    }
 }

Server/Model/Module/ActorLocation/AMActorLocationRpcHandler.cs

@@ -2,64 +2,64 @@
 
 namespace ET
 {
-	public abstract class AMActorLocationRpcHandler<E, Request, Response>: IMActorHandler where E: Entity where Request: class, IActorLocationRequest where Response : class, IActorLocationResponse
-	{
-		protected abstract ETTask Run(E unit, Request message, Response response, Action reply);
+    [ActorMessageHandler]
+    public abstract class AMActorLocationRpcHandler<E, Request, Response>: IMActorHandler where E : Entity where Request : class, IActorLocationRequest where Response : class, IActorLocationResponse
+    {
+        protected abstract ETTask Run(E unit, Request request, Response response, Action reply);
 
-		public async ETTask Handle(Session session, Entity entity, object actorMessage)
-		{
-			try
-			{
-				Request request = actorMessage as Request;
-				if (request == null)
-				{
-					Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Request).Name}");
-					return;
-				}
-				E e = entity as E;
-				if (e == null)
-				{
-					Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
-					return;
-				}
+        public async ETTask Handle(Entity entity, object actorMessage, Action<IActorResponse> reply)
+        {
+            try
+            {
+                Request request = actorMessage as Request;
+                if (request == null)
+                {
+                    Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Request).Name}");
+                    return;
+                }
 
-				int rpcId = request.RpcId;
-				long instanceId = session.InstanceId;
-				Response response = Activator.CreateInstance<Response>();
+                E ee = entity as E;
+                if (ee == null)
+                {
+                    Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof (E).Name} --{typeof (Request).Name}");
+                    return;
+                }
 
-				void Reply()
-				{
-					// 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
-					if (session.InstanceId != instanceId)
-					{
-						return;
-					}
+                int rpcId = request.RpcId;
+                Response response = Activator.CreateInstance<Response>();
 
-					response.RpcId = rpcId;
-					session.Reply(response);
-				}
+                void Reply()
+                {
+                    response.RpcId = rpcId;
+                    reply.Invoke(response);
+                }
 
-				try
-				{
-					await this.Run(e, request, response, Reply);
-				}
-				catch (Exception exception)
-				{
-					Log.Error(exception);
-					response.Error = ErrorCode.ERR_RpcFail;
-					response.Message = e.ToString();
-					Reply();
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error($"解释消息失败: {actorMessage.GetType().FullName}\n{e}");
-			}
-		}
+                try
+                {
+                    await this.Run(ee, request, response, Reply);
+                }
+                catch (Exception exception)
+                {
+                    Log.Error(exception);
+                    response.Error = ErrorCode.ERR_RpcFail;
+                    response.Message = exception.ToString();
+                    Reply();
+                }
+            }
+            catch (Exception e)
+            {
+                throw new Exception($"解释消息失败: {actorMessage.GetType().FullName}", e);
+            }
+        }
 
-		public Type GetMessageType()
-		{
-			return typeof (Request);
-		}
-	}
+        public Type GetRequestType()
+        {
+            return typeof (Request);
+        }
+
+        public Type GetResponseType()
+        {
+            return typeof (Response);
+        }
+    }
 }

Server/Model/Module/ActorLocation/ActorLocationSender.cs

@@ -1,15 +1,15 @@
-namespace ET
+using System.IO;
+
+namespace ET
 {
     // 知道对方的Id，使用这个类发actor消息
-    public class ActorLocationSender : Entity
+    public class ActorLocationSender: Entity
     {
         public long ActorId;
 
         // 最近接收或者发送消息的时间
         public long LastSendOrRecvTime;
-		
-        public int FailTimes;
 
-        public const int MaxFailTimes = 5;
+        public int Error;
     }
 }

Server/Model/Module/ActorLocation/ActorLocationSenderComponent.cs

@@ -1,12 +1,11 @@
-using System;
+using System.Collections.Generic;
 
 namespace ET
 {
     public class ActorLocationSenderComponent: Entity
     {
-        [NoMemoryCheck]
-        public static long TIMEOUT_TIME = 10 * 1000;
-        
+        public static long TIMEOUT_TIME = 60 * 1000;
+
         public static ActorLocationSenderComponent Instance { get; set; }
 
         public long CheckTimer;

Server/Model/Module/ActorLocation/LocationComponent.cs

@@ -1,128 +1,129 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace ET
 {
-	public class LockInfoAwakeSystem : AwakeSystem<LockInfo, long, CoroutineLock>
-	{
-		public override void Awake(LockInfo self, long lockInstanceId, CoroutineLock coroutineLock)
-		{
-			self.CoroutineLock = coroutineLock;
-			self.LockInstanceId = lockInstanceId;
-		}
-	}
-	
-	public class LockInfo: Entity
-	{
-		public long LockInstanceId;
-		
-		public CoroutineLock CoroutineLock;
-
-		public override void Dispose()
-		{
-			if (this.IsDisposed)
-			{
-				return;
-			}
-			
-			base.Dispose();
-			
-			this.CoroutineLock.Dispose();
-			this.CoroutineLock = null;
-			LockInstanceId = 0;
-		}
-	}
-	
-	public class LocationComponent : Entity
-	{
-		private readonly Dictionary<long, long> locations = new Dictionary<long, long>();
-		
-		private readonly Dictionary<long, LockInfo> lockInfos = new Dictionary<long, LockInfo>();
-
-		public async ETTask Add(long key, long instanceId)
-		{
-			using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
-			{
-				this.locations[key] = instanceId;
-				Log.Info($"location add key: {key} instanceId: {instanceId}");
-			}
-		}
-
-		public async ETTask Remove(long key)
-		{
-			using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
-			{
-				this.locations.Remove(key);
-				Log.Info($"location remove key: {key}");
-			}
-		}
-
-		public async ETVoid Lock(long key, long instanceId, int time = 0)
-		{
-			CoroutineLock coroutineLock = await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key);
-
-			LockInfo lockInfo = EntityFactory.Create<LockInfo, long, CoroutineLock>(this.Domain, instanceId, coroutineLock);
-			lockInfo.Parent = this;
-			this.lockInfos.Add(key, lockInfo);
-			
-			Log.Info($"location lock key: {key} instanceId: {instanceId}");
-
-			if (time > 0)
-			{
-				long lockInfoInstanceId = lockInfo.InstanceId;
-				await TimerComponent.Instance.WaitAsync(time);
-				if (lockInfo.InstanceId != lockInfoInstanceId)
-				{
-					return;
-				}
-				UnLock(key, instanceId, instanceId);
-			}
-		}
-
-		public void UnLock(long key, long oldInstanceId, long newInstanceId)
-		{
-			if (!this.lockInfos.TryGetValue(key, out LockInfo lockInfo))
-			{
-				Log.Error($"location unlock not found key: {key} {oldInstanceId}");
-				return;
-			}
-			
-			if (oldInstanceId != lockInfo.LockInstanceId)
-			{
-				Log.Error($"location unlock oldInstanceId is different: {key} {oldInstanceId}");
-				return;
-			}
-			
-			Log.Info($"location unlock key: {key} instanceId: {oldInstanceId} newInstanceId: {newInstanceId}");
-
-			this.locations[key] = newInstanceId;
-			
-			this.lockInfos.Remove(key);
-			
-			// 解锁
-			lockInfo.Dispose();
-		}
-
-		public async ETTask<long> Get(long key)
-		{
-			using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
-			{
-				this.locations.TryGetValue(key, out long instanceId);
-				Log.Info($"location get key: {key} instanceId: {instanceId}");
-				return instanceId;
-			}
-		}
-
-		public override void Dispose()
-		{
-			if (this.IsDisposed)
-			{
-				return;
-			}
-			base.Dispose();
-			
-			this.locations.Clear();
-			this.lockInfos.Clear();
-		}
-	}
+    [ObjectSystem]
+    public class LockInfoAwakeSystem: AwakeSystem<LockInfo, long, CoroutineLock>
+    {
+        public override void Awake(LockInfo self, long lockInstanceId, CoroutineLock coroutineLock)
+        {
+            self.CoroutineLock = coroutineLock;
+            self.LockInstanceId = lockInstanceId;
+        }
+    }
+
+    public class LockInfo: Entity
+    {
+        public long LockInstanceId;
+
+        public CoroutineLock CoroutineLock;
+
+        public override void Dispose()
+        {
+            if (this.IsDisposed)
+            {
+                return;
+            }
+
+            base.Dispose();
+
+            this.CoroutineLock.Dispose();
+            LockInstanceId = 0;
+        }
+    }
+
+    public class LocationComponent: Entity
+    {
+        public readonly Dictionary<long, long> locations = new Dictionary<long, long>();
+
+        private readonly Dictionary<long, LockInfo> lockInfos = new Dictionary<long, LockInfo>();
+
+        public async ETTask Add(long key, long instanceId)
+        {
+            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
+            {
+                this.locations[key] = instanceId;
+                Log.Debug($"location add key: {key} instanceId: {instanceId}");
+            }
+        }
+
+        public async ETTask Remove(long key)
+        {
+            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
+            {
+                this.locations.Remove(key);
+                Log.Debug($"location remove key: {key}");
+            }
+        }
+
+        public async ETVoid Lock(long key, long instanceId, int time = 0)
+        {
+            CoroutineLock coroutineLock = await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key);
+
+            LockInfo lockInfo = EntityFactory.Create<LockInfo, long, CoroutineLock>(this.Domain, instanceId, coroutineLock);
+            lockInfo.Parent = this;
+            this.lockInfos.Add(key, lockInfo);
+
+            Log.Debug($"location lock key: {key} instanceId: {instanceId}");
+
+            if (time > 0)
+            {
+                long lockInfoInstanceId = lockInfo.InstanceId;
+                await TimerComponent.Instance.WaitAsync(time);
+                if (lockInfo.InstanceId != lockInfoInstanceId)
+                {
+                    return;
+                }
+
+                UnLock(key, instanceId, instanceId);
+            }
+        }
+
+        public void UnLock(long key, long oldInstanceId, long newInstanceId)
+        {
+            if (!this.lockInfos.TryGetValue(key, out LockInfo lockInfo))
+            {
+                Log.Error($"location unlock not found key: {key} {oldInstanceId}");
+                return;
+            }
+
+            if (oldInstanceId != lockInfo.LockInstanceId)
+            {
+                Log.Error($"location unlock oldInstanceId is different: {key} {oldInstanceId}");
+                return;
+            }
+
+            Log.Debug($"location unlock key: {key} instanceId: {oldInstanceId} newInstanceId: {newInstanceId}");
+
+            this.locations[key] = newInstanceId;
+
+            this.lockInfos.Remove(key);
+
+            // 解锁
+            lockInfo.Dispose();
+        }
+
+        public async ETTask<long> Get(long key)
+        {
+            using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key))
+            {
+                this.locations.TryGetValue(key, out long instanceId);
+                Log.Debug($"location get key: {key} instanceId: {instanceId}");
+                return instanceId;
+            }
+        }
+
+        public override void Dispose()
+        {
+            if (this.IsDisposed)
+            {
+                return;
+            }
+
+            base.Dispose();
+
+            this.locations.Clear();
+            this.lockInfos.Clear();
+        }
+    }
 }

Server/Model/Module/ActorLocation/LocationProxyComponent.cs

@@ -1,21 +1,19 @@
-using System.Net;
-
-namespace ET
+namespace ET
 {
-	public class LocationProxyComponent : Entity
-	{
-		public static LocationProxyComponent Instance;
+    public class LocationProxyComponent: Entity
+    {
+        public static LocationProxyComponent Instance;
+
+        public override void Dispose()
+        {
+            if (this.IsDisposed)
+            {
+                return;
+            }
 
-		public override void Dispose()
-		{
-			if (this.IsDisposed)
-			{
-				return;
-			}
-			
-			base.Dispose();
+            base.Dispose();
 
-			Instance = null;
-		}
-	}
+            Instance = null;
+        }
+    }
 }

Server/Model/Module/Benchmark/BenchmarkComponent.cs

@@ -1,9 +0,0 @@
-namespace ET
-{
-	public class BenchmarkComponent: Entity
-	{
-		public int k;
-
-		public long time1 = TimeHelper.ClientNow();
-	}
-}

Server/Model/Module/Benchmark/WebSocketBenchmarkComponent.cs

@@ -1,9 +0,0 @@
-namespace ET
-{
-	public class WebSocketBenchmarkComponent: Entity
-	{
-		public int k;
-
-		public long time1 = TimeHelper.ClientNow();
-	}
-}

Server/Model/Module/Console/ConsoleComponent.cs

@@ -1,112 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace ET
-{
-    public class ConsoleComponentAwakeSystem : StartSystem<ConsoleComponent>
-    {
-        public override void Start(ConsoleComponent self)
-        {
-            self.Start().Coroutine();
-        }
-    }
-
-    public static class ConsoleMode
-    {
-        public const string None = "";
-        public const string Repl = "repl";
-    }
-    
-    public class ConsoleComponent: Entity
-    {
-        public CancellationTokenSource CancellationTokenSource;
-        public string Mode = "";
-
-        public async ETVoid Start()
-        {
-            this.CancellationTokenSource = new CancellationTokenSource();
-            
-            while (true)
-            {
-                try
-                {
-                    string line = await Task.Factory.StartNew(() =>
-                    {
-                        Console.Write($"{this.Mode}> ");
-                        return Console.In.ReadLine();
-                    }, this.CancellationTokenSource.Token);
-                    
-                    line = line.Trim();
-
-                    if (this.Mode != "")
-                    {
-                        bool isExited = true;
-                        switch (this.Mode)
-                        {
-                            case ConsoleMode.Repl:
-                            {
-                                ReplComponent replComponent = this.GetComponent<ReplComponent>();
-                                if (replComponent == null)
-                                {
-                                    Console.WriteLine($"no command: {line}!");
-                                    break;
-                                }
-                            
-                                try
-                                {
-                                    isExited = await replComponent.Run(line, this.CancellationTokenSource.Token);
-                                }
-                                catch (Exception e)
-                                {
-                                    Console.WriteLine(e);
-                                }
-
-                                break;
-                            }
-                        }
-
-                        if (isExited)
-                        {
-                            this.Mode = "";
-                        }
-
-                        continue;
-                    }
-
-                    switch (line)
-                    {
-                        case "reload": 
-                            try
-                            {
-                                Game.EventSystem.Add(DllHelper.GetHotfixAssembly());
-                            }
-                            catch (Exception e)
-                            {
-                                Console.WriteLine(e);
-                            }
-                            break;
-                        case "repl":
-                            try
-                            {
-                                this.Mode = ConsoleMode.Repl;
-                                this.AddComponent<ReplComponent>();
-                            }
-                            catch (Exception e)
-                            {
-                                Console.WriteLine(e);
-                            }
-                            break;
-                        default:
-                            Console.WriteLine($"no such command: {line}");
-                            break;
-                    }
-                }
-                catch (Exception e)
-                {
-                    Console.WriteLine(e);
-                }
-            }
-        }
-    }
-}

Server/Model/Module/Console/ReplComponent.cs

@@ -1,72 +0,0 @@
-using System;
-using System.Threading;
-using Microsoft.CodeAnalysis.CSharp.Scripting;
-using Microsoft.CodeAnalysis.Scripting;
-
-namespace ET
-{
-    public class ReplComponentAwakeSystem : AwakeSystem<ReplComponent>
-    {
-        public override void Awake(ReplComponent self)
-        {
-            self.ScriptOptions = ScriptOptions.Default
-                    .WithMetadataResolver(ScriptMetadataResolver.Default.WithBaseDirectory(Environment.CurrentDirectory))
-                    .AddReferences(typeof (ReplComponent).Assembly)
-                    .AddImports("System");
-        }
-    }
-    
-    public class ReplComponent: Entity
-    {
-        public ScriptOptions ScriptOptions;
-        public ScriptState ScriptState;
-
-        public async ETTask<bool> Run(string line, CancellationToken cancellationToken)
-        {
-            switch (line)
-            {
-                case "exit":
-                {
-                    this.Parent.RemoveComponent<ReplComponent>();
-                    return true;
-                }
-                case "reset":
-                {
-                    this.ScriptState = null;
-                    return false;
-                }
-                default:
-                {
-                    try
-                    {
-                        if (this.ScriptState == null)
-                        {
-                            this.ScriptState = await CSharpScript.RunAsync(line, this.ScriptOptions, cancellationToken: cancellationToken);
-                        }
-                        else
-                        {
-                            this.ScriptState = await this.ScriptState.ContinueWithAsync(line, cancellationToken: cancellationToken);
-                        }
-                    }
-                    catch (Exception e)
-                    {
-                        Console.WriteLine(e);
-                    }
-
-                    return false;
-                }
-            }
-        }
-
-        public override void Dispose()
-        {
-            if (this.IsDisposed)
-            {
-                return;
-            }
-            base.Dispose();
-            this.ScriptOptions = null;
-            this.ScriptState = null;
-        }
-    }
-}

Server/Model/Base/Object/IDBCollection.cs → Server/Model/Module/DB/IDBCollection.cs

@@ -1,4 +1,4 @@
-namespace ET
+namespace ET
 {
     public interface IDBCollection
     {

Server/Model/Module/Message/AMRpcHandler.cs

@@ -1,59 +0,0 @@
-using System;
-
-namespace ET
-{
-	public abstract class AMRpcHandler<Request, Response>: IMHandler where Request : class, IRequest where Response : class, IResponse 
-	{
-		protected abstract ETTask Run(Session session, Request request, Response response, Action reply);
-
-		public async ETVoid Handle(Session session, object message)
-		{
-			try
-			{
-				Request request = message as Request;
-				if (request == null)
-				{
-					Log.Error($"消息类型转换错误: {message.GetType().Name} to {typeof (Request).Name}");
-				}
-
-				int rpcId = request.RpcId;
-				long instanceId = session.InstanceId;
-				Response response = Activator.CreateInstance<Response>();
-
-				void Reply()
-				{
-					// 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
-					if (session.InstanceId != instanceId)
-					{
-						return;
-					}
-
-					response.RpcId = rpcId;
-					session.Reply(response);
-				}
-
-				try
-				{
-					await this.Run(session, request, response, Reply);
-				}
-				catch (Exception e)
-				{
-					Log.Error(e);
-					response.Error = ErrorCode.ERR_RpcFail;
-					response.Message = e.ToString();
-					Reply();
-				}
-				
-			}
-			catch (Exception e)
-			{
-				Log.Error($"解释消息失败: {message.GetType().FullName}\n{e}");
-			}
-		}
-
-		public Type GetMessageType()
-		{
-			return typeof (Request);
-		}
-	}
-}

Server/Model/Module/Message/InnerOpcode.cs

@@ -1,29 +0,0 @@
-namespace ET
-{
-	public static partial class InnerOpcode
-	{
-		 public const ushort M2M_TrasferUnitRequest = 10001;
-		 public const ushort M2M_TrasferUnitResponse = 10002;
-		 public const ushort M2A_Reload = 10003;
-		 public const ushort A2M_Reload = 10004;
-		 public const ushort G2G_LockRequest = 10005;
-		 public const ushort G2G_LockResponse = 10006;
-		 public const ushort G2G_LockReleaseRequest = 10007;
-		 public const ushort G2G_LockReleaseResponse = 10008;
-		 public const ushort ObjectAddRequest = 10009;
-		 public const ushort ObjectAddResponse = 10010;
-		 public const ushort ObjectLockRequest = 10011;
-		 public const ushort ObjectLockResponse = 10012;
-		 public const ushort ObjectUnLockRequest = 10013;
-		 public const ushort ObjectUnLockResponse = 10014;
-		 public const ushort ObjectRemoveRequest = 10015;
-		 public const ushort ObjectRemoveResponse = 10016;
-		 public const ushort ObjectGetRequest = 10017;
-		 public const ushort ObjectGetResponse = 10018;
-		 public const ushort R2G_GetLoginKey = 10019;
-		 public const ushort G2R_GetLoginKey = 10020;
-		 public const ushort G2M_CreateUnit = 10021;
-		 public const ushort M2G_CreateUnit = 10022;
-		 public const ushort G2M_SessionDisconnect = 10023;
-	}
-}

Server/Model/Module/Message/MessageDispatcherComponent.cs

@@ -1,13 +0,0 @@
-using System.Collections.Generic;
-
-namespace ET
-{
-	/// <summary>
-	/// 消息分发组件
-	/// </summary>
-	public class MessageDispatcherComponent : Entity
-	{
-		public static MessageDispatcherComponent Instace { get; set; }
-		public readonly Dictionary<ushort, List<IMHandler>> Handlers = new Dictionary<ushort, List<IMHandler>>();
-	}
-}

Server/Model/Module/Message/NetInnerComponent.cs

@@ -1,51 +0,0 @@
-using System.Collections.Generic;
-
-namespace ET
-{
-    public class NetInnerComponent: NetworkComponent
-    {
-        public static NetInnerComponent Instance;
-		
-        public readonly Dictionary<string, Session> adressSessions = new Dictionary<string, Session>();
-		
-        public override Session OnAccept(AChannel channel)
-        {
-            Session session = base.OnAccept(channel);
-            // 内网accept连接，一分钟检查一次，20分钟没有收到消息则断开, 主要是防止连接过来的机器宕机，导致无法超时主动断开，这里检测时间是连接方的两倍
-            session.AddComponent<SessionIdleCheckerComponent, int, int, int>(60 * 1000, 1000 * 60 * 20, int.MaxValue);
-            return session;
-        }
-
-        public override void Remove(long id)
-        {
-            Session session = this.Get(id);
-            if (session == null)
-            {
-                return;
-            }
-            this.adressSessions.Remove(session.RemoteAddress);
-
-            base.Remove(id);
-        }
-
-        /// <summary>
-        /// 从地址缓存中取Session,如果没有则创建一个新的Session,并且保存到地址缓存中
-        /// </summary>
-        public Session Get(string addr)
-        {
-            if (this.adressSessions.TryGetValue(addr, out Session session))
-            {
-                return session;
-            }
-			
-            session = this.Create(addr);
-
-            this.adressSessions.Add(addr, session);
-			
-            // 内网connect连接，一分钟检查一次，10分钟没有收到发送消息则断开
-            session.AddComponent<SessionIdleCheckerComponent, int, int, int>(60 * 1000, int.MaxValue, 60 * 1000);
-			
-            return session;
-        }
-    }
-}

Server/Model/Module/Message/OuterMessageStatisticComponent.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace ET
+{
+    public class OuterMessageStatisticComponent: Entity
+    {
+        public long LastCheckTime;
+        public int MessageCountPerSec;
+        public Dictionary<Type, int> MessageTypeCount = new Dictionary<Type, int>();
+    }
+}

Server/Model/Module/NetworkTCP/AMRpcHandler.cs

@@ -0,0 +1,71 @@
+using System;
+
+namespace ET
+{
+    [MessageHandler]
+    public abstract class AMRpcHandler<Request, Response>: IMHandler where Request : class, IRequest where Response : class, IResponse
+    {
+        protected abstract ETTask Run(Session session, Request request, Response response, Action reply);
+
+        public void Handle(Session session, object message)
+        {
+            HandleAsync(session, message).Coroutine();
+        }
+
+        private async ETVoid HandleAsync(Session session, object message)
+        {
+            try
+            {
+                Request request = message as Request;
+                if (request == null)
+                {
+                    Log.Error($"消息类型转换错误: {message.GetType().Name} to {typeof (Request).Name}");
+                }
+
+                int rpcId = request.RpcId;
+
+                long instanceId = session.InstanceId;
+
+                Response response = Activator.CreateInstance<Response>();
+
+                void Reply()
+                {
+                    // 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
+                    if (session.InstanceId != instanceId)
+                    {
+                        return;
+                    }
+
+                    response.RpcId = rpcId;
+                    session.Reply(response);
+                }
+
+                try
+                {
+                    await this.Run(session, request, response, Reply);
+                }
+                catch (Exception exception)
+                {
+                    Log.Error(exception);
+                    response.Error = ErrorCode.ERR_RpcFail;
+                    response.Message = exception.ToString();
+                    Reply();
+                }
+            }
+            catch (Exception e)
+            {
+                throw new Exception($"解释消息失败: {message.GetType().FullName}", e);
+            }
+        }
+
+        public Type GetMessageType()
+        {
+            return typeof (Request);
+        }
+
+        public Type GetResponseType()
+        {
+            return typeof (Response);
+        }
+    }
+}

Server/Model/Module/NetworkTCP/NetInnerComponent.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace ET
+{
+    public struct ProcessActorId
+    {
+        public int Process;
+        public long ActorId;
+
+        public ProcessActorId(long actorId)
+        {
+            InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
+            this.Process = instanceIdStruct.Process;
+            instanceIdStruct.Process = Game.Options.Process;
+            this.ActorId = instanceIdStruct.ToLong();
+        }
+    }
+
+    public class NetInnerComponent: Entity
+    {
+        public AService Service;
+
+        public static NetInnerComponent Instance;
+
+        public IMessageDispatcher MessageDispatcher { get; set; }
+        
+        public Random Random = new Random(Guid.NewGuid().GetHashCode());
+    }
+}

Server/Model/Other/Options.cs

@@ -2,9 +2,33 @@
 
 namespace ET
 {
-	public class Options: Entity
-	{
-		[Option("Process", Required = false, Default = 1)]
-		public int Process { get; set; }
-	}
+    public enum ServerType
+    {
+        Game,
+        Watcher,
+    }
+    
+    public class Options
+    {
+        [Option("StartConfig", Required = true)]
+        public string StartConfig { get; set; }
+
+        [Option("ServerType", Required = false, Default = ServerType.Game, HelpText = "serverType enum")]
+        public ServerType ServerType { get; set; }
+
+        [Option("Develop", Required = false, Default = 0, HelpText = "develop mode")]
+        public int Develop { get; set; }
+
+        [Option("Process", Required = false, Default = 1)]
+        public int Process { get; set; }
+
+        [Option("CreateScenes", Required = false, Default = 1)]
+        public int CreateScenes { get; set; }
+
+        [Option("Console", Required = false, Default = 0)]
+        public int Console { get; set; }
+
+        [Option("LogLevel", Required = false, Default = 0)]
+        public int LogLevel { get; set; }
+    }
 }

Server/Model/Server.Model.csproj

@@ -21,135 +21,15 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Remove="Libs\**" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\AsyncETTaskCompletedMethodBuilder.cs">
-      <Link>Base\Async\AsyncETTaskCompletedMethodBuilder.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\AsyncETTaskMethodBuilder.cs">
-      <Link>Base\Async\AsyncETTaskMethodBuilder.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\AsyncETVoidMethodBuilder.cs">
-      <Link>Base\Async\AsyncETVoidMethodBuilder.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\AsyncMethodBuilderAttribute.cs">
-      <Link>Base\Async\AsyncMethodBuilderAttribute.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETCancellationToken.cs">
-      <Link>Base\Async\ETCancellationToken.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETTask.cs">
-      <Link>Base\Async\ETTask.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETTaskCompleted.cs">
-      <Link>Base\Async\ETTaskCompleted.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETTaskCompletionSource.cs">
-      <Link>Base\Async\ETTaskCompletionSource.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETTaskHelper.cs">
-      <Link>Base\Async\ETTaskHelper.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\ETVoid.cs">
-      <Link>Base\Async\ETVoid.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Async\IAwaiter.cs">
-      <Link>Base\Async\IAwaiter.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Entity\EntitySceneFactory.cs">
-      <Link>Base\Entity\EntitySceneFactory.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Entity\Game.cs">
-      <Link>Base\Entity\Game.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Entity\Scene.cs">
-      <Link>Base\Entity\Scene.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Entity\SceneType.cs">
-      <Link>Base\Entity\SceneType.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Entity\TimerComponent.cs">
-      <Link>Base\Entity\TimerComponent.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\MongoHelper.cs">
-      <Link>Base\Helper\MongoHelper.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\ListComponent.cs">
-      <Link>Base\ListComponent.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\MultiMapSet.cs">
-      <Link>Base\MultiMapSet.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\BaseAttribute.cs">
-      <Link>Base\Object\BaseAttribute.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\Entity.cs">
-      <Link>Base\Object\Entity.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\EntityCreateComponet.cs">
-      <Link>Base\Object\EntityCreateComponet.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\EntityEventAttribute.cs">
-      <Link>Base\Object\EntityEventAttribute.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\EntityFactory.cs">
-      <Link>Base\Object\EntityFactory.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\EventSystem.cs">
-      <Link>Base\Object\EventSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IAwakeSystem.cs">
-      <Link>Base\Object\IAwakeSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IChangeSystem.cs">
-      <Link>Base\Object\IChangeSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IDeserializeSystem.cs">
-      <Link>Base\Object\IDeserializeSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IDestroySystem.cs">
-      <Link>Base\Object\IDestroySystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\ILateUpdateSystem.cs">
-      <Link>Base\Object\ILateUpdateSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\ILoadSystem.cs">
-      <Link>Base\Object\ILoadSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\ISerializeToEntity.cs">
-      <Link>Base\Object\ISerializeToEntity.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IStartSystem.cs">
-      <Link>Base\Object\IStartSystem.cs</Link>
+
+    <Compile Include="..\..\Unity\Assets\Model\Core\**\*.cs"> 
+      <Link>Core\%(RecursiveDir)%(FileName)%(Extension)</Link>
     </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\IUpdateSystem.cs">
-      <Link>Base\Object\IUpdateSystem.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\NoMemoryCheck.cs">
-      <Link>Base\Object\NoMemoryCheck.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\NoObjectPool.cs">
-      <Link>Base\Object\NoObjectPool.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\Object.cs">
-      <Link>Base\Object\Object.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\ObjectPool.cs">
-      <Link>Base\Object\ObjectPool.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Object\ObjectSystemAttribute.cs">
-      <Link>Base\Object\ObjectSystemAttribute.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\Pool.cs">
-      <Link>Base\Pool.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\ProcessHelper.cs">
-      <Link>Base/ProcessHelper.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\StructBsonSerialize.cs">
-      <Link>Base\StructBsonSerialize.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Base\UnOrderMultiMapSet.cs">
-      <Link>Base\UnOrderMultiMapSet.cs</Link>
+    
+    <Compile Remove="Libs\**" />
+    
+    <Compile Include="..\..\Unity\Assets\Model\Module\ActorLocation\ActorResponse.cs">
+      <Link>Module\ActorLocation\ActorResponse.cs</Link>
     </Compile>
     <Compile Include="..\..\Unity\Assets\Model\Module\ActorLocation\IActorLocationMessage.cs">
       <Link>Module\ActorLocation\IActorLocationMessage.cs</Link>
@@ -175,20 +55,8 @@
     <Compile Include="..\..\Unity\Assets\Model\Module\CoroutineLock\CoroutineLockType.cs">
       <Link>Module\CoroutineLock\CoroutineLockType.cs</Link>
     </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessagePackHelper.cs">
-      <Link>Module\Message\MessagePackHelper.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\NetOuterComponent.cs">
-      <Link>Module\Message\NetOuterComponent.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\KCP\Kcp.cs">
-      <Link>Module\Message\Network\KCP\Kcp.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\WebSocket\WChannel.cs">
-      <Link>Module\Message\Network\WebSocket\WChannel.cs</Link>
-    </Compile>
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\WebSocket\WService.cs">
-      <Link>Module\Message\Network\WebSocket\WService.cs</Link>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessageDispatcherComponent.cs">
+      <Link>Module\Message\MessageDispatcherComponent.cs</Link>
     </Compile>
     <EmbeddedResource Remove="Libs\**" />
     <None Remove="Libs\**" />
@@ -196,30 +64,32 @@
     <Compile Remove="Module\Scene\**" />
     <EmbeddedResource Remove="Module\Scene\**" />
     <None Remove="Module\Scene\**" />
+    <Compile Remove="Base\Async\**" />
+    <EmbeddedResource Remove="Base\Async\**" />
+    <None Remove="Base\Async\**" />
+    <Compile Remove="Base\Entity\**" />
+    <EmbeddedResource Remove="Base\Entity\**" />
+    <None Remove="Base\Entity\**" />
+    <Compile Remove="Base\Event\**" />
+    <EmbeddedResource Remove="Base\Event\**" />
+    <None Remove="Base\Event\**" />
+    <Compile Remove="Module\Message\Network\KCP\**" />
+    <EmbeddedResource Remove="Module\Message\Network\KCP\**" />
+    <None Remove="Module\Message\Network\KCP\**" />
+    <Compile Remove="Module\Message\Network\TCP\**" />
+    <EmbeddedResource Remove="Module\Message\Network\TCP\**" />
+    <None Remove="Module\Message\Network\TCP\**" />
+    <Compile Remove="Module\Message\Network\WebSocket\**" />
+    <EmbeddedResource Remove="Module\Message\Network\WebSocket\**" />
+    <None Remove="Module\Message\Network\WebSocket\**" />
+    <Compile Remove="Module\Message\Network\**" />
+    <EmbeddedResource Remove="Module\Message\Network\**" />
+    <None Remove="Module\Message\Network\**" />
+    <Compile Remove="Base\RecyclableMemoryStream\**" />
+    <EmbeddedResource Remove="Base\RecyclableMemoryStream\**" />
+    <None Remove="Base\RecyclableMemoryStream\**" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="..\..\Unity\Assets\Model\Base\DoubleMap.cs" Link="Base\DoubleMap.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Event\EventAttribute.cs" Link="Base\Event\EventAttribute.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Event\IEvent.cs" Link="Base\Event\IEvent.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\ByteHelper.cs" Link="Base\Helper\ByteHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\EnumHelper.cs" Link="Base\Helper\EnumHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\FileHelper.cs" Link="Base\Helper\FileHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\IdGenerater.cs" Link="Base\Helper\IdGenerater.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\MD5Helper.cs" Link="Base\Helper\MD5Helper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\MethodInfoHelper.cs" Link="Base\Helper\MethodInfoHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\NetHelper.cs" Link="Base\Helper\NetHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\ObjectHelper.cs" Link="Base\Helper\ObjectHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\RandomHelper.cs" Link="Base\Helper\RandomHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\StringHelper.cs" Link="Base\Helper\StringHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\TimeHelper.cs" Link="Base\Helper\TimeHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\Helper\ZipHelper.cs" Link="Base\Helper\ZipHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\MultiMap.cs" Link="Base\MultiMap.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\OneThreadSynchronizationContext.cs" Link="Base\OneThreadSynchronizationContext.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\QueueDictionary.cs" Link="Base\QueueDictionary.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\RecyclableMemoryStream\Events.cs" Link="Base\RecyclableMemoryStream\Events.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\RecyclableMemoryStream\RecyclableMemoryStream.cs" Link="Base\RecyclableMemoryStream\RecyclableMemoryStream.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\RecyclableMemoryStream\RecyclableMemoryStreamManager.cs" Link="Base\RecyclableMemoryStream\RecyclableMemoryStreamManager.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Base\UnOrderMultiMap.cs" Link="Base\UnOrderMultiMap.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Config\ACategory.cs" Link="Module\Config\ACategory.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Config\ConfigAttribute.cs" Link="Module\Config\ConfigAttribute.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Config\IConfig.cs" Link="Module\Config\IConfig.cs" />
@@ -230,27 +100,19 @@
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\IMHandler.cs" Link="Module\Message\IMHandler.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessageAttribute.cs" Link="Module\Message\MessageAttribute.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessageHandlerAttribute.cs" Link="Module\Message\MessageHandlerAttribute.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessageInfo.cs" Link="Module\Message\MessageInfo.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\NetworkComponent.cs" Link="Module\Message\NetworkComponent.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\AChannel.cs" Link="Module\Message\Network\AChannel.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\AService.cs" Link="Module\Message\Network\AService.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\Circularbuffer.cs" Link="Module\Message\Network\Circularbuffer.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\KCP\KChannel.cs" Link="Module\Message\Network\KCP\KChannel.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\KCP\KService.cs" Link="Module\Message\Network\KCP\KService.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\NetworkHelper.cs" Link="Module\Message\Network\NetworkHelper.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\TCP\PacketParser.cs" Link="Module\Message\Network\TCP\PacketParser.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\TCP\TChannel.cs" Link="Module\Message\Network\TCP\TChannel.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Network\TCP\TService.cs" Link="Module\Message\Network\TCP\TService.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\Opcode.cs" Link="Module\Message\Opcode.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\OpcodeHelper.cs" Link="Module\Message\OpcodeHelper.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\OpcodeTypeComponent.cs" Link="Module\Message\OpcodeTypeComponent.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\OuterMessage.cs" Link="Module\Message\OuterMessage.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\OuterOpcode.cs" Link="Module\Message\OuterOpcode.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\ProtobufHelper.cs" Link="Module\Message\ProtobufHelper.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\RpcException.cs" Link="Module\Message\RpcException.cs" />
     <Compile Include="..\..\Unity\Assets\Model\Module\Message\Session.cs" Link="Module\Message\Session.cs" />
-    <Compile Include="..\..\Unity\Assets\Model\Module\Message\SessionIdleCheckComponent.cs">
-      <Link>Module\Message\SessionIdleCheckComponent.cs</Link>
+    <Compile Include="..\..\Unity\Assets\Model\Module\NetworkTCP\PacketParser.cs">
+      <Link>Module\NetworkTCP\PacketParser.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\NetworkTCP\TChannel.cs">
+      <Link>Module\NetworkTCP\TChannel.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\NetworkTCP\TService.cs">
+      <Link>Module\NetworkTCP\TService.cs</Link>
     </Compile>
     <Compile Include="..\..\Unity\Assets\Model\Module\Numeric\INumericWatcher.cs">
       <Link>Module\Numeric\INumericWatcher.cs</Link>
@@ -268,6 +130,38 @@
       <Link>Module\Numeric\NumericWatcherComponent.cs</Link>
     </Compile>
   </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessageSerializeHelper.cs"> 
+      <Link>Module\Message\MessageSerializeHelper.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessagePool.cs">
+      <Link>Module\Message\MessagePool.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\MessagePackHelper.cs">
+      <Link>Module\Message\MessagePackHelper.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\NetKcpComponent.cs">
+      <Link>Module\Message\NetKcpComponent.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\NetThreadComponent.cs">
+      <Link>Module\Message\NetThreadComponent.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\ResponseTypeAttribute.cs">
+      <Link>Module\Message\ResponseTypeAttribute.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\SessionAcceptTimeoutComponent.cs">
+      <Link>Module\Message\SessionAcceptTimeoutComponent.cs</Link>
+    </Compile>
+    <Compile Include="..\..\Unity\Assets\Model\Module\Message\SessionIdleCheckerComponent.cs">
+      <Link>Module\Message\SessionIdleCheckerComponent.cs</Link>
+    </Compile>
+
+    <Compile Include="..\..\Unity\Assets\Model\Module\Network\**\*.cs">
+      <Link>Module\Network\%(RecursiveDir)%(FileName)%(Extension)</Link>
+    </Compile>
+  </ItemGroup>
+  
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.2.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.Scripting" Version="2.9.0" />
@@ -277,9 +171,4 @@
   <ItemGroup>
     <ProjectReference Include="..\ThirdParty\Server.ThirdParty.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Base\RecyclableMemoryStream\" />
-    <Folder Include="Module\Message\Network\KCP\" />
-    <Folder Include="Module\Message\Network\TCP\" />
-  </ItemGroup>
 </Project>

Tools/Proto2CS/Proto2CS.csproj

@@ -19,7 +19,7 @@
 
     <ItemGroup>
       <Compile Remove=".vs\**" />
-      <Compile Include="..\..\Unity\Assets\Model\Base\ProcessHelper.cs">
+      <Compile Include="..\..\Unity\Assets\Model\Core\ProcessHelper.cs">
         <Link>ProcessHelper.cs</Link>
       </Compile>
     </ItemGroup>

Unity/Assets/Editor/BuildEditor/BuildHelper.cs

@@ -54,7 +54,6 @@ namespace ET
             Log.Info("开始资源打包");
             BuildPipeline.BuildAssetBundles(fold, buildAssetBundleOptions, buildTarget);
 
-            GenerateVersionInfo(fold);
             Log.Info("完成资源打包");
 
             if (isContainAB)
@@ -74,42 +73,5 @@ namespace ET
                 Log.Info("完成exe打包");
             }
         }
-
-        private static void GenerateVersionInfo(string dir)
-        {
-            VersionConfig versionProto = new VersionConfig();
-            GenerateVersionProto(dir, versionProto, "");
-
-            using (FileStream fileStream = new FileStream($"{dir}/Version.txt", FileMode.Create))
-            {
-                byte[] bytes = JsonHelper.ToJson(versionProto).ToByteArray();
-                fileStream.Write(bytes, 0, bytes.Length);
-            }
-        }
-
-        private static void GenerateVersionProto(string dir, VersionConfig versionProto, string relativePath)
-        {
-            foreach (string file in Directory.GetFiles(dir))
-            {
-                string md5 = MD5Helper.FileMD5(file);
-                FileInfo fi = new FileInfo(file);
-                long size = fi.Length;
-                string filePath = relativePath == "" ? fi.Name : $"{relativePath}/{fi.Name}";
-
-                versionProto.FileInfoDict.Add(filePath, new FileVersionInfo
-                {
-                    File = filePath,
-                    MD5 = md5,
-                    Size = size,
-                });
-            }
-
-            foreach (string directory in Directory.GetDirectories(dir))
-            {
-                DirectoryInfo dinfo = new DirectoryInfo(directory);
-                string rel = relativePath == "" ? dinfo.Name : $"{relativePath}/{dinfo.Name}";
-                GenerateVersionProto($"{dir}/{dinfo.Name}", versionProto, rel);
-            }
-        }
     }
 }

Unity/Assets/Editor/ServerManagerEditor/ServerManagerEditor.cs

@@ -1,68 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-
-using MongoDB.Bson;
-using UnityEditor;
-using UnityEngine;
-
-namespace ET
-{
-	public class ServerManagerEditor: EditorWindow
-	{
-		private string managerAddress;
-		private string account;
-		private string password;
-
-		[MenuItem("Tools/服务器管理工具")]
-		private static void ShowWindow()
-		{
-			GetWindow(typeof (ServerManagerEditor));
-		}
-
-		private void OnGUI()
-		{
-			GUILayout.BeginHorizontal();
-			
-			GUILayout.Label("Manager外网地址:");
-			managerAddress = EditorGUILayout.TextField(this.managerAddress);
-			
-			GUILayout.Label("帐号:");
-			this.account = GUILayout.TextField(this.account);
-			
-			GUILayout.Label("密码:");
-			this.password = GUILayout.TextField(this.password);
-			
-			if (GUILayout.Button("Reload"))
-			{
-				if (!Application.isPlaying)
-				{
-					Log.Error($"Reload必须先启动客户端!");
-					return;
-				}
-
-				ReloadAsync(this.managerAddress, this.account, this.password).Coroutine();
-			}
-			
-			GUILayout.EndHorizontal();
-		}
-		
-		private static async ETVoid ReloadAsync(string address, string account, string password)
-		{
-			using (Session session = Game.Scene.GetComponent<NetOuterComponent>().Create(address))
-			{
-				try
-				{
-					await session.Call(new C2M_Reload() {Account = account, Password = password});	
-					Log.Info($"Reload服务端成功!");
-				}
-				catch (Exception e)
-				{
-					Log.Error(e);
-				}
-			}
-		}
-	}
-}

Unity/Assets/Hotfix/Module/Message/MessageDispatcherComponentSystem.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [ObjectSystem]
+    public class MessageDispatcherComponentAwakeSystem: AwakeSystem<MessageDispatcherComponent>
+    {
+        public override void Awake(MessageDispatcherComponent self)
+        {
+            MessageDispatcherComponent.Instance = self;
+            self.Load();
+        }
+    }
+
+    [ObjectSystem]
+    public class MessageDispatcherComponentLoadSystem: LoadSystem<MessageDispatcherComponent>
+    {
+        public override void Load(MessageDispatcherComponent self)
+        {
+            self.Load();
+        }
+    }
+
+    [ObjectSystem]
+    public class MessageDispatcherComponentDestroySystem: DestroySystem<MessageDispatcherComponent>
+    {
+        public override void Destroy(MessageDispatcherComponent self)
+        {
+            MessageDispatcherComponent.Instance = null;
+            self.Handlers.Clear();
+        }
+    }
+
+    /// <summary>
+    /// 消息分发组件
+    /// </summary>
+    public static class MessageDispatcherComponentHelper
+    {
+        public static void Load(this MessageDispatcherComponent self)
+        {
+            self.Handlers.Clear();
+
+            HashSet<Type> types = Game.EventSystem.GetTypes(typeof (MessageHandlerAttribute));
+
+            foreach (Type type in types)
+            {
+                IMHandler iMHandler = Activator.CreateInstance(type) as IMHandler;
+                if (iMHandler == null)
+                {
+                    Log.Error($"message handle {type.Name} 需要继承 IMHandler");
+                    continue;
+                }
+
+                Type messageType = iMHandler.GetMessageType();
+                ushort opcode = OpcodeTypeComponent.Instance.GetOpcode(messageType);
+                if (opcode == 0)
+                {
+                    Log.Error($"消息opcode为0: {messageType.Name}");
+                    continue;
+                }
+
+                self.RegisterHandler(opcode, iMHandler);
+            }
+        }
+
+        public static void RegisterHandler(this MessageDispatcherComponent self, ushort opcode, IMHandler handler)
+        {
+            if (!self.Handlers.ContainsKey(opcode))
+            {
+                self.Handlers.Add(opcode, new List<IMHandler>());
+            }
+
+            self.Handlers[opcode].Add(handler);
+        }
+
+        public static void Handle(this MessageDispatcherComponent self, Session session, ushort opcode, object message)
+        {
+            List<IMHandler> actions;
+            if (!self.Handlers.TryGetValue(opcode, out actions))
+            {
+                Log.Error($"消息没有处理: {opcode} {message}");
+                return;
+            }
+
+            foreach (IMHandler ev in actions)
+            {
+                try
+                {
+                    ev.Handle(session, message);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+    }
+}

Unity/Assets/Editor/ServerManagerEditor/ServerManagerEditor.cs.meta → Unity/Assets/Hotfix/Module/Message/MessageDispatcherComponentSystem.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e7452c3f5604f024488c47940d839a96
+guid: ef027fa4e09cdd749b7915120643e8bf
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Unity/Assets/Hotfix/Module/Message/NetKcpComponentSystem.cs

@@ -0,0 +1,112 @@
+using System;
+using System.IO;
+using System.Net;
+
+namespace ET
+{
+    [ObjectSystem]
+    public class NetKcpComponentAwakeSystem: AwakeSystem<NetKcpComponent>
+    {
+        public override void Awake(NetKcpComponent self)
+        {
+            self.MessageDispatcher = new OuterMessageDispatcher();
+            
+            self.Service = new KService(NetThreadComponent.Instance.ThreadSynchronizationContext, ServiceType.Outer);
+            self.Service.ErrorCallback += self.OnError;
+            self.Service.ReadCallback += self.OnRead;
+
+            NetThreadComponent.Instance.Add(self.Service);
+        }
+    }
+
+    [ObjectSystem]
+    public class NetKcpComponentAwake1System: AwakeSystem<NetKcpComponent, IPEndPoint>
+    {
+        public override void Awake(NetKcpComponent self, IPEndPoint address)
+        {
+            self.MessageDispatcher = new OuterMessageDispatcher();
+            
+            self.Service = new KService(NetThreadComponent.Instance.ThreadSynchronizationContext, address, ServiceType.Outer);
+            self.Service.ErrorCallback += self.OnError;
+            self.Service.ReadCallback += self.OnRead;
+            self.Service.AcceptCallback += self.OnAccept;
+
+            NetThreadComponent.Instance.Add(self.Service);
+        }
+    }
+
+    [ObjectSystem]
+    public class NetKcpComponentLoadSystem: LoadSystem<NetKcpComponent>
+    {
+        public override void Load(NetKcpComponent self)
+        {
+            self.MessageDispatcher = new OuterMessageDispatcher();
+        }
+    }
+
+    [ObjectSystem]
+    public class NetKcpComponentDestroySystem: DestroySystem<NetKcpComponent>
+    {
+        public override void Destroy(NetKcpComponent self)
+        {
+            NetThreadComponent.Instance.Remove(self.Service);
+            self.Service.Destroy();
+        }
+    }
+
+    public static class NetKcpComponentSystem
+    {
+        public static void OnRead(this NetKcpComponent self, long channelId, MemoryStream memoryStream)
+        {
+            Session session = self.GetChild<Session>(channelId);
+            if (session == null)
+            {
+                return;
+            }
+
+            session.LastRecvTime = TimeHelper.ClientNow();
+            self.MessageDispatcher.Dispatch(session, memoryStream);
+        }
+
+        public static void OnError(this NetKcpComponent self, long channelId, int error)
+        {
+            Session session = self.GetChild<Session>(channelId);
+            if (session == null)
+            {
+                return;
+            }
+
+            session.Error = error;
+            session.Dispose();
+        }
+
+        // 这个channelId是由CreateAcceptChannelId生成的
+        public static void OnAccept(this NetKcpComponent self, long channelId, IPEndPoint ipEndPoint)
+        {
+            Session session = EntityFactory.CreateWithParentAndId<Session, AService>(self, channelId, self.Service);
+            session.RemoteAddress = ipEndPoint;
+
+            session.AddComponent<SessionAcceptTimeoutComponent>();
+            // 客户端连接，2秒检查一次recv消息，10秒没有消息则断开
+            session.AddComponent<SessionIdleCheckerComponent, int>(NetThreadComponent.checkInteral);
+        }
+
+        public static Session Get(this NetKcpComponent self, long id)
+        {
+            Session session = self.GetChild<Session>(id);
+            return session;
+        }
+
+        public static Session Create(this NetKcpComponent self, IPEndPoint realIPEndPoint)
+        {
+            long channelId = RandomHelper.RandInt64();
+            Session session = EntityFactory.CreateWithParentAndId<Session, AService>(self, channelId, self.Service);
+            session.RemoteAddress = realIPEndPoint;
+            session.AddComponent<SessionIdleCheckerComponent, int>(NetThreadComponent.checkInteral);
+
+            self.Service.GetOrCreate(session.Id, realIPEndPoint);
+
+            return session;
+        }
+    }
+}

Unity/Assets/Hotfix/Module/Message/NetOuterComponentSystem.cs.meta → Unity/Assets/Hotfix/Module/Message/NetKcpComponentSystem.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e98686e622a85a64faa86f208f72e787
+guid: a63db8c5f4da7da4888567c905479f23
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Unity/Assets/Hotfix/Module/Message/NetOuterComponentSystem.cs

@@ -1,38 +0,0 @@
-
-
-namespace ET
-{
-	public class NetOuterComponentAwakeSystem : AwakeSystem<NetOuterComponent>
-	{
-		public override void Awake(NetOuterComponent self)
-		{
-			self.Awake(self.Protocol);
-			self.MessageDispatcher = new OuterMessageDispatcher();
-		}
-	}
-
-	public class NetOuterComponentAwake1System : AwakeSystem<NetOuterComponent, string>
-	{
-		public override void Awake(NetOuterComponent self, string address)
-		{
-			self.Awake(self.Protocol, address);
-			self.MessageDispatcher = new OuterMessageDispatcher();
-		}
-	}
-	
-	public class NetOuterComponentLoadSystem : LoadSystem<NetOuterComponent>
-	{
-		public override void Load(NetOuterComponent self)
-		{
-			self.MessageDispatcher = new OuterMessageDispatcher();
-		}
-	}
-	
-	public class NetOuterComponentUpdateSystem : UpdateSystem<NetOuterComponent>
-	{
-		public override void Update(NetOuterComponent self)
-		{
-			self.Update();
-		}
-	}
-}

Unity/Assets/Hotfix/Module/Message/NetThreadComponentSystem.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Threading;
+
+namespace ET
+{
+    [ObjectSystem]
+    public class NetThreadComponentAwakeSystem: AwakeSystem<NetThreadComponent>
+    {
+        public override void Awake(NetThreadComponent self)
+        {
+            NetThreadComponent.Instance = self;
+            
+#if NET_THREAD
+            self.Thread = new Thread(self.Loop);
+            self.ThreadSynchronizationContext = new ThreadSynchronizationContext(self.Thread.ManagedThreadId);
+            self.Thread.Start();
+#else
+            self.ThreadSynchronizationContext = ThreadSynchronizationContext.Instance;
+#endif
+        }
+    }
+
+#if !NET_THREAD
+    [ObjectSystem]
+    public class NetThreadComponentUpdateSystem: LateUpdateSystem<NetThreadComponent>
+    {
+        public override void LateUpdate(NetThreadComponent self)
+        {
+            foreach (AService service in self.Services)
+            {
+                service.Update();
+            }
+        }
+    }
+#endif
+    
+    [ObjectSystem]
+    public class NetThreadComponentDestroySystem: DestroySystem<NetThreadComponent>
+    {
+        public override void Destroy(NetThreadComponent self)
+        {
+            self.Stop();
+        }
+    }
+    
+    public static class NetThreadComponentSystem
+    {
+#region 主线程
+
+        public static void Stop(this NetThreadComponent self)
+        {
+#if NET_THREAD
+            self.ThreadSynchronizationContext.Post(()=>{self.isRun = false;});
+#endif
+        }
+
+        public static void Add(this NetThreadComponent self, AService kService)
+        {
+            // 这里要去下一帧添加，避免foreach错误
+            self.ThreadSynchronizationContext.PostNext(() =>
+            {
+                if (kService.IsDispose())
+                {
+                    return;
+                }
+                self.Services.Add(kService);
+            });
+        }
+        
+        public static void Remove(this NetThreadComponent self, AService kService)
+        {
+            // 这里要去下一帧删除，避免foreach错误
+            self.ThreadSynchronizationContext.PostNext(() =>
+            {
+                if (kService.IsDispose())
+                {
+                    return;
+                }
+                self.Services.Remove(kService);
+            });
+        }
+
+#endregion
+
+#if NET_THREAD
+#region 网络线程
+        public static void Loop(this NetThreadComponent self)
+        {
+            self.isRun = true;
+            while (true)
+            {
+                try
+                {
+                    if (!self.isRun)
+                    {
+                        return;
+                    }
+
+                    self.ThreadSynchronizationContext.Update();
+
+                    foreach (AService service in self.Services)
+                    {
+                        service.Update();
+                    }
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+                
+                Thread.Sleep(1);
+            }
+        }
+#endregion
+#endif
+        
+    }
+}

Unity/Assets/Model/Module/Message/Network/WebSocket/WChannel.cs.meta → Unity/Assets/Hotfix/Module/Message/NetThreadComponentSystem.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 8e9431d46e7e100479fce069d4c08079
+guid: 268ac19916093d347a3733ed36720f73
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Unity/Assets/Hotfix/Module/Message/OuterMessageDispatcher.cs

@@ -0,0 +1,37 @@
+using System;
+using System.IO;
+
+namespace ET
+{
+    public class OuterMessageDispatcher: IMessageDispatcher
+    {
+        // 查找卡死问题临时处理
+        public long lastMessageTime = long.MaxValue;
+        public object LastMessage;
+        
+        public void Dispatch(Session session, MemoryStream memoryStream)
+        {
+            ushort opcode = BitConverter.ToUInt16(memoryStream.GetBuffer(), Packet.KcpOpcodeIndex);
+            Type type = OpcodeTypeComponent.Instance.GetType(opcode);
+            object message = MessageSerializeHelper.DeserializeFrom(opcode, type, memoryStream);
+
+            if (TimeHelper.ClientFrameTime() - this.lastMessageTime > 3000)
+            {
+                Log.Info($"可能导致卡死的消息: {this.LastMessage}");
+            }
+
+            this.lastMessageTime = TimeHelper.ClientFrameTime();
+            this.LastMessage = message;
+            
+            if (message is IResponse response)
+            {
+                session.OnRead(opcode, response);
+                return;
+            }
+
+            OpcodeHelper.LogMsg(session.DomainZone(), opcode, message);
+            // 普通消息或者是Rpc请求消息
+            MessageDispatcherComponent.Instance.Handle(session, opcode, message);
+        }
+    }
+}

Unity/Assets/Model/Module/Message/OuterMessageDispatcher.cs.meta → Unity/Assets/Hotfix/Module/Message/OuterMessageDispatcher.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4718b5fb8dff51f438ac8179c036699d
+guid: eadf6b4c6d9e4f146bbf89d803c01c96
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Unity/Assets/Hotfix/Module/Message/PingComponentSystem.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace ET
+{
+    [ObjectSystem]
+    public class PingComponentAwakeSystem: AwakeSystem<PingComponent>
+    {
+        public override void Awake(PingComponent self)
+        {
+            PingAsync(self).Coroutine();
+        }
+
+        private static async ETVoid PingAsync(PingComponent self)
+        {
+            Session session = self.GetParent<Session>();
+            long instanceId = self.InstanceId;
+            
+            while (true)
+            {
+                if (self.InstanceId != instanceId)
+                {
+                    return;
+                }
+
+                long time1 = TimeHelper.ClientNow();
+                try
+                {
+                    G2C_Ping response = await session.Call(self.C2G_Ping) as G2C_Ping;
+
+                    if (self.InstanceId != instanceId)
+                    {
+                        return;
+                    }
+
+                    long time2 = TimeHelper.ClientNow();
+                    self.Ping = time2 - time1;
+                    
+                    Game.TimeInfo.ServerMinusClientTime = response.Time + (time2 - time1) / 2 - time2;
+
+                    await TimerComponent.Instance.WaitAsync(2000);
+                }
+                catch (RpcException e)
+                {
+                    // session断开导致ping rpc报错，记录一下即可，不需要打成error
+                    Log.Info($"ping error: {self.Id} {e.Error}");
+                    return;
+                }
+                catch (Exception e)
+                {
+                    Log.Error($"ping error: \n{e}");
+                }
+            }
+        }
+    }
+
+    [ObjectSystem]
+    public class PingComponentDestroySystem: DestroySystem<PingComponent>
+    {
+        public override void Destroy(PingComponent self)
+        {
+            self.Ping = default;
+        }
+    }
+}

Unity/Assets/Model/Module/Message/Network/WebSocket/WService.cs.meta → Unity/Assets/Hotfix/Module/Message/PingComponentSystem.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ab08a203cf5da164c86fbc14d09e3a3b
+guid: 5e493e7e2772cd34f87800aa999fdcf8
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Unity/Assets/Hotfix/Module/Message/SessionAcceptTimeoutComponentSystem.cs

@@ -0,0 +1,25 @@
+namespace ET
+{
+    [ObjectSystem]
+    public class SessionAcceptTimeoutComponentAwakeSystem: AwakeSystem<SessionAcceptTimeoutComponent>
+    {
+        public override void Awake(SessionAcceptTimeoutComponent self)
+        {
+            //self.Timer = TimerComponent.Instance.NewOnceTimer(5000, () => { self.Parent.Dispose(); });
+        }
+    }
+
+    [ObjectSystem]
+    public class SessionAcceptTimeoutComponentDestroySystem: DestroySystem<SessionAcceptTimeoutComponent>
+    {
+        public override void Destroy(SessionAcceptTimeoutComponent self)
+        {
+            TimerComponent.Instance.Remove(ref self.Timer);
+        }
+    }
+    
+    public static class SessionAcceptTimeoutComponentSystem
+    {
+        
+    }
+}

Unity/Assets/Hotfix/Module/Message/SessionAcceptTimeoutComponentSystem.cs.meta

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

Unity/Assets/Hotfix/Module/Message/SessionIdleCheckerComponentSystem.cs

@@ -0,0 +1,39 @@
+namespace ET
+{
+    [ObjectSystem]
+    public class SessionIdleCheckerComponentAwakeSystem: AwakeSystem<SessionIdleCheckerComponent, int>
+    {
+        public override void Awake(SessionIdleCheckerComponent self, int checkInteral)
+        {
+            self.RepeatedTimer = TimerComponent.Instance.NewRepeatedTimer(checkInteral, self.Check);
+        }
+    }
+
+    [ObjectSystem]
+    public class SessionIdleCheckerComponentDestroySystem: DestroySystem<SessionIdleCheckerComponent>
+    {
+        public override void Destroy(SessionIdleCheckerComponent self)
+        {
+            TimerComponent.Instance.Remove(ref self.RepeatedTimer);
+        }
+    }
+
+    public static class SessionIdleCheckerComponentSystem
+    {
+        public static void Check(this SessionIdleCheckerComponent self)
+        {
+            Session session = self.GetParent<Session>();
+            long timeNow = TimeHelper.ClientNow();
+            
+            if (timeNow - session.LastRecvTime < 30 * 1000 && timeNow - session.LastSendTime < 30 * 1000)
+            {
+                return;
+            }
+            
+            Log.Info($"session timeout: {session.Id} {timeNow} {session.LastRecvTime} {session.LastSendTime} {timeNow - session.LastRecvTime} {timeNow - session.LastSendTime}");
+            session.Error = ErrorCode.ERR_SessionSendOrRecvTimeout;
+
+            session.Dispose();
+        }
+    }
+}

Unity/Assets/Hotfix/Module/Message/SessionIdleCheckerComponentSystem.cs.meta

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

Unity/Assets/Hotfix/Move/M2C_PathfindingResultHandler.cs

@@ -3,7 +3,7 @@
 	[MessageHandler]
 	public class M2C_PathfindingResultHandler : AMHandler<M2C_PathfindingResult>
 	{
-		protected override async ETTask Run(Session session, M2C_PathfindingResult message)
+		protected override async ETVoid Run(Session session, M2C_PathfindingResult message)
 		{
 			Unit unit = session.Domain.GetComponent<UnitComponent>().Get(message.Id);
 			unit.GameObject.transform.position = unit.Position = new UnityEngine.Vector3(message.X, message.Y, message.Z);

Unity/Assets/Hotfix/Scene/LoginHelper.cs

@@ -11,13 +11,13 @@ namespace ET
             {
                 // 创建一个ETModel层的Session
                 R2C_Login r2CLogin;
-                using (Session session = zoneScene.GetComponent<NetOuterComponent>().Create(address))
+                using (Session session = zoneScene.GetComponent<NetKcpComponent>().Create(NetworkHelper.ToIPEndPoint(address)))
                 {
                     r2CLogin = (R2C_Login) await session.Call(new C2R_Login() { Account = account, Password = "111111" });
                 }
 
                 // 创建一个gate Session,并且保存到SessionComponent中
-                Session gateSession = zoneScene.GetComponent<NetOuterComponent>().Create(r2CLogin.Address);
+                Session gateSession = zoneScene.GetComponent<NetKcpComponent>().Create(NetworkHelper.ToIPEndPoint(r2CLogin.Address));
                 zoneScene.AddComponent<SessionComponent>().Session = gateSession;
 				
                 G2C_LoginGate g2CLoginGate = (G2C_LoginGate)await gateSession.Call(

Unity/Assets/Hotfix/Unit/M2C_CreateUnitsHandler.cs

@@ -6,7 +6,7 @@ namespace ET
 	[MessageHandler]
 	public class M2C_CreateUnitsHandler : AMHandler<M2C_CreateUnits>
 	{
-		protected override async ETTask Run(Session session, M2C_CreateUnits message)
+		protected override async ETVoid Run(Session session, M2C_CreateUnits message)
 		{	
 			UnitComponent unitComponent = Game.Scene.Get(1).GetComponent<UnitComponent>();
 			

Unity/Assets/HotfixView/Scene/SceneFactory.cs

@@ -6,7 +6,7 @@ namespace ET
         {
             Scene zoneScene = EntitySceneFactory.CreateScene(id, zone, SceneType.Zone, name, Game.Scene);
             
-            zoneScene.AddComponent<NetOuterComponent>();
+            zoneScene.AddComponent<NetKcpComponent>();
             zoneScene.AddComponent<UnitComponent>();
             
             // UI层的初始化

Unity/Assets/HotfixView/Scene/SceneHelper.cs

@@ -2,16 +2,6 @@ namespace ET
 {
     public static class SceneHelper
     {
-        public static int DomainZone(this Entity entity)
-        {
-            return ((Scene) entity.Domain).Zone;
-        }
-        
-        public static Scene DomainScene(this Entity entity)
-        {
-            return (Scene) entity.Domain;
-        }
-
         public static Scene ZoneScene(this Entity entity)
         {
             return Game.Scene.Get(entity.DomainZone());

Unity/Assets/HotfixView/UI/UILoading/UILoadingComponentSystem.cs

@@ -30,13 +30,6 @@ namespace ET
                 {
                     return;
                 }
-
-                BundleDownloaderComponent bundleDownloaderComponent = Game.Scene.GetComponent<BundleDownloaderComponent>();
-                if (bundleDownloaderComponent == null)
-                {
-                    continue;
-                }
-                self.text.text = $"{bundleDownloaderComponent.Progress}%";
             }
         }
     }

Unity/Assets/Model/Base/Async/ETCancellationToken.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace ET
-{
-    public class ETCancellationToken
-    {
-        private Action action;
-
-        public void Register(Action callback)
-        {
-            this.action = callback;
-        }
-
-        public void Cancel()
-        {
-            action.Invoke();
-        }
-    }
-}

Unity/Assets/Model/Base/DoubleMap.cs.meta

@@ -1,12 +0,0 @@
-fileFormatVersion: 2
-guid: 4490fa27a0147ae41b8c923f8daa7bc1
-timeCreated: 1476430040
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: