proto2cs导出proto成功

Generate/Client/Proto/ClientMessage_C_1000.cs

@@ -0,0 +1,92 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(ClientMessage.Main2NetClient_Login)]
+    [ResponseType(nameof(NetClient2Main_Login))]
+    public partial class Main2NetClient_Login : MessageObject, IRequest
+    {
+        public static Main2NetClient_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<Main2NetClient_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int OwnerFiberId { get; set; }
+
+        /// <summary>
+        /// 账号
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.OwnerFiberId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(ClientMessage.NetClient2Main_Login)]
+    public partial class NetClient2Main_Login : MessageObject, IResponse
+    {
+        public static NetClient2Main_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<NetClient2Main_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class ClientMessage
+    {
+        public const ushort Main2NetClient_Login = 1001;
+        public const ushort NetClient2Main_Login = 1002;
+    }
+}

Generate/Client/Proto/OuterMessage_C_10001.cs

@@ -0,0 +1,1122 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(OuterMessage.HttpGetRouterResponse)]
+    public partial class HttpGetRouterResponse : MessageObject
+    {
+        public static HttpGetRouterResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<HttpGetRouterResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<string> Realms { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public List<string> Routers { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Realms.Clear();
+            this.Routers.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.RouterSync)]
+    public partial class RouterSync : MessageObject
+    {
+        public static RouterSync Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<RouterSync>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public uint ConnectId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.ConnectId = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRequest)]
+    [ResponseType(nameof(M2C_TestResponse))]
+    public partial class C2M_TestRequest : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string request { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.request = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestResponse)]
+    public partial class M2C_TestResponse : MessageObject, IResponse
+    {
+        public static M2C_TestResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string response { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.response = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_EnterMap)]
+    [ResponseType(nameof(G2C_EnterMap))]
+    public partial class C2G_EnterMap : MessageObject, ISessionRequest
+    {
+        public static C2G_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_EnterMap)]
+    public partial class G2C_EnterMap : MessageObject, ISessionResponse
+    {
+        public static G2C_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        /// <summary>
+        /// 自己的UnitId
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public long MyId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.MyId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.MoveInfo)]
+    public partial class MoveInfo : MessageObject
+    {
+        public static MoveInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<MoveInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int TurnSpeed { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Points.Clear();
+            this.Rotation = default;
+            this.TurnSpeed = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.UnitInfo)]
+    public partial class UnitInfo : MessageObject
+    {
+        public static UnitInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<UnitInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long UnitId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int ConfigId { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(4)]
+        public Unity.Mathematics.float3 Forward { get; set; }
+
+        [MongoDB.Bson.Serialization.Attributes.BsonDictionaryOptions(MongoDB.Bson.Serialization.Options.DictionaryRepresentation.ArrayOfArrays)]
+        [MemoryPackOrder(5)]
+        public Dictionary<int, long> KV { get; set; } = new();
+        [MemoryPackOrder(6)]
+        public MoveInfo MoveInfo { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.UnitId = default;
+            this.ConfigId = default;
+            this.Type = default;
+            this.Position = default;
+            this.Forward = default;
+            this.KV.Clear();
+            this.MoveInfo = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateUnits)]
+    public partial class M2C_CreateUnits : MessageObject, IMessage
+    {
+        public static M2C_CreateUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<UnitInfo> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateMyUnit)]
+    public partial class M2C_CreateMyUnit : MessageObject, IMessage
+    {
+        public static M2C_CreateMyUnit Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateMyUnit>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public UnitInfo Unit { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Unit = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_StartSceneChange)]
+    public partial class M2C_StartSceneChange : MessageObject, IMessage
+    {
+        public static M2C_StartSceneChange Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_StartSceneChange>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long SceneInstanceId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string SceneName { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.SceneInstanceId = default;
+            this.SceneName = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_RemoveUnits)]
+    public partial class M2C_RemoveUnits : MessageObject, IMessage
+    {
+        public static M2C_RemoveUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_RemoveUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<long> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_PathfindingResult)]
+    public partial class C2M_PathfindingResult : MessageObject, ILocationMessage
+    {
+        public static C2M_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Position = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Stop)]
+    public partial class C2M_Stop : MessageObject, ILocationMessage
+    {
+        public static C2M_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_PathfindingResult)]
+    public partial class M2C_PathfindingResult : MessageObject, IMessage
+    {
+        public static M2C_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(2)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Id = default;
+            this.Position = default;
+            this.Points.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Stop)]
+    public partial class M2C_Stop : MessageObject, IMessage
+    {
+        public static M2C_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Error = default;
+            this.Id = default;
+            this.Position = default;
+            this.Rotation = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Ping)]
+    [ResponseType(nameof(G2C_Ping))]
+    public partial class C2G_Ping : MessageObject, ISessionRequest
+    {
+        public static C2G_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Ping)]
+    public partial class G2C_Ping : MessageObject, ISessionResponse
+    {
+        public static G2C_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long Time { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Time = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Test)]
+    public partial class G2C_Test : MessageObject, ISessionMessage
+    {
+        public static G2C_Test Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Test>(isFromPool);
+        }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Reload)]
+    [ResponseType(nameof(M2C_Reload))]
+    public partial class C2M_Reload : MessageObject, ISessionRequest
+    {
+        public static C2M_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Reload)]
+    public partial class M2C_Reload : MessageObject, ISessionResponse
+    {
+        public static M2C_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2R_Login)]
+    [ResponseType(nameof(R2C_Login))]
+    public partial class C2R_Login : MessageObject, ISessionRequest
+    {
+        public static C2R_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2R_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.R2C_Login)]
+    public partial class R2C_Login : MessageObject, ISessionResponse
+    {
+        public static R2C_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<R2C_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string Address { get; set; }
+
+        [MemoryPackOrder(4)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(5)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Address = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_LoginGate)]
+    [ResponseType(nameof(G2C_LoginGate))]
+    public partial class C2G_LoginGate : MessageObject, ISessionRequest
+    {
+        public static C2G_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_LoginGate)]
+    public partial class G2C_LoginGate : MessageObject, ISessionResponse
+    {
+        public static G2C_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_TestHotfixMessage)]
+    public partial class G2C_TestHotfixMessage : MessageObject, ISessionMessage
+    {
+        public static G2C_TestHotfixMessage Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_TestHotfixMessage>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public string Info { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Info = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase)]
+    [ResponseType(nameof(M2C_TestRobotCase))]
+    public partial class C2M_TestRobotCase : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase)]
+    public partial class M2C_TestRobotCase : MessageObject, ILocationResponse
+    {
+        public static M2C_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase2)]
+    public partial class C2M_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static C2M_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase2)]
+    public partial class M2C_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static M2C_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TransferMap)]
+    [ResponseType(nameof(M2C_TransferMap))]
+    public partial class C2M_TransferMap : MessageObject, ILocationRequest
+    {
+        public static C2M_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TransferMap)]
+    public partial class M2C_TransferMap : MessageObject, ILocationResponse
+    {
+        public static M2C_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Benchmark)]
+    [ResponseType(nameof(G2C_Benchmark))]
+    public partial class C2G_Benchmark : MessageObject, ISessionRequest
+    {
+        public static C2G_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Benchmark)]
+    public partial class G2C_Benchmark : MessageObject, ISessionResponse
+    {
+        public static G2C_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class OuterMessage
+    {
+        public const ushort HttpGetRouterResponse = 10002;
+        public const ushort RouterSync = 10003;
+        public const ushort C2M_TestRequest = 10004;
+        public const ushort M2C_TestResponse = 10005;
+        public const ushort C2G_EnterMap = 10006;
+        public const ushort G2C_EnterMap = 10007;
+        public const ushort MoveInfo = 10008;
+        public const ushort UnitInfo = 10009;
+        public const ushort M2C_CreateUnits = 10010;
+        public const ushort M2C_CreateMyUnit = 10011;
+        public const ushort M2C_StartSceneChange = 10012;
+        public const ushort M2C_RemoveUnits = 10013;
+        public const ushort C2M_PathfindingResult = 10014;
+        public const ushort C2M_Stop = 10015;
+        public const ushort M2C_PathfindingResult = 10016;
+        public const ushort M2C_Stop = 10017;
+        public const ushort C2G_Ping = 10018;
+        public const ushort G2C_Ping = 10019;
+        public const ushort G2C_Test = 10020;
+        public const ushort C2M_Reload = 10021;
+        public const ushort M2C_Reload = 10022;
+        public const ushort C2R_Login = 10023;
+        public const ushort R2C_Login = 10024;
+        public const ushort C2G_LoginGate = 10025;
+        public const ushort G2C_LoginGate = 10026;
+        public const ushort G2C_TestHotfixMessage = 10027;
+        public const ushort C2M_TestRobotCase = 10028;
+        public const ushort M2C_TestRobotCase = 10029;
+        public const ushort C2M_TestRobotCase2 = 10030;
+        public const ushort M2C_TestRobotCase2 = 10031;
+        public const ushort C2M_TransferMap = 10032;
+        public const ushort M2C_TransferMap = 10033;
+        public const ushort C2G_Benchmark = 10034;
+        public const ushort G2C_Benchmark = 10035;
+    }
+}

Generate/ClientServer/Proto/ClientMessage_C_1000.cs

@@ -0,0 +1,92 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(ClientMessage.Main2NetClient_Login)]
+    [ResponseType(nameof(NetClient2Main_Login))]
+    public partial class Main2NetClient_Login : MessageObject, IRequest
+    {
+        public static Main2NetClient_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<Main2NetClient_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int OwnerFiberId { get; set; }
+
+        /// <summary>
+        /// 账号
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.OwnerFiberId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(ClientMessage.NetClient2Main_Login)]
+    public partial class NetClient2Main_Login : MessageObject, IResponse
+    {
+        public static NetClient2Main_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<NetClient2Main_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class ClientMessage
+    {
+        public const ushort Main2NetClient_Login = 1001;
+        public const ushort NetClient2Main_Login = 1002;
+    }
+}

Generate/ClientServer/Proto/InnerMessage_S_20001.cs

@@ -0,0 +1,826 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectQueryRequest)]
+    [ResponseType(nameof(ObjectQueryResponse))]
+    public partial class ObjectQueryRequest : MessageObject, IRequest
+    {
+        public static ObjectQueryRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectQueryRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long InstanceId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Key = default;
+            this.InstanceId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2A_Reload)]
+    [ResponseType(nameof(A2M_Reload))]
+    public partial class M2A_Reload : MessageObject, IRequest
+    {
+        public static M2A_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2A_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.A2M_Reload)]
+    public partial class A2M_Reload : MessageObject, IResponse
+    {
+        public static A2M_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<A2M_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockRequest)]
+    [ResponseType(nameof(G2G_LockResponse))]
+    public partial class G2G_LockRequest : MessageObject, IRequest
+    {
+        public static G2G_LockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Id = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockResponse)]
+    public partial class G2G_LockResponse : MessageObject, IResponse
+    {
+        public static G2G_LockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockReleaseRequest)]
+    [ResponseType(nameof(G2G_LockReleaseResponse))]
+    public partial class G2G_LockReleaseRequest : MessageObject, IRequest
+    {
+        public static G2G_LockReleaseRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockReleaseRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Id = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockReleaseResponse)]
+    public partial class G2G_LockReleaseResponse : MessageObject, IResponse
+    {
+        public static G2G_LockReleaseResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockReleaseResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectAddRequest)]
+    [ResponseType(nameof(ObjectAddResponse))]
+    public partial class ObjectAddRequest : MessageObject, IRequest
+    {
+        public static ObjectAddRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectAddRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId ActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.ActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectAddResponse)]
+    public partial class ObjectAddResponse : MessageObject, IResponse
+    {
+        public static ObjectAddResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectAddResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectLockRequest)]
+    [ResponseType(nameof(ObjectLockResponse))]
+    public partial class ObjectLockRequest : MessageObject, IRequest
+    {
+        public static ObjectLockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectLockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId ActorId { get; set; }
+
+        [MemoryPackOrder(4)]
+        public int Time { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.ActorId = default;
+            this.Time = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectLockResponse)]
+    public partial class ObjectLockResponse : MessageObject, IResponse
+    {
+        public static ObjectLockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectLockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectUnLockRequest)]
+    [ResponseType(nameof(ObjectUnLockResponse))]
+    public partial class ObjectUnLockRequest : MessageObject, IRequest
+    {
+        public static ObjectUnLockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectUnLockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId OldActorId { get; set; }
+
+        [MemoryPackOrder(4)]
+        public ActorId NewActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.OldActorId = default;
+            this.NewActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectUnLockResponse)]
+    public partial class ObjectUnLockResponse : MessageObject, IResponse
+    {
+        public static ObjectUnLockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectUnLockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectRemoveRequest)]
+    [ResponseType(nameof(ObjectRemoveResponse))]
+    public partial class ObjectRemoveRequest : MessageObject, IRequest
+    {
+        public static ObjectRemoveRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectRemoveRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectRemoveResponse)]
+    public partial class ObjectRemoveResponse : MessageObject, IResponse
+    {
+        public static ObjectRemoveResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectRemoveResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectGetRequest)]
+    [ResponseType(nameof(ObjectGetResponse))]
+    public partial class ObjectGetRequest : MessageObject, IRequest
+    {
+        public static ObjectGetRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectGetRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectGetResponse)]
+    public partial class ObjectGetResponse : MessageObject, IResponse
+    {
+        public static ObjectGetResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectGetResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(4)]
+        public ActorId ActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Type = default;
+            this.ActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.R2G_GetLoginKey)]
+    [ResponseType(nameof(G2R_GetLoginKey))]
+    public partial class R2G_GetLoginKey : MessageObject, IRequest
+    {
+        public static R2G_GetLoginKey Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<R2G_GetLoginKey>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2R_GetLoginKey)]
+    public partial class G2R_GetLoginKey : MessageObject, IResponse
+    {
+        public static G2R_GetLoginKey Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2R_GetLoginKey>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(4)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2M_SessionDisconnect)]
+    public partial class G2M_SessionDisconnect : MessageObject, ILocationMessage
+    {
+        public static G2M_SessionDisconnect Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2M_SessionDisconnect>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectQueryResponse)]
+    public partial class ObjectQueryResponse : MessageObject, IResponse
+    {
+        public static ObjectQueryResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectQueryResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public byte[] Entity { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Entity = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2M_UnitTransferRequest)]
+    [ResponseType(nameof(M2M_UnitTransferResponse))]
+    public partial class M2M_UnitTransferRequest : MessageObject, IRequest
+    {
+        public static M2M_UnitTransferRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2M_UnitTransferRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public ActorId OldActorId { get; set; }
+
+        [MemoryPackOrder(2)]
+        public byte[] Unit { get; set; }
+
+        [MemoryPackOrder(3)]
+        public List<byte[]> Entitys { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.OldActorId = default;
+            this.Unit = default;
+            this.Entitys.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2M_UnitTransferResponse)]
+    public partial class M2M_UnitTransferResponse : MessageObject, IResponse
+    {
+        public static M2M_UnitTransferResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2M_UnitTransferResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class InnerMessage
+    {
+        public const ushort ObjectQueryRequest = 20002;
+        public const ushort M2A_Reload = 20003;
+        public const ushort A2M_Reload = 20004;
+        public const ushort G2G_LockRequest = 20005;
+        public const ushort G2G_LockResponse = 20006;
+        public const ushort G2G_LockReleaseRequest = 20007;
+        public const ushort G2G_LockReleaseResponse = 20008;
+        public const ushort ObjectAddRequest = 20009;
+        public const ushort ObjectAddResponse = 20010;
+        public const ushort ObjectLockRequest = 20011;
+        public const ushort ObjectLockResponse = 20012;
+        public const ushort ObjectUnLockRequest = 20013;
+        public const ushort ObjectUnLockResponse = 20014;
+        public const ushort ObjectRemoveRequest = 20015;
+        public const ushort ObjectRemoveResponse = 20016;
+        public const ushort ObjectGetRequest = 20017;
+        public const ushort ObjectGetResponse = 20018;
+        public const ushort R2G_GetLoginKey = 20019;
+        public const ushort G2R_GetLoginKey = 20020;
+        public const ushort G2M_SessionDisconnect = 20021;
+        public const ushort ObjectQueryResponse = 20022;
+        public const ushort M2M_UnitTransferRequest = 20023;
+        public const ushort M2M_UnitTransferResponse = 20024;
+    }
+}

Generate/ClientServer/Proto/OuterMessage_C_10001.cs

@@ -0,0 +1,1122 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(OuterMessage.HttpGetRouterResponse)]
+    public partial class HttpGetRouterResponse : MessageObject
+    {
+        public static HttpGetRouterResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<HttpGetRouterResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<string> Realms { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public List<string> Routers { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Realms.Clear();
+            this.Routers.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.RouterSync)]
+    public partial class RouterSync : MessageObject
+    {
+        public static RouterSync Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<RouterSync>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public uint ConnectId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.ConnectId = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRequest)]
+    [ResponseType(nameof(M2C_TestResponse))]
+    public partial class C2M_TestRequest : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string request { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.request = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestResponse)]
+    public partial class M2C_TestResponse : MessageObject, IResponse
+    {
+        public static M2C_TestResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string response { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.response = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_EnterMap)]
+    [ResponseType(nameof(G2C_EnterMap))]
+    public partial class C2G_EnterMap : MessageObject, ISessionRequest
+    {
+        public static C2G_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_EnterMap)]
+    public partial class G2C_EnterMap : MessageObject, ISessionResponse
+    {
+        public static G2C_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        /// <summary>
+        /// 自己的UnitId
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public long MyId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.MyId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.MoveInfo)]
+    public partial class MoveInfo : MessageObject
+    {
+        public static MoveInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<MoveInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int TurnSpeed { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Points.Clear();
+            this.Rotation = default;
+            this.TurnSpeed = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.UnitInfo)]
+    public partial class UnitInfo : MessageObject
+    {
+        public static UnitInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<UnitInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long UnitId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int ConfigId { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(4)]
+        public Unity.Mathematics.float3 Forward { get; set; }
+
+        [MongoDB.Bson.Serialization.Attributes.BsonDictionaryOptions(MongoDB.Bson.Serialization.Options.DictionaryRepresentation.ArrayOfArrays)]
+        [MemoryPackOrder(5)]
+        public Dictionary<int, long> KV { get; set; } = new();
+        [MemoryPackOrder(6)]
+        public MoveInfo MoveInfo { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.UnitId = default;
+            this.ConfigId = default;
+            this.Type = default;
+            this.Position = default;
+            this.Forward = default;
+            this.KV.Clear();
+            this.MoveInfo = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateUnits)]
+    public partial class M2C_CreateUnits : MessageObject, IMessage
+    {
+        public static M2C_CreateUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<UnitInfo> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateMyUnit)]
+    public partial class M2C_CreateMyUnit : MessageObject, IMessage
+    {
+        public static M2C_CreateMyUnit Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateMyUnit>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public UnitInfo Unit { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Unit = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_StartSceneChange)]
+    public partial class M2C_StartSceneChange : MessageObject, IMessage
+    {
+        public static M2C_StartSceneChange Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_StartSceneChange>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long SceneInstanceId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string SceneName { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.SceneInstanceId = default;
+            this.SceneName = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_RemoveUnits)]
+    public partial class M2C_RemoveUnits : MessageObject, IMessage
+    {
+        public static M2C_RemoveUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_RemoveUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<long> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_PathfindingResult)]
+    public partial class C2M_PathfindingResult : MessageObject, ILocationMessage
+    {
+        public static C2M_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Position = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Stop)]
+    public partial class C2M_Stop : MessageObject, ILocationMessage
+    {
+        public static C2M_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_PathfindingResult)]
+    public partial class M2C_PathfindingResult : MessageObject, IMessage
+    {
+        public static M2C_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(2)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Id = default;
+            this.Position = default;
+            this.Points.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Stop)]
+    public partial class M2C_Stop : MessageObject, IMessage
+    {
+        public static M2C_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Error = default;
+            this.Id = default;
+            this.Position = default;
+            this.Rotation = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Ping)]
+    [ResponseType(nameof(G2C_Ping))]
+    public partial class C2G_Ping : MessageObject, ISessionRequest
+    {
+        public static C2G_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Ping)]
+    public partial class G2C_Ping : MessageObject, ISessionResponse
+    {
+        public static G2C_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long Time { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Time = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Test)]
+    public partial class G2C_Test : MessageObject, ISessionMessage
+    {
+        public static G2C_Test Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Test>(isFromPool);
+        }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Reload)]
+    [ResponseType(nameof(M2C_Reload))]
+    public partial class C2M_Reload : MessageObject, ISessionRequest
+    {
+        public static C2M_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Reload)]
+    public partial class M2C_Reload : MessageObject, ISessionResponse
+    {
+        public static M2C_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2R_Login)]
+    [ResponseType(nameof(R2C_Login))]
+    public partial class C2R_Login : MessageObject, ISessionRequest
+    {
+        public static C2R_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2R_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.R2C_Login)]
+    public partial class R2C_Login : MessageObject, ISessionResponse
+    {
+        public static R2C_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<R2C_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string Address { get; set; }
+
+        [MemoryPackOrder(4)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(5)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Address = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_LoginGate)]
+    [ResponseType(nameof(G2C_LoginGate))]
+    public partial class C2G_LoginGate : MessageObject, ISessionRequest
+    {
+        public static C2G_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_LoginGate)]
+    public partial class G2C_LoginGate : MessageObject, ISessionResponse
+    {
+        public static G2C_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_TestHotfixMessage)]
+    public partial class G2C_TestHotfixMessage : MessageObject, ISessionMessage
+    {
+        public static G2C_TestHotfixMessage Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_TestHotfixMessage>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public string Info { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Info = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase)]
+    [ResponseType(nameof(M2C_TestRobotCase))]
+    public partial class C2M_TestRobotCase : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase)]
+    public partial class M2C_TestRobotCase : MessageObject, ILocationResponse
+    {
+        public static M2C_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase2)]
+    public partial class C2M_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static C2M_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase2)]
+    public partial class M2C_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static M2C_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TransferMap)]
+    [ResponseType(nameof(M2C_TransferMap))]
+    public partial class C2M_TransferMap : MessageObject, ILocationRequest
+    {
+        public static C2M_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TransferMap)]
+    public partial class M2C_TransferMap : MessageObject, ILocationResponse
+    {
+        public static M2C_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Benchmark)]
+    [ResponseType(nameof(G2C_Benchmark))]
+    public partial class C2G_Benchmark : MessageObject, ISessionRequest
+    {
+        public static C2G_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Benchmark)]
+    public partial class G2C_Benchmark : MessageObject, ISessionResponse
+    {
+        public static G2C_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class OuterMessage
+    {
+        public const ushort HttpGetRouterResponse = 10002;
+        public const ushort RouterSync = 10003;
+        public const ushort C2M_TestRequest = 10004;
+        public const ushort M2C_TestResponse = 10005;
+        public const ushort C2G_EnterMap = 10006;
+        public const ushort G2C_EnterMap = 10007;
+        public const ushort MoveInfo = 10008;
+        public const ushort UnitInfo = 10009;
+        public const ushort M2C_CreateUnits = 10010;
+        public const ushort M2C_CreateMyUnit = 10011;
+        public const ushort M2C_StartSceneChange = 10012;
+        public const ushort M2C_RemoveUnits = 10013;
+        public const ushort C2M_PathfindingResult = 10014;
+        public const ushort C2M_Stop = 10015;
+        public const ushort M2C_PathfindingResult = 10016;
+        public const ushort M2C_Stop = 10017;
+        public const ushort C2G_Ping = 10018;
+        public const ushort G2C_Ping = 10019;
+        public const ushort G2C_Test = 10020;
+        public const ushort C2M_Reload = 10021;
+        public const ushort M2C_Reload = 10022;
+        public const ushort C2R_Login = 10023;
+        public const ushort R2C_Login = 10024;
+        public const ushort C2G_LoginGate = 10025;
+        public const ushort G2C_LoginGate = 10026;
+        public const ushort G2C_TestHotfixMessage = 10027;
+        public const ushort C2M_TestRobotCase = 10028;
+        public const ushort M2C_TestRobotCase = 10029;
+        public const ushort C2M_TestRobotCase2 = 10030;
+        public const ushort M2C_TestRobotCase2 = 10031;
+        public const ushort C2M_TransferMap = 10032;
+        public const ushort M2C_TransferMap = 10033;
+        public const ushort C2G_Benchmark = 10034;
+        public const ushort G2C_Benchmark = 10035;
+    }
+}

Generate/Server/Proto/ClientMessage_C_1000.cs

@@ -0,0 +1,92 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(ClientMessage.Main2NetClient_Login)]
+    [ResponseType(nameof(NetClient2Main_Login))]
+    public partial class Main2NetClient_Login : MessageObject, IRequest
+    {
+        public static Main2NetClient_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<Main2NetClient_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int OwnerFiberId { get; set; }
+
+        /// <summary>
+        /// 账号
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.OwnerFiberId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(ClientMessage.NetClient2Main_Login)]
+    public partial class NetClient2Main_Login : MessageObject, IResponse
+    {
+        public static NetClient2Main_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<NetClient2Main_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class ClientMessage
+    {
+        public const ushort Main2NetClient_Login = 1001;
+        public const ushort NetClient2Main_Login = 1002;
+    }
+}

Generate/Server/Proto/InnerMessage_S_20001.cs

@@ -0,0 +1,826 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectQueryRequest)]
+    [ResponseType(nameof(ObjectQueryResponse))]
+    public partial class ObjectQueryRequest : MessageObject, IRequest
+    {
+        public static ObjectQueryRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectQueryRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long InstanceId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Key = default;
+            this.InstanceId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2A_Reload)]
+    [ResponseType(nameof(A2M_Reload))]
+    public partial class M2A_Reload : MessageObject, IRequest
+    {
+        public static M2A_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2A_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.A2M_Reload)]
+    public partial class A2M_Reload : MessageObject, IResponse
+    {
+        public static A2M_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<A2M_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockRequest)]
+    [ResponseType(nameof(G2G_LockResponse))]
+    public partial class G2G_LockRequest : MessageObject, IRequest
+    {
+        public static G2G_LockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Id = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockResponse)]
+    public partial class G2G_LockResponse : MessageObject, IResponse
+    {
+        public static G2G_LockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockReleaseRequest)]
+    [ResponseType(nameof(G2G_LockReleaseResponse))]
+    public partial class G2G_LockReleaseRequest : MessageObject, IRequest
+    {
+        public static G2G_LockReleaseRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockReleaseRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Id = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2G_LockReleaseResponse)]
+    public partial class G2G_LockReleaseResponse : MessageObject, IResponse
+    {
+        public static G2G_LockReleaseResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2G_LockReleaseResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectAddRequest)]
+    [ResponseType(nameof(ObjectAddResponse))]
+    public partial class ObjectAddRequest : MessageObject, IRequest
+    {
+        public static ObjectAddRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectAddRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId ActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.ActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectAddResponse)]
+    public partial class ObjectAddResponse : MessageObject, IResponse
+    {
+        public static ObjectAddResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectAddResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectLockRequest)]
+    [ResponseType(nameof(ObjectLockResponse))]
+    public partial class ObjectLockRequest : MessageObject, IRequest
+    {
+        public static ObjectLockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectLockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId ActorId { get; set; }
+
+        [MemoryPackOrder(4)]
+        public int Time { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.ActorId = default;
+            this.Time = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectLockResponse)]
+    public partial class ObjectLockResponse : MessageObject, IResponse
+    {
+        public static ObjectLockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectLockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectUnLockRequest)]
+    [ResponseType(nameof(ObjectUnLockResponse))]
+    public partial class ObjectUnLockRequest : MessageObject, IRequest
+    {
+        public static ObjectUnLockRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectUnLockRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(3)]
+        public ActorId OldActorId { get; set; }
+
+        [MemoryPackOrder(4)]
+        public ActorId NewActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+            this.OldActorId = default;
+            this.NewActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectUnLockResponse)]
+    public partial class ObjectUnLockResponse : MessageObject, IResponse
+    {
+        public static ObjectUnLockResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectUnLockResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectRemoveRequest)]
+    [ResponseType(nameof(ObjectRemoveResponse))]
+    public partial class ObjectRemoveRequest : MessageObject, IRequest
+    {
+        public static ObjectRemoveRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectRemoveRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectRemoveResponse)]
+    public partial class ObjectRemoveResponse : MessageObject, IResponse
+    {
+        public static ObjectRemoveResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectRemoveResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectGetRequest)]
+    [ResponseType(nameof(ObjectGetResponse))]
+    public partial class ObjectGetRequest : MessageObject, IRequest
+    {
+        public static ObjectGetRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectGetRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long Key { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Type = default;
+            this.Key = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectGetResponse)]
+    public partial class ObjectGetResponse : MessageObject, IResponse
+    {
+        public static ObjectGetResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectGetResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(4)]
+        public ActorId ActorId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Type = default;
+            this.ActorId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.R2G_GetLoginKey)]
+    [ResponseType(nameof(G2R_GetLoginKey))]
+    public partial class R2G_GetLoginKey : MessageObject, IRequest
+    {
+        public static R2G_GetLoginKey Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<R2G_GetLoginKey>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2R_GetLoginKey)]
+    public partial class G2R_GetLoginKey : MessageObject, IResponse
+    {
+        public static G2R_GetLoginKey Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2R_GetLoginKey>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(4)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.G2M_SessionDisconnect)]
+    public partial class G2M_SessionDisconnect : MessageObject, ILocationMessage
+    {
+        public static G2M_SessionDisconnect Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2M_SessionDisconnect>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.ObjectQueryResponse)]
+    public partial class ObjectQueryResponse : MessageObject, IResponse
+    {
+        public static ObjectQueryResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<ObjectQueryResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public byte[] Entity { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Entity = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2M_UnitTransferRequest)]
+    [ResponseType(nameof(M2M_UnitTransferResponse))]
+    public partial class M2M_UnitTransferRequest : MessageObject, IRequest
+    {
+        public static M2M_UnitTransferRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2M_UnitTransferRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public ActorId OldActorId { get; set; }
+
+        [MemoryPackOrder(2)]
+        public byte[] Unit { get; set; }
+
+        [MemoryPackOrder(3)]
+        public List<byte[]> Entitys { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.OldActorId = default;
+            this.Unit = default;
+            this.Entitys.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(InnerMessage.M2M_UnitTransferResponse)]
+    public partial class M2M_UnitTransferResponse : MessageObject, IResponse
+    {
+        public static M2M_UnitTransferResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2M_UnitTransferResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class InnerMessage
+    {
+        public const ushort ObjectQueryRequest = 20002;
+        public const ushort M2A_Reload = 20003;
+        public const ushort A2M_Reload = 20004;
+        public const ushort G2G_LockRequest = 20005;
+        public const ushort G2G_LockResponse = 20006;
+        public const ushort G2G_LockReleaseRequest = 20007;
+        public const ushort G2G_LockReleaseResponse = 20008;
+        public const ushort ObjectAddRequest = 20009;
+        public const ushort ObjectAddResponse = 20010;
+        public const ushort ObjectLockRequest = 20011;
+        public const ushort ObjectLockResponse = 20012;
+        public const ushort ObjectUnLockRequest = 20013;
+        public const ushort ObjectUnLockResponse = 20014;
+        public const ushort ObjectRemoveRequest = 20015;
+        public const ushort ObjectRemoveResponse = 20016;
+        public const ushort ObjectGetRequest = 20017;
+        public const ushort ObjectGetResponse = 20018;
+        public const ushort R2G_GetLoginKey = 20019;
+        public const ushort G2R_GetLoginKey = 20020;
+        public const ushort G2M_SessionDisconnect = 20021;
+        public const ushort ObjectQueryResponse = 20022;
+        public const ushort M2M_UnitTransferRequest = 20023;
+        public const ushort M2M_UnitTransferResponse = 20024;
+    }
+}

Generate/Server/Proto/OuterMessage_C_10001.cs

@@ -0,0 +1,1122 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(OuterMessage.HttpGetRouterResponse)]
+    public partial class HttpGetRouterResponse : MessageObject
+    {
+        public static HttpGetRouterResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<HttpGetRouterResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<string> Realms { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public List<string> Routers { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Realms.Clear();
+            this.Routers.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.RouterSync)]
+    public partial class RouterSync : MessageObject
+    {
+        public static RouterSync Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<RouterSync>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public uint ConnectId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Address { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.ConnectId = default;
+            this.Address = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRequest)]
+    [ResponseType(nameof(M2C_TestResponse))]
+    public partial class C2M_TestRequest : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRequest Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRequest>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string request { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.request = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestResponse)]
+    public partial class M2C_TestResponse : MessageObject, IResponse
+    {
+        public static M2C_TestResponse Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestResponse>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string response { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.response = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_EnterMap)]
+    [ResponseType(nameof(G2C_EnterMap))]
+    public partial class C2G_EnterMap : MessageObject, ISessionRequest
+    {
+        public static C2G_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_EnterMap)]
+    public partial class G2C_EnterMap : MessageObject, ISessionResponse
+    {
+        public static G2C_EnterMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_EnterMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        /// <summary>
+        /// 自己的UnitId
+        /// </summary>
+        [MemoryPackOrder(3)]
+        public long MyId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.MyId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.MoveInfo)]
+    public partial class MoveInfo : MessageObject
+    {
+        public static MoveInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<MoveInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int TurnSpeed { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Points.Clear();
+            this.Rotation = default;
+            this.TurnSpeed = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.UnitInfo)]
+    public partial class UnitInfo : MessageObject
+    {
+        public static UnitInfo Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<UnitInfo>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long UnitId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int ConfigId { get; set; }
+
+        [MemoryPackOrder(2)]
+        public int Type { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(4)]
+        public Unity.Mathematics.float3 Forward { get; set; }
+
+        [MongoDB.Bson.Serialization.Attributes.BsonDictionaryOptions(MongoDB.Bson.Serialization.Options.DictionaryRepresentation.ArrayOfArrays)]
+        [MemoryPackOrder(5)]
+        public Dictionary<int, long> KV { get; set; } = new();
+        [MemoryPackOrder(6)]
+        public MoveInfo MoveInfo { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.UnitId = default;
+            this.ConfigId = default;
+            this.Type = default;
+            this.Position = default;
+            this.Forward = default;
+            this.KV.Clear();
+            this.MoveInfo = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateUnits)]
+    public partial class M2C_CreateUnits : MessageObject, IMessage
+    {
+        public static M2C_CreateUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<UnitInfo> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_CreateMyUnit)]
+    public partial class M2C_CreateMyUnit : MessageObject, IMessage
+    {
+        public static M2C_CreateMyUnit Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_CreateMyUnit>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public UnitInfo Unit { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Unit = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_StartSceneChange)]
+    public partial class M2C_StartSceneChange : MessageObject, IMessage
+    {
+        public static M2C_StartSceneChange Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_StartSceneChange>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long SceneInstanceId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string SceneName { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.SceneInstanceId = default;
+            this.SceneName = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_RemoveUnits)]
+    public partial class M2C_RemoveUnits : MessageObject, IMessage
+    {
+        public static M2C_RemoveUnits Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_RemoveUnits>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public List<long> Units { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Units.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_PathfindingResult)]
+    public partial class C2M_PathfindingResult : MessageObject, ILocationMessage
+    {
+        public static C2M_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Position = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Stop)]
+    public partial class C2M_Stop : MessageObject, ILocationMessage
+    {
+        public static C2M_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_PathfindingResult)]
+    public partial class M2C_PathfindingResult : MessageObject, IMessage
+    {
+        public static M2C_PathfindingResult Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_PathfindingResult>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(1)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(2)]
+        public List<Unity.Mathematics.float3> Points { get; set; } = new();
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Id = default;
+            this.Position = default;
+            this.Points.Clear();
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Stop)]
+    public partial class M2C_Stop : MessageObject, IMessage
+    {
+        public static M2C_Stop Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Stop>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(1)]
+        public long Id { get; set; }
+
+        [MemoryPackOrder(2)]
+        public Unity.Mathematics.float3 Position { get; set; }
+
+        [MemoryPackOrder(3)]
+        public Unity.Mathematics.quaternion Rotation { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Error = default;
+            this.Id = default;
+            this.Position = default;
+            this.Rotation = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Ping)]
+    [ResponseType(nameof(G2C_Ping))]
+    public partial class C2G_Ping : MessageObject, ISessionRequest
+    {
+        public static C2G_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Ping)]
+    public partial class G2C_Ping : MessageObject, ISessionResponse
+    {
+        public static G2C_Ping Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Ping>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long Time { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Time = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Test)]
+    public partial class G2C_Test : MessageObject, ISessionMessage
+    {
+        public static G2C_Test Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Test>(isFromPool);
+        }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_Reload)]
+    [ResponseType(nameof(M2C_Reload))]
+    public partial class C2M_Reload : MessageObject, ISessionRequest
+    {
+        public static C2M_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_Reload)]
+    public partial class M2C_Reload : MessageObject, ISessionResponse
+    {
+        public static M2C_Reload Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_Reload>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2R_Login)]
+    [ResponseType(nameof(R2C_Login))]
+    public partial class C2R_Login : MessageObject, ISessionRequest
+    {
+        public static C2R_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2R_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public string Account { get; set; }
+
+        /// <summary>
+        /// 密码
+        /// </summary>
+        [MemoryPackOrder(2)]
+        public string Password { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Account = default;
+            this.Password = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.R2C_Login)]
+    public partial class R2C_Login : MessageObject, ISessionResponse
+    {
+        public static R2C_Login Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<R2C_Login>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public string Address { get; set; }
+
+        [MemoryPackOrder(4)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(5)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.Address = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_LoginGate)]
+    [ResponseType(nameof(G2C_LoginGate))]
+    public partial class C2G_LoginGate : MessageObject, ISessionRequest
+    {
+        public static C2G_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        /// <summary>
+        /// 帐号
+        /// </summary>
+        [MemoryPackOrder(1)]
+        public long Key { get; set; }
+
+        [MemoryPackOrder(2)]
+        public long GateId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Key = default;
+            this.GateId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_LoginGate)]
+    public partial class G2C_LoginGate : MessageObject, ISessionResponse
+    {
+        public static G2C_LoginGate Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_LoginGate>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public long PlayerId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.PlayerId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_TestHotfixMessage)]
+    public partial class G2C_TestHotfixMessage : MessageObject, ISessionMessage
+    {
+        public static G2C_TestHotfixMessage Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_TestHotfixMessage>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public string Info { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.Info = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase)]
+    [ResponseType(nameof(M2C_TestRobotCase))]
+    public partial class C2M_TestRobotCase : MessageObject, ILocationRequest
+    {
+        public static C2M_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase)]
+    public partial class M2C_TestRobotCase : MessageObject, ILocationResponse
+    {
+        public static M2C_TestRobotCase Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        [MemoryPackOrder(3)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TestRobotCase2)]
+    public partial class C2M_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static C2M_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TestRobotCase2)]
+    public partial class M2C_TestRobotCase2 : MessageObject, ILocationMessage
+    {
+        public static M2C_TestRobotCase2 Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TestRobotCase2>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int N { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.N = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2M_TransferMap)]
+    [ResponseType(nameof(M2C_TransferMap))]
+    public partial class C2M_TransferMap : MessageObject, ILocationRequest
+    {
+        public static C2M_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2M_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.M2C_TransferMap)]
+    public partial class M2C_TransferMap : MessageObject, ILocationResponse
+    {
+        public static M2C_TransferMap Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<M2C_TransferMap>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.C2G_Benchmark)]
+    [ResponseType(nameof(G2C_Benchmark))]
+    public partial class C2G_Benchmark : MessageObject, ISessionRequest
+    {
+        public static C2G_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<C2G_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    [MemoryPackable]
+    [Message(OuterMessage.G2C_Benchmark)]
+    public partial class G2C_Benchmark : MessageObject, ISessionResponse
+    {
+        public static G2C_Benchmark Create(bool isFromPool = false)
+        {
+            return ObjectPool.Fetch<G2C_Benchmark>(isFromPool);
+        }
+
+        [MemoryPackOrder(0)]
+        public int RpcId { get; set; }
+
+        [MemoryPackOrder(1)]
+        public int Error { get; set; }
+
+        [MemoryPackOrder(2)]
+        public string Message { get; set; }
+
+        public override void Dispose()
+        {
+            if (!this.IsFromPool)
+            {
+                return;
+            }
+
+            this.RpcId = default;
+            this.Error = default;
+            this.Message = default;
+
+            ObjectPool.Recycle(this);
+        }
+    }
+
+    public static class OuterMessage
+    {
+        public const ushort HttpGetRouterResponse = 10002;
+        public const ushort RouterSync = 10003;
+        public const ushort C2M_TestRequest = 10004;
+        public const ushort M2C_TestResponse = 10005;
+        public const ushort C2G_EnterMap = 10006;
+        public const ushort G2C_EnterMap = 10007;
+        public const ushort MoveInfo = 10008;
+        public const ushort UnitInfo = 10009;
+        public const ushort M2C_CreateUnits = 10010;
+        public const ushort M2C_CreateMyUnit = 10011;
+        public const ushort M2C_StartSceneChange = 10012;
+        public const ushort M2C_RemoveUnits = 10013;
+        public const ushort C2M_PathfindingResult = 10014;
+        public const ushort C2M_Stop = 10015;
+        public const ushort M2C_PathfindingResult = 10016;
+        public const ushort M2C_Stop = 10017;
+        public const ushort C2G_Ping = 10018;
+        public const ushort G2C_Ping = 10019;
+        public const ushort G2C_Test = 10020;
+        public const ushort C2M_Reload = 10021;
+        public const ushort M2C_Reload = 10022;
+        public const ushort C2R_Login = 10023;
+        public const ushort R2C_Login = 10024;
+        public const ushort C2G_LoginGate = 10025;
+        public const ushort G2C_LoginGate = 10026;
+        public const ushort G2C_TestHotfixMessage = 10027;
+        public const ushort C2M_TestRobotCase = 10028;
+        public const ushort M2C_TestRobotCase = 10029;
+        public const ushort C2M_TestRobotCase2 = 10030;
+        public const ushort M2C_TestRobotCase2 = 10031;
+        public const ushort C2M_TransferMap = 10032;
+        public const ushort M2C_TransferMap = 10033;
+        public const ushort C2G_Benchmark = 10034;
+        public const ushort G2C_Benchmark = 10035;
+    }
+}

Unity/Packages/com.et.core/Proto/LockStepInner_S_21001.proto

@@ -1,67 +0,0 @@
-syntax = "proto3";
-package ET;
-
-/// 请求匹配
-// ResponseType Match2G_Match
-message G2Match_Match // IRequest
-{
-	int32 RpcId = 1;
-	
-	int64 Id = 2;
-}
-
-message Match2G_Match // IResponse
-{
-	int32 RpcId = 1;
-	int32 Error = 2;
-	string Message = 3;
-}
-
-// ResponseType Map2Match_GetRoom
-message Match2Map_GetRoom // IRequest
-{
-	int32 RpcId = 1;
-	repeated int64 PlayerIds = 2;
-}
-
-message Map2Match_GetRoom // IResponse
-{
-	int32 RpcId = 1;
-	int32 Error = 2;
-	string Message = 3;
-
-	/// 房间的ActorId
-	ActorId ActorId = 4;
-}
-
-// ResponseType Room2G_Reconnect
-message G2Room_Reconnect // IRequest
-{
-	int32 RpcId = 1;
-	int64 PlayerId = 2;
-}
-
-message Room2G_Reconnect // IResponse
-{
-	int32 RpcId = 1;
-	int32 Error = 2;
-	string Message = 3;
-
-	int64 StartTime = 4;
-	repeated LockStepUnitInfo UnitInfos = 5;
-	int32 Frame = 6;
-}
-
-// ResponseType Room2RoomManager_Init
-message RoomManager2Room_Init // IRequest
-{
-	int32 RpcId = 1;
-	repeated int64 PlayerIds = 2;
-}
-
-message Room2RoomManager_Init // IResponse
-{
-	int32 RpcId = 1;
-	int32 Error = 2;
-	string Message = 3;
-}

Unity/Packages/com.et.core/Proto/LockStepInner_S_21001.proto.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 2adafb641a45a4d548b1cc826aca1d6f
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Unity/Packages/com.et.core/Proto/LockStepOuter_C_11001.proto

@@ -1,81 +0,0 @@
-syntax = "proto3";
-package ET;
-
-// ResponseType G2C_Match
-message C2G_Match // ISessionRequest
-{
-	int32 RpcId = 1;
-}
-
-message G2C_Match // ISessionResponse
-{
-	int32 RpcId = 1;
-	int32 Error = 2;
-	string Message = 3;
-}
-
-/// 匹配成功，通知客户端切换场景
-message Match2G_NotifyMatchSuccess // IMessage
-{
-	int32 RpcId = 1;
-	/// 房间的ActorId
-	ActorId ActorId = 2;
-}
-
-/// 客户端通知房间切换场景完成
-message C2Room_ChangeSceneFinish // IRoomMessage
-{
-	int64 PlayerId = 1;
-}
-
-message LockStepUnitInfo
-{
-	int64 PlayerId = 1;
-	TrueSync.TSVector Position = 2;
-	TrueSync.TSQuaternion Rotation = 3;
-}
-
-/// 房间通知客户端进入战斗
-message Room2C_Start // IMessage
-{
-	int64 StartTime = 1;
-	repeated LockStepUnitInfo UnitInfo = 2;
-}
-
-message FrameMessage // IMessage
-{
-	int32 Frame = 1;
-	int64 PlayerId = 2;
-	LSInput Input = 3;
-}
-
-message OneFrameInputs // IMessage
-{
-	int32 Frame = 1;
-	map<int64, LSInput> Inputs = 2;
-}
-
-message Room2C_AdjustUpdateTime // IMessage
-{
-	int32 DiffTime = 1;
-}
-
-message C2Room_CheckHash // IRoomMessage
-{
-	int64 PlayerId = 1;
-	int32 Frame = 2;
-	int64 Hash = 3;
-}
-
-message Room2C_CheckHashFail // IMessage
-{
-	int32 Frame = 1;
-	bytes LSWorldBytes = 2;
-}
-
-message G2C_Reconnect // IMessage
-{
-	int64 StartTime = 1;
-	repeated LockStepUnitInfo UnitInfos = 2;
-	int32 Frame = 3;
-}

Unity/Packages/com.et.core/Proto/LockStepOuter_C_11001.proto.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 32e6c63b0256f45a19583fba46f5cfab
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: