Scripts跟导出的Excel跟Proto都各做成一个Package包

Share/Tool/ExcelExporter/ExcelExporter.cs

@@ -56,11 +56,11 @@ namespace ET
     {
         private static string template;
 
-        private const string ClientClassDir = "../Unity/Assets/Generate/Model/Excel/Client/";
+        private const string ClientClassDir = "../Unity/Assets/Excel/Model/Client/";
         // 服务端因为机器人的存在必须包含客户端所有配置，所以单独的c字段没有意义,单独的c就表示cs
-        private const string ServerClassDir = "../Unity/Assets/Generate/Model/Excel/Server/";
+        private const string ServerClassDir = "../Unity/Assets/Excel/Model/Server/";
 
-        private const string CSClassDir = "../Unity/Assets/Generate/Model/Excel/ClientServer/";
+        private const string CSClassDir = "../Unity/Assets/Excel/Model/ClientServer/";
 
         private const string jsonDir = "../Config/Json/{0}/{1}/";
 
@@ -104,10 +104,12 @@ namespace ET
                 template = File.ReadAllText("Template.txt");
                 ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
                 
-                if (Directory.Exists("../Generate/Model/Excel"))
+                if (Directory.Exists("../Unity/Assets/Excel"))
                 {
-                    Directory.Delete("../Generate/Model/Excel", true);
+                    Directory.Delete("../Unity/Assets/Excel", true);
                 }
+                
+                File.WriteAllText("../Unity/Assets/Excel/Model/AssemblyReference.asmref", "[\"reference\": \"ET.Model\"]");
 
                 if (!Directory.Exists(ClientClassDir))
                 {

Share/Tool/Proto2CS/Proto2CS.cs

@@ -22,9 +22,9 @@ namespace ET
 
     public static partial class InnerProto2CS
     {
-        private const string clientMessagePath = "../Unity/Assets/Generate/Model/Proto/Client/";
-        private const string serverMessagePath = "../Unity/Assets/Generate/Model/Proto/Server/";
-        private const string clientServerMessagePath = "../Unity/Assets/Generate/Model/Proto/ClientServer/";
+        private const string clientMessagePath = "../Unity/Assets/Proto/Model/Client/";
+        private const string serverMessagePath = "../Unity/Assets/Proto/Model/Server/";
+        private const string clientServerMessagePath = "../Unity/Assets/Proto/Model/ClientServer/";
         private static readonly char[] splitChars = [' ', '\t'];
         private static readonly List<OpcodeInfo> msgOpcode = [];
 
@@ -32,11 +32,15 @@ namespace ET
         {
             msgOpcode.Clear();
 
-            if (Directory.Exists("../Generate/Model/Proto"))
+            if (Directory.Exists("../Unity/Assets/Proto"))
             {
-                Directory.Delete("../Generate/Model/Proto", true);
+                Directory.Delete("../Unity/Assets/Proto", true);
             }
 
+            Directory.CreateDirectory("../Unity/Assets/Proto/Model");
+            
+            File.WriteAllText("../Unity/Assets/Proto/Model/AssemblyReference.asmref", "[\"reference\": \"ET.Model\"]");
+
             System.Collections.Generic.List<(string, string)> list = new ();
             foreach (string directory in Directory.GetDirectories("../Unity/Packages", "com.et.*"))
             {

Unity/Assets/Generate/ModelView.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 3bc8a6b3ec57e044d8c218ec6bd98ddc
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Unity/Assets/Scripts.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 647352e054b584a4b859362c65b09042
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Unity/Packages/com.et.core/Scripts/Model/CodeMode/ClientServer.meta → Unity/Packages/com.et.core/CodeMode/ClientServer.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 035d1da654c404640a9594ba8eb167a2
+guid: 8049b4daacc5ba044a655acda34d6265
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Assets/Generate/HotfixView/AssemblyReference.asmref.meta → Unity/Packages/com.et.core/CodeMode/ClientServer/AssemblyReference.asmref.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9c6b8ecf68e4c264792dce0868a2e7f7
+guid: e50efba8cd3c5634b816ef0e072e68ba
 AssemblyDefinitionReferenceImporter:
   externalObjects: {}
   userData: 

Unity/Packages/com.et.core/Scripts/Model/CodeMode/Server/Ignore.ET.Core.Scripts.Model.CodeModel.Server.asmdef → Unity/Packages/com.et.core/CodeMode/Ignore.ET.Core.CodeMode.asmdef

@@ -1,5 +1,5 @@
 {
-    "name": "Ignore.ET.Core.Scripts.Model.CodeModel.Server",
+    "name": "Ignore.ET.Core.CodeMode",
     "rootNamespace": "",
     "references": [],
     "includePlatforms": [],

Unity/Packages/com.et.core/Scripts/Model/CodeMode/Server/Ignore.ET.Core.Scripts.Model.CodeModel.Server.asmdef.meta → Unity/Packages/com.et.core/CodeMode/Ignore.ET.Core.CodeMode.asmdef.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3b2c2cc673e4fbf459dbb54bf4812523
+guid: a7d590a07c654b040b06581dc8e2d675
 AssemblyDefinitionImporter:
   externalObjects: {}
   userData: 

Unity/Packages/com.et.core/Scripts/Model/CodeMode/Server.meta → Unity/Packages/com.et.core/CodeMode/Server.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 98ecd3d7c1f6bb649a558bc571e15237
+guid: d2dd4565adfc6ee45959390a5e31363f
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Assets/Generate/ModelView/AssemblyReference.asmref.meta → Unity/Packages/com.et.core/Scripts/Model/Server/AssemblyReference.asmref.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3db7b32ecb06fe546958bafa73b5b571
+guid: 5deb51c590a7414418511008409a127a
 AssemblyDefinitionReferenceImporter:
   externalObjects: {}
   userData: 

Unity/Packages/com.et.core/Scripts/ModelView/AssemblyReference.asmref.meta

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

Unity/Packages/com.et.core/package.json

@@ -14,6 +14,8 @@
   },
   "relatedPackages": {},
   "dependencies": {
-    "com.cysharp.memorypack": ""
+    "com.et.scripts": "",
+    "com.et.excel": "",
+    "com.et.proto": ""
   }
 }

Unity/Assets/Generate.meta → Unity/Packages/com.et.excel/CodeMode.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 959624662e015224ebe6f3b12e9a586f
+guid: b3fd060a33ed72f46b376414e69ecf37
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Assets/Generate/Model.meta → Unity/Packages/com.et.excel/CodeMode/Model.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 8811f95d234522c419e3339e264a0657
+guid: 8512915c7360e18488093d96fdc7759a
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Assets/Generate/Hotfix.meta → Unity/Packages/com.et.excel/CodeMode/Model/Client.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 83774c921b5eb674e9ea04bc07a258c6
+guid: 8eedebce6d43d7a408c4a77045982096
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Packages/com.et.excel/CodeMode/Model/Client/UnitConfig.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class UnitConfigCategory : Singleton<UnitConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, UnitConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            UnitConfigCategory s = o as UnitConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public UnitConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out UnitConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (UnitConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, UnitConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public UnitConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class UnitConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>Type</summary>
+		public int Type { get; set; }
+		/// <summary>名字</summary>
+		public string Name { get; set; }
+		/// <summary>位置</summary>
+		public int Position { get; set; }
+		/// <summary>身高</summary>
+		public int Height { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Client/UnitConfig.cs.meta

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

Unity/Packages/com.et.statesync/Scripts/Model/CodeMode/ClientServer.meta → Unity/Packages/com.et.excel/CodeMode/Model/ClientServer.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 73d728dab3cfcda4bbe1d94a28407509
+guid: 74989f9b68d7d014c92f744a57d92f09
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Assets/Generate/Hotfix/AssemblyReference.asmref.meta → Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/AssemblyReference.asmref.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ad993a6e4ce69c2448fdd476c2a618c2
+guid: f48a6ee8fcf551c4fb1eeaedb8292cc1
 AssemblyDefinitionReferenceImporter:
   externalObjects: {}
   userData: 

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartMachineConfig.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartMachineConfigCategory : Singleton<StartMachineConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartMachineConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartMachineConfigCategory s = o as StartMachineConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartMachineConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartMachineConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartMachineConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartMachineConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartMachineConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartMachineConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>内网地址</summary>
+		public string InnerIP { get; set; }
+		/// <summary>外网地址</summary>
+		public string OuterIP { get; set; }
+		/// <summary>守护进程端口</summary>
+		public string WatcherPort { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartMachineConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartProcessConfig.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartProcessConfigCategory : Singleton<StartProcessConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartProcessConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartProcessConfigCategory s = o as StartProcessConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartProcessConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartProcessConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartProcessConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartProcessConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartProcessConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartProcessConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>所属机器</summary>
+		public int MachineId { get; set; }
+		/// <summary>外网端口</summary>
+		public int Port { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartProcessConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartSceneConfig.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartSceneConfigCategory : Singleton<StartSceneConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartSceneConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartSceneConfigCategory s = o as StartSceneConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartSceneConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartSceneConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartSceneConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartSceneConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartSceneConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartSceneConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>所属进程</summary>
+		public int Process { get; set; }
+		/// <summary>所属区</summary>
+		public int Zone { get; set; }
+		/// <summary>类型</summary>
+		public string SceneType { get; set; }
+		/// <summary>名字</summary>
+		public string Name { get; set; }
+		/// <summary>外网端口</summary>
+		public int Port { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartSceneConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartZoneConfig.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartZoneConfigCategory : Singleton<StartZoneConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartZoneConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartZoneConfigCategory s = o as StartZoneConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartZoneConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartZoneConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartZoneConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartZoneConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartZoneConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartZoneConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>数据库地址</summary>
+		public string DBConnection { get; set; }
+		/// <summary>数据库名</summary>
+		public string DBName { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/StartZoneConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/UnitConfig.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class UnitConfigCategory : Singleton<UnitConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, UnitConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            UnitConfigCategory s = o as UnitConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public UnitConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out UnitConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (UnitConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, UnitConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public UnitConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class UnitConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>Type</summary>
+		public int Type { get; set; }
+		/// <summary>名字</summary>
+		public string Name { get; set; }
+		/// <summary>位置</summary>
+		public int Position { get; set; }
+		/// <summary>身高</summary>
+		public int Height { get; set; }
+		/// <summary>体重</summary>
+		public int Weight { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/ClientServer/UnitConfig.cs.meta

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

Unity/Assets/Generate/HotfixView.meta → Unity/Packages/com.et.excel/CodeMode/Model/Server.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 35b8d94a6dea9434b9f2504bd0e67169
+guid: 941e1e4da66d20042b443bba9b5683d2
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartMachineConfig.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartMachineConfigCategory : Singleton<StartMachineConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartMachineConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartMachineConfigCategory s = o as StartMachineConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartMachineConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartMachineConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartMachineConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartMachineConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartMachineConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartMachineConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>内网地址</summary>
+		public string InnerIP { get; set; }
+		/// <summary>外网地址</summary>
+		public string OuterIP { get; set; }
+		/// <summary>守护进程端口</summary>
+		public string WatcherPort { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartMachineConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartProcessConfig.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartProcessConfigCategory : Singleton<StartProcessConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartProcessConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartProcessConfigCategory s = o as StartProcessConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartProcessConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartProcessConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartProcessConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartProcessConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartProcessConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartProcessConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>所属机器</summary>
+		public int MachineId { get; set; }
+		/// <summary>外网端口</summary>
+		public int Port { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartProcessConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartSceneConfig.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartSceneConfigCategory : Singleton<StartSceneConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartSceneConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartSceneConfigCategory s = o as StartSceneConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartSceneConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartSceneConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartSceneConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartSceneConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartSceneConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartSceneConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>所属进程</summary>
+		public int Process { get; set; }
+		/// <summary>所属区</summary>
+		public int Zone { get; set; }
+		/// <summary>类型</summary>
+		public string SceneType { get; set; }
+		/// <summary>名字</summary>
+		public string Name { get; set; }
+		/// <summary>外网端口</summary>
+		public int Port { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartSceneConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartZoneConfig.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class StartZoneConfigCategory : Singleton<StartZoneConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, StartZoneConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            StartZoneConfigCategory s = o as StartZoneConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public StartZoneConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out StartZoneConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (StartZoneConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, StartZoneConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public StartZoneConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class StartZoneConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>数据库地址</summary>
+		public string DBConnection { get; set; }
+		/// <summary>数据库名</summary>
+		public string DBName { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Server/StartZoneConfig.cs.meta

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

Unity/Packages/com.et.excel/CodeMode/Model/Server/UnitConfig.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using System.ComponentModel;
+
+namespace ET
+{
+    [Config]
+    public partial class UnitConfigCategory : Singleton<UnitConfigCategory>, IMerge
+    {
+        [BsonElement]
+        [BsonDictionaryOptions(DictionaryRepresentation.ArrayOfArrays)]
+        private Dictionary<int, UnitConfig> dict = new();
+		
+        public void Merge(object o)
+        {
+            UnitConfigCategory s = o as UnitConfigCategory;
+            foreach (var kv in s.dict)
+            {
+                this.dict.Add(kv.Key, kv.Value);
+            }
+        }
+		
+        public UnitConfig Get(int id)
+        {
+            this.dict.TryGetValue(id, out UnitConfig item);
+
+            if (item == null)
+            {
+                throw new Exception($"配置找不到，配置表名: {nameof (UnitConfig)}，配置id: {id}");
+            }
+
+            return item;
+        }
+		
+        public bool Contain(int id)
+        {
+            return this.dict.ContainsKey(id);
+        }
+
+        public Dictionary<int, UnitConfig> GetAll()
+        {
+            return this.dict;
+        }
+
+        public UnitConfig GetOne()
+        {
+            if (this.dict == null || this.dict.Count <= 0)
+            {
+                return null;
+            }
+            
+            var enumerator = this.dict.Values.GetEnumerator();
+            enumerator.MoveNext();
+            return enumerator.Current; 
+        }
+    }
+
+	public partial class UnitConfig: ProtoObject, IConfig
+	{
+		/// <summary>Id</summary>
+		public int Id { get; set; }
+		/// <summary>Type</summary>
+		public int Type { get; set; }
+		/// <summary>名字</summary>
+		public string Name { get; set; }
+		/// <summary>位置</summary>
+		public int Position { get; set; }
+		/// <summary>体重</summary>
+		public int Weight { get; set; }
+
+	}
+}

Unity/Packages/com.et.excel/CodeMode/Model/Server/UnitConfig.cs.meta

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

Unity/Packages/com.et.statesync/Scripts/Model/CodeMode/Server/Ignore.ET.StateSync.Scripts.Model.CodeModel.Server.asmdef → Unity/Packages/com.et.excel/Ignore.ET.Excel.asmdef

@@ -1,5 +1,5 @@
 {
-    "name": "Ignore.ET.StateSync.Scripts.Model.CodeModel.Server",
+    "name": "Ignore.ET.Excel",
     "rootNamespace": "",
     "references": [],
     "includePlatforms": [],

Unity/Packages/com.et.statesync/Scripts/Model/CodeMode/Server/Ignore.ET.StateSync.Scripts.Model.CodeModel.Server.asmdef.meta → Unity/Packages/com.et.excel/Ignore.ET.Excel.asmdef.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 2bf077d0ab986e6408c1c0a3c55a275d
+guid: dd161450f604069419e73326cce1d475
 AssemblyDefinitionImporter:
   externalObjects: {}
   userData: 

Unity/Packages/com.et.excel/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "com.et.excel",
+  "displayName": "ET.Excel",
+  "version": "0.0.1",
+  "unity": "2022.3",
+  "description": "et excel",
+  "author": {
+    "name": "tanghai",
+    "url": "https://github.com/egametang/ET"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/egametang/ET"
+  },
+  "relatedPackages": {},
+  "dependencies": {
+  }
+}

Unity/Packages/com.et.excel/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4d88f08d1582c564e88e67a01ac5ded5
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Packages/com.et.proto/Ignore.ET.Proto.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Ignore.ET.Proto",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "IGNORE"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Unity/Packages/com.et.proto/Ignore.ET.Proto.asmdef.meta

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

Unity/Packages/com.et.proto/Model.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dddf7e27f2732e44cb9ea5a3d882105f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Packages/com.et.proto/Model/Client.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 53f09ffb0f442134288a1e413486ba73
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Packages/com.et.proto/Model/Client/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;
+    }
+}

Unity/Packages/com.et.proto/Model/Client/ClientMessage_C_1000.cs.meta

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

Unity/Packages/com.et.proto/Model/Client/StateSyncOuter_C_10001.cs

@@ -0,0 +1,1122 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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 StateSyncOuter
+    {
+        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.proto/Model/Client/StateSyncOuter_C_10001.cs.meta

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

Unity/Packages/com.et.proto/Model/ClientServer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 64bfad785eae257498fd6bbce8eb08e2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Packages/com.et.proto/Model/ClientServer/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;
+    }
+}

Unity/Packages/com.et.proto/Model/ClientServer/ClientMessage_C_1000.cs.meta

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

Unity/Packages/com.et.proto/Model/ClientServer/StateSyncInner_S_20001.cs

@@ -0,0 +1,826 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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(StateSyncInner.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 StateSyncInner
+    {
+        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;
+    }
+}

Unity/Packages/com.et.proto/Model/ClientServer/StateSyncInner_S_20001.cs.meta

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

Unity/Packages/com.et.proto/Model/ClientServer/StateSyncOuter_C_10001.cs

@@ -0,0 +1,1122 @@
+using MemoryPack;
+using System.Collections.Generic;
+
+namespace ET
+{
+    [MemoryPackable]
+    [Message(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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(StateSyncOuter.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 StateSyncOuter
+    {
+        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.proto/Model/ClientServer/StateSyncOuter_C_10001.cs.meta

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

Unity/Packages/com.et.proto/Model/Server.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 35eb625ca631b6c4799a83a733f416ab
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: