export-table-plugin-csharp 1.1.189

package/dist/ExportUnityCSJsonPlugin.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportUJsonPlugin = void 0;
+exports.exportUJson = exportUJson;
+exports.exportUJsonLoader = exportUJsonLoader;
+const export_table_lib_1 = require("export-table-lib");
+const CSParseTool_1 = require("./CSParseTool");
+var isSkipIndexLoader0 = process.argv.findIndex(v => v == "--SkipIndexLoader") >= 0;
+var isWrapObject = process.argv.findIndex(v => v == "--WrapObject") >= 0;
+let firstLetterUpper = export_table_lib_1.makeFirstLetterUpper;
+function exportUJson(paras) {
+    let { datas, fields, name, objects, table, } = paras;
+    var fullName = `${table.workbookName}-${name}`;
+    let jsonString = JSON.stringify(objects.map(obj => {
+        var newObj = Object.create(null);
+        for (let f of fields) {
+            let key = f.name;
+            var newKey = (0, CSParseTool_1.convMemberName)(key);
+            newObj[newKey] = obj[key];
+            let content = obj[key];
+            let result = (0, CSParseTool_1.genTupleArrayValue)(f, content);
+            if (result != null) {
+                let { isArray, objs } = result;
+                if (isArray) {
+                    newObj[newKey + "Obj"] = objs;
+                }
+                else {
+                    if (objs.length > 1) {
+                        console.log(`配置错误，过多的条目数量: ${content}`);
+                    }
+                    newObj[newKey + "Obj"] = objs[0] ?? {};
+                }
+            }
+        }
+        // Object.keys(obj).forEach(key => {
+        // 	var newKey = convMemberName(key);
+        // 	newObj[newKey] = obj[key];
+        // })
+        return newObj;
+    }));
+    if (isWrapObject) {
+        jsonString = `{"A":${jsonString}}`;
+    }
+    return jsonString;
+    // 	// !!!必须开头没有空格
+    // 	let temp = `%YAML 1.1
+    // %TAG !u! tag:unity3d.com,2011:
+    // --- !u!114 &11400000
+    // MonoBehaviour:
+    //   m_ObjectHideFlags: 0
+    //   m_CorrespondingSourceObject: {fileID: 0}
+    //   m_PrefabInstance: {fileID: 0}
+    //   m_PrefabAsset: {fileID: 0}
+    //   m_GameObject: {fileID: 0}
+    //   m_Enabled: 1
+    //   m_EditorHideFlags: 0
+    //   m_Script: {fileID: 11500000, guid: 496f60086c072a8479a6e0b948efb5e8, type: 3}
+    //   m_Name: ${fullName}
+    //   m_EditorClassIdentifier:
+    //   JsonText: ${JSON.stringify(jsonString)}
+    // `
+    // 	return temp
+}
+function exportUJsonLoader(paras) {
+    let { datas, fields, name, objects, table, exportNamespace, allTags, } = paras;
+    let useJsonToolNamesapce = (0, CSParseTool_1.GetUsingJsonToolNamespace)();
+    let RowClass = firstLetterUpper(name);
+    let fullName = `${table.workbookName}-${name}`;
+    let isMMP = CSParseTool_1.isEnableMMP || allTags.indexOf('csharp:mmp') != -1;
+    let fileExt = isMMP ? ".bytes" : ".json";
+    // !!!必须开头没有空格
+    let temp = `
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using UnityEngine;
+${useJsonToolNamesapce}
+
+namespace ${exportNamespace}
+{
+	public partial class ${RowClass}
+	{
+#if UNITY_EDITOR && ENABLE_CONFIG_LOG
+		static ${RowClass}()
+		{
+			Debug.Log("ReferConfig-${RowClass}");
+		}
+#endif
+		[System.Serializable]
+		private struct TempA
+		{
+			public List<${RowClass}> a;
+		}
+
+		public const string LoadUrl = "Assets/Bundles/GameConfigs/Auto/${fullName}${fileExt}";
+		public static int LoadState = 0;
+		public static bool IsLoadedSuccessfully => LoadState == 4;
+		public static bool IsComplete => LoadState != 0;
+
+		public static async Task Load()
+		{
+			if (LoadState <= 0)
+			{
+				LoadState = 1;
+				var loadUrl = LoadUrl;
+				var configLiteral = await ConfigAssetLoader.LoadAssetAsync(loadUrl);
+				if (configLiteral != null)
+				{
+					Debug.Log($"解析配表: {loadUrl}");
+					try
+					{
+						// JsonUtility.FromJsonOverwrite("{\"a\":"+configLiteral+"}", obj);
+						LoadState = 2;
+						ConfigAssetLoader.LoadConfigs(configLiteral, Configs);
+						LoadState = 4;
+					}
+					catch (System.Exception ex)
+					{
+						LoadState = -2;
+						Debug.LogError($"解析配表失败: {loadUrl}");
+						throw ex;
+					}
+				}
+				else
+				{
+					LoadState = -1;
+					Debug.LogError($"配表资源缺失: {loadUrl}");
+				}
+			}
+		}
+
+#if UNITY_EDITOR
+		public static void LoadInEditor(bool force = false, System.Func<string, string> pathConverter = null)
+		{
+			if ((!force) && UnityEditor.EditorApplication.isPlaying)
+			{
+				var tip = $"cannot load ${RowClass}[] with LoadInEditor at runtime";
+				Debug.LogError(tip);
+				throw new System.Exception(tip);
+			}
+			var loadUrl = pathConverter == null ? LoadUrl : pathConverter(LoadUrl);
+			var configLiteral = System.IO.File.ReadAllText(loadUrl, System.Text.Encoding.UTF8);
+			if (configLiteral != null)
+			{
+				Configs.Clear();
+				try
+				{
+					ConfigAssetLoader.LoadConfigs(configLiteral, Configs);
+				}
+				catch(System.Exception ex)
+				{
+					Debug.LogError($"解析配表失败: {loadUrl}");
+                    throw ex;
+				}
+			}
+			else
+			{
+				Debug.LogError($"配表资源缺失: {loadUrl}");
+			}
+		}
+			
+		public static void SaveInEditor(bool force = false, System.Func<string, string> pathConverter = null)
+		{
+			if ((!force) && UnityEditor.EditorApplication.isPlaying)
+			{
+				var tip = $"cannot load ${RowClass}[] with LoadInEditor at runtime";
+				Debug.LogError(tip);
+				throw new System.Exception(tip);
+			}
+
+			var loadUrl = pathConverter == null ? LoadUrl : pathConverter(LoadUrl);
+			string configLiteral = null;
+			try
+			{
+				configLiteral = ConfigAssetLoader.ToLiteral(Configs);
+			}
+			catch (System.Exception exception)
+			{
+				Debug.LogError($"json序列化失败: {loadUrl}");
+				throw exception;
+			}
+
+			if (configLiteral != null)
+			{
+				try
+				{
+					var content0 = System.IO.File.ReadAllText(loadUrl, System.Text.Encoding.UTF8);
+					if (content0 != configLiteral)
+					{
+						System.IO.File.WriteAllText(loadUrl, configLiteral, System.Text.Encoding.UTF8);
+					}
+				}
+				catch (System.Exception exception)
+				{
+					Debug.LogError($"写配置文件失败: {loadUrl}");
+					throw exception;
+				}
+			}
+		}
+#endif
+	}
+}
+`;
+    return temp;
+}
+class ExportUJsonPlugin extends export_table_lib_1.PluginBase {
+    name = "ujson";
+    tags = ["ujson"];
+    handleSheet(paras) {
+        var fullName = `${paras.table.workbookName}-${paras.name}`;
+        {
+            let content1 = exportUJsonLoader(paras);
+            if (content1 != null) {
+                let savePath = new export_table_lib_1.OutFilePath(paras.outPath, fullName, "Loader.cs").fullPath;
+                (0, CSParseTool_1.outputFileSync)(savePath, content1, "utf-8");
+            }
+        }
+        {
+            let content2 = exportUJson(paras);
+            if (content2 != null) {
+                let savePath = new export_table_lib_1.OutFilePath(paras.outPath, fullName, ".json").fullPath;
+                (0, CSParseTool_1.outputFileSync)(savePath, content2, "utf-8");
+            }
+            return content2;
+        }
+    }
+    handleBatch(paras) {
+        let { moreOptions, tables, exportNamespace, } = paras;
+        let isSkipIndexLoader = moreOptions?.SkipIndexLoader ?? false;
+        if (isSkipIndexLoader0) {
+            isSkipIndexLoader = true;
+        }
+        if (isSkipIndexLoader) {
+            return;
+        }
+        var temp = `
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ${exportNamespace}
+{
+	public static class DefaultConfigLoader{
+		public static IEnumerable<Func<Task>> Load(){
+${(0, export_table_lib_1.foreach)(tables.sort((ta, tb) => ta.name.localeCompare(tb.name)), (table) => `
+			yield return ${firstLetterUpper(table.name)}.Load;
+`)}
+			yield break;
+		}
+		
+#if UNITY_EDITOR
+		public static IEnumerable<Action<bool, System.Func<string, string>>> LoadInEditor(){
+${(0, export_table_lib_1.foreach)(tables.sort((ta, tb) => ta.name.localeCompare(tb.name)), (table) => `
+			yield return ${firstLetterUpper(table.name)}.LoadInEditor;
+`)}
+			yield break;
+		}
+#endif
+	}
+}
+`;
+        let savePath = paras.outPath + "/DefaultConfigLoader.cs";
+        (0, CSParseTool_1.outputFileSync)(savePath, temp, "utf-8");
+    }
+}
+exports.ExportUJsonPlugin = ExportUJsonPlugin;

package/dist/ExportUnityMMPPlugin.d.ts

@@ -0,0 +1,8 @@
+import { HandleSheetParams, PluginBase } from "export-table-lib";
+export declare function exportMMP(paras: HandleSheetParams): string | null;
+export declare class ExportUnityMMPPlugin extends PluginBase {
+    name: string;
+    tags: string[];
+    handleSheet(paras: HandleSheetParams): void;
+}
+//# sourceMappingURL=ExportUnityMMPPlugin.d.ts.map

package/dist/ExportUnityMMPPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportUnityMMPPlugin.d.ts","sourceRoot":"","sources":["../src/ExportUnityMMPPlugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAO,iBAAiB,EAA+B,UAAU,EAA6D,MAAM,kBAAkB,CAAA;AAQ7J,wBAAgB,SAAS,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CAqGjE;AAED,qBAAa,oBAAqB,SAAQ,UAAU;IACnD,IAAI,SAAQ;IACZ,IAAI,EAAE,MAAM,EAAE,CAAU;IAExB,WAAW,CAAC,KAAK,EAAE,iBAAiB;CAUpC"}

package/dist/ExportUnityMMPPlugin.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportUnityMMPPlugin = void 0;
+exports.exportMMP = exportMMP;
+const export_table_lib_1 = require("export-table-lib");
+const CSParseTool_1 = require("./CSParseTool");
+var isEnableMMPB = process.argv.findIndex(v => v == "--EnableMMPB") >= 0;
+let firstLetterUpper = export_table_lib_1.makeFirstLetterUpper;
+function exportMMP(paras) {
+    let { datas, fields, name, objects, table, exportNamespace, } = paras;
+    let RowClass = firstLetterUpper(name);
+    var fullName = `${table.workbookName}-${name}`;
+    var mmpMark = "[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]";
+    // TODO: 支持FK类型
+    let temp = `
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+${CSParseTool_1.useMMPNamespace}
+
+namespace ${exportNamespace}
+{
+	${mmpMark}
+	public partial class ${RowClass} : IMMPSerializable
+	{
+		private static int _typeSize = -1;
+
+		public static int GetTypeSize()
+		{
+			if (_typeSize >= 0)
+			{
+				return _typeSize;
+			}
+
+			_typeSize = Marshal.SizeOf<${RowClass}>();
+			return _typeSize;
+		}
+
+		public void Serialize(ref SerializeParas paras)
+		{
+${(0, export_table_lib_1.foreach)(fields, f => `
+${(0, export_table_lib_1.iff)(f.type == "string[]", () => `
+			var ${(0, CSParseTool_1.convVarName)(f.name)} = this.${(0, CSParseTool_1.convMemberName)(f.name)}; this.${(0, CSParseTool_1.convMemberName)(f.name)} = null;
+`)}
+`)}
+			Marshal.StructureToPtr(this, paras.Ptr, false);
+${(0, export_table_lib_1.foreach)(fields, f => `
+${(0, export_table_lib_1.iff)(f.type == "string[]", () => `
+			this.${(0, CSParseTool_1.convMemberName)(f.name)} = ${(0, CSParseTool_1.convVarName)(f.name)};
+`)}
+`)}
+			paras.Offset += GetTypeSize();
+${(0, export_table_lib_1.foreach)(fields, f => `
+${(0, export_table_lib_1.iff)(f.type == "string", () => `
+			// ${f.name}
+			BitUtils.FromString(ref paras, this.${(0, CSParseTool_1.convMemberName)(f.name)});
+${(0, export_table_lib_1.iff)(f.rawType.startsWith("@") && f.rawType.endsWith("[]"), () => `
+			BitUtils.FromSArray(ref paras, this.${(0, CSParseTool_1.convMemberName)(f.name)}Obj);
+`)}
+`).elseif(f.type == "string[]", () => `
+			// ${f.name}
+			BitUtils.FromArray(ref paras, this.${(0, CSParseTool_1.convMemberName)(f.name)}, BitUtils.FromString);
+`).elseif((0, CSParseTool_1.isTypeArray)(f), () => `
+			// ${f.name}
+			BitUtils.FromRawArray(ref paras, this.${(0, CSParseTool_1.convMemberName)(f.name)});
+`).else(() => `
+`)}
+`, "\n")}
+		}
+
+		public void Deserialize(ref DeserializeParas paras)
+		{
+			Marshal.PtrToStructure(paras.Ptr, this);
+			paras.Offset += GetTypeSize();
+${(0, export_table_lib_1.foreach)(fields, f => `
+${(0, export_table_lib_1.iff)(f.type == "string", () => `
+			// ${f.name}
+			this.${(0, CSParseTool_1.convMemberName)(f.name)} = BitUtils.ToString(ref paras);
+${(0, export_table_lib_1.iff)(f.rawType.startsWith("@") && f.rawType.endsWith("[]"), () => `
+			BitUtils.ToSArray(ref paras, ref this.${(0, CSParseTool_1.convMemberName)(f.name)}Obj);
+`)}
+`).elseif(f.type == "string[]", () => `
+			// ${f.name}
+			this.${(0, CSParseTool_1.convMemberName)(f.name)} = BitUtils.ToArray(ref paras, BitUtils.ToString);
+`).elseif((0, CSParseTool_1.isTypeArray)(f), () => `
+			// ${f.name}
+			this.${(0, CSParseTool_1.convMemberName)(f.name)} = BitUtils.ToRawArray<${(0, CSParseTool_1.getFieldElementType)(f)}>(ref paras);
+`).else(() => `
+`)}
+`)}
+		}
+
+		public static IEnumerable<IMMPSerializable> AsSerializableEnumerable()
+		{
+			return Configs;
+		}
+	}
+}
+`;
+    return temp;
+}
+class ExportUnityMMPPlugin extends export_table_lib_1.PluginBase {
+    name = "mmp";
+    tags = ["mmp"];
+    handleSheet(paras) {
+        var fullName = `${paras.table.workbookName}-${paras.name}`;
+        {
+            let content1 = exportMMP(paras);
+            if (content1 != null) {
+                let savePath = new export_table_lib_1.OutFilePath(paras.outPath, fullName, "MMP.cs").fullPath;
+                (0, CSParseTool_1.outputFileSync)(savePath, content1, "utf-8");
+            }
+        }
+    }
+}
+exports.ExportUnityMMPPlugin = ExportUnityMMPPlugin;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ExportPlugin as ExportCSPlugin } from "./ExportCSPlugin";
+import { ExportLiteDBCSPlugin } from "./ExportLiteDBCSPlugin";
+import { ExportLiteDBUJsonPlugin } from "./ExportLiteDBUnityCSJsonPlugin";
+import { ExportUJsonPlugin } from "./ExportUnityCSJsonPlugin";
+import { ExportUnityMMPPlugin } from "./ExportUnityMMPPlugin";
+export declare const ExportPlugins: (ExportCSPlugin | ExportLiteDBCSPlugin | ExportUJsonPlugin | ExportLiteDBUJsonPlugin | ExportUnityMMPPlugin)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAE7D,eAAO,MAAM,aAAa,gHAMzB,CAAA"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportPlugins = void 0;
+const ExportCSPlugin_1 = require("./ExportCSPlugin");
+const ExportLiteDBCSPlugin_1 = require("./ExportLiteDBCSPlugin");
+const ExportLiteDBUnityCSJsonPlugin_1 = require("./ExportLiteDBUnityCSJsonPlugin");
+const ExportUnityCSJsonPlugin_1 = require("./ExportUnityCSJsonPlugin");
+const ExportUnityMMPPlugin_1 = require("./ExportUnityMMPPlugin");
+exports.ExportPlugins = [
+    new ExportCSPlugin_1.ExportPlugin(),
+    new ExportUnityCSJsonPlugin_1.ExportUJsonPlugin(),
+    new ExportLiteDBCSPlugin_1.ExportLiteDBCSPlugin(),
+    new ExportLiteDBUnityCSJsonPlugin_1.ExportLiteDBUJsonPlugin(),
+    new ExportUnityMMPPlugin_1.ExportUnityMMPPlugin(),
+];

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "export-table-plugin-csharp",
+  "version": "1.1.189",
+  "description": "",
+  "main": "./dist/index.js",
+  "scripts": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/windyuuy/export-table-plugin-csharp.git"
+  },
+  "author": "windyuuy",
+  "license": "ISC",
+  "dependencies": {
+    "@types/commander": "2.12.2",
+    "@types/node": "^17.0.18",
+    "export-table-lib": "^1.0.73",
+    "fs": "^0.0.1-security",
+    "fs-extra": "^10.0.0",
+    "fse": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13"
+  }
+}

package/res/mmp-cs/BitUtils.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace ExportedConfigs.MMPConvTool.Core
+{
+	public delegate T DeserializeMethod<T>(ref DeserializeParas paras);
+
+	public delegate void SerializeMethod<T>(ref SerializeParas paras, T value);
+
+	public delegate void FromValue<T>(IntPtr ptr, T value);
+
+	public delegate T ToValue<T>(IntPtr ptr);
+
+	public struct DeserializeParas
+	{
+		public byte[] Bytes;
+		private IntPtr _ptr;
+		public IntPtr Ptr => _ptr + Offset;
+		public int Offset;
+
+		public DeserializeParas(byte[] bytes)
+		{
+			IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(bytes, 0);
+
+			Bytes = bytes;
+			_ptr = ptr;
+			Offset = 0;
+		}
+	}
+
+	public struct SerializeParas
+	{
+		public byte[] Bytes;
+		private IntPtr _ptr;
+		public IntPtr Ptr => _ptr + Offset;
+		public int Offset;
+
+		public SerializeParas(byte[] bytes)
+		{
+			IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(bytes, 0);
+
+			Bytes = bytes;
+			_ptr = ptr;
+			Offset = 0;
+		}
+	}
+
+	public static class BitUtils
+	{
+		public static T[] ToArray<T>(ref DeserializeParas paras, DeserializeMethod<T> func)
+		{
+			var count = BitUtils.ToValue(ref paras, Marshal.ReadInt32);
+
+			var arr = new T[count];
+			for (var i = 0; i < count; i++)
+			{
+				arr[i] = func(ref paras);
+			}
+
+			return arr;
+		}
+
+		public static void ToArrayInternal<T>(ref DeserializeParas paras, ref T[] arr) where T : IMMPSerializable, new()
+		{
+			var count = BitUtils.ToValue(ref paras, Marshal.ReadInt32);
+
+			arr = new T[count];
+			for (var i = 0; i < count; i++)
+			{
+				var obj = new T();
+				obj.Deserialize(ref paras);
+				arr[i] = obj;
+			}
+		}
+
+		public static void FromArrayInternal<T>(ref SerializeParas paras, T[] arr) where T : IMMPSerializable
+		{
+			BitUtils.FromValue(ref paras, Marshal.WriteInt32, arr.Length);
+			foreach (var obj in arr)
+			{
+				obj.Serialize(ref paras);
+			}
+		}
+
+		public static void FromArray<T>(ref SerializeParas paras, T[] arr, SerializeMethod<T> func)
+		{
+			BitUtils.FromValue(ref paras, Marshal.WriteInt32, arr.Length);
+			foreach (var obj in arr)
+			{
+				func(ref paras, obj);
+			}
+		}
+
+		public static T[] ToRawArray<T>(ref DeserializeParas paras) where T : unmanaged
+		{
+			var len = BitUtils.ToValue(ref paras, Marshal.ReadInt32);
+
+			var arr = new T[len];
+			var ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0);
+			unsafe
+			{
+				var size = sizeof(T);
+				var byteLen = len * size;
+				Marshal.Copy(paras.Bytes, paras.Offset, ptr, byteLen);
+				paras.Offset += byteLen;
+			}
+
+			return arr;
+		}
+
+		public static void FromRawArray<T>(ref SerializeParas paras, T[] arr) where T : unmanaged
+		{
+			var arrLength = arr.Length;
+			BitUtils.FromValue(ref paras, Marshal.WriteInt32, arrLength);
+			var ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0);
+			unsafe
+			{
+				var size = sizeof(T);
+				var byteLength = arrLength * size;
+				Marshal.Copy(ptr, paras.Bytes, paras.Offset, byteLength);
+				paras.Offset += byteLength;
+			}
+		}
+
+		public static string ToString(ref DeserializeParas paras)
+		{
+			var len = BitUtils.ToValue(ref paras, Marshal.ReadInt32);
+			unsafe
+			{
+				var str = Marshal.PtrToStringUTF8(paras.Ptr, len);
+				paras.Offset += len;
+				return str;
+			}
+		}
+
+		public static void FromString(ref SerializeParas paras, string str)
+		{
+			var writeLen = Encoding.UTF8.GetBytes(str, 0, str.Length, paras.Bytes, paras.Offset + 4);
+			BitUtils.FromValue(ref paras, Marshal.WriteInt32, writeLen);
+
+			paras.Offset += writeLen;
+		}
+
+		public static T ToValue<T>(ref DeserializeParas paras, ToValue<T> conv) where T : unmanaged
+		{
+			var value = conv(paras.Ptr);
+			unsafe
+			{
+				paras.Offset += sizeof(T);
+			}
+
+			return value;
+		}
+
+		public static void FromValue<T>(ref SerializeParas paras, FromValue<T> conv, T value) where T : unmanaged
+		{
+			conv(paras.Ptr, value);
+			unsafe
+			{
+				paras.Offset += sizeof(T);
+			}
+		}
+	}
+
+	public interface IMMPSerializable
+	{
+		public void Serialize(ref SerializeParas paras);
+		public void Deserialize(ref DeserializeParas paras);
+	}
+}

package/res/mmp-cs/BitUtils.cs.meta

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

package/res/mmp-cs/WritableValueTuple.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Runtime.InteropServices;
+using ExportedConfigs.MMPConvTool.Core;
+
+#nullable disable
+namespace FaBao.ExportedConfigs
+{
+	[Serializable]
+	[StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]
+	public struct WritableValueTuple<T1, T2> : IMMPSerializable
+	{
+		public T1 Item1;
+		public T2 Item2;
+
+		private static int _typeSize = -1;
+
+		public static int GetTypeSize()
+		{
+			if (_typeSize >= 0)
+			{
+				return _typeSize;
+			}
+
+			_typeSize = Marshal.SizeOf<WritableValueTuple<T1, T2>>();
+			return _typeSize;
+		}
+
+		public void Deserialize(ref DeserializeParas paras)
+		{
+			this = Marshal.PtrToStructure<WritableValueTuple<T1, T2>>(paras.Ptr);
+			paras.Offset += GetTypeSize();
+		}
+
+		public void Serialize(ref SerializeParas paras)
+		{
+			Marshal.StructureToPtr(this, paras.Ptr, false);
+			paras.Offset += GetTypeSize();
+		}
+	}
+}

package/res/mmp-cs/WritableValueTuple.cs.meta

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