export-table-plugin-csharp 1.1.189

package/src/ExportLiteDBUnityCSJsonPlugin.ts

@@ -0,0 +1,175 @@
+
+import { cmm, HandleSheetParams, Field, foreach, IPlugin, st, PluginBase, HandleBatchParams, OutFilePath, makeFirstLetterUpper } from "export-table-lib"
+import * as fs from "fs-extra"
+import { GetUsingJsonToolNamespace, TryConvValue, convMemberName, firstLetterUpper, outputFileSync } from "./CSParseTool";
+import path from "path";
+import * as cp from "child_process"
+import { exportUJson } from "./ExportUnityCSJsonPlugin";
+
+var isSkipIndexLoader0 = process.argv.findIndex(v => v == "--SkipIndexLoader") >= 0
+
+export function exportUJsonLoader(paras: HandleSheetParams): string | null {
+	let {
+		datas,
+		fields,
+		name,
+		objects,
+		table,
+		exportNamespace,
+	} = paras;
+
+	let useJsonToolNamesapce = GetUsingJsonToolNamespace()
+
+	let RowClass = firstLetterUpper(name)
+	var fullName = `${table.workbookName}-${name}`
+	// !!!必须开头没有空格
+	let temp = `
+using System.Threading.Tasks;
+using LiteDB;
+using UnityEngine;
+${useJsonToolNamesapce}
+
+namespace ${exportNamespace}
+{
+	public partial class ${RowClass}
+	{
+		protected static LiteDatabase Database;
+		protected static ILiteCollection<${RowClass}> Collection;
+		public const string CollKey = "${fullName.replace("-", "_")}";
+		public static Task Load()
+		{
+#if UNITY_EDITOR && ENABLE_CONFIG_LOG
+			Debug.Log("ReferConfig-${RowClass}");
+#endif
+			var key = CollKey;
+			var ldb = SharedLiteDB.Database;
+			Database = ldb;
+			if (!ldb.CollectionExists(key))
+			{
+				Debug.LogError($"配表资源缺失: {key}");
+			}
+			Collection = ldb.GetCollection<${RowClass}>(key);
+
+			return Task.CompletedTask;
+		}
+	}
+}
+`
+	return temp
+
+}
+
+export async function RemoveJsonFiles(savePaths2: string[]) {
+	let deleteTasks = savePaths2.map(async (savePath2) => {
+		console.log(`delete file: ${savePath2}`)
+		try {
+			if (fs.existsSync(savePath2)) {
+				fs.removeSync(savePath2);
+			}
+		} catch (ex) {
+			console.error(`error: cannot delete file ${savePath2}`);
+			console.error(ex);
+		}
+	})
+
+	await Promise.all(deleteTasks)
+}
+export async function ConvJson2LiteDB(litedbpath: string, savePaths: string[]) {
+	if (litedbpath != null && litedbpath != "") {
+		let modulePath = require.resolve(".")
+		let binPath = path.resolve(modulePath, "../../bin/Json2LiteDB.exe")
+		// let dbPath = path.resolve("../../../GameClient/Assets/Bundles/GameConfigs/Auto/MainConfig.db.bytes");
+		// let dbPath = path.resolve(litedbpath)
+		let savePaths2 = savePaths.map(savePath => path.resolve(savePath))
+		let cmdParas = savePaths2.concat();
+		cmdParas.unshift(litedbpath);
+		let cmdParasLine = cmdParas.join(" ");
+		let cmdline = `${binPath} ${cmdParasLine}`;
+		console.log("execute-cmdline: " + cmdline)
+		var output = cp.spawnSync(binPath, cmdParas)
+		console.log(output.output.toString())
+
+		RemoveJsonFiles(savePaths2)
+	} else {
+		console.log(`no litedbpath given, skip conv database`)
+	}
+}
+
+export class ExportLiteDBUJsonPlugin extends PluginBase {
+	name = "litedbujson"
+	tags: string[] = ["litedbujson"]
+
+	handleSheet(paras: HandleSheetParams) {
+		var fullName = `${paras.table.workbookName}-${paras.name}`
+		{
+			let content1 = exportUJsonLoader(paras)
+			if (content1 != null) {
+				let savePath = new OutFilePath(paras.outPath, fullName, "Loader.cs").fullPath
+				outputFileSync(savePath, content1, "utf-8")
+			}
+		}
+		{
+			let content2 = exportUJson(paras)
+			if (content2 != null) {
+				let savePath = new OutFilePath(paras.outPath, fullName, ".json").fullPath
+				outputFileSync(savePath, content2, "utf-8")
+			}
+
+			return content2
+		}
+	}
+
+	async handleBatch(paras: HandleBatchParams) {
+
+		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(){
+${foreach(tables.sort((ta, tb) => ta.name.localeCompare(tb.name)), (table) => `
+			yield return ${firstLetterUpper(table.name)}.Load;
+`)}
+			yield break;
+		}
+	}
+}
+`
+		let savePath = paras.outPath + "/DefaultConfigLoader.cs";
+		outputFileSync(savePath, temp, "utf-8");
+
+		// var options = new program.Command().option("--litedbpath <string>").parse(process.argv).allowUnknownOption(true).opts()
+		// let litedbpath = options["litedbpath"]
+		let litedbpathIndex = process.argv.indexOf("--litedbpath")
+		let litedbpath: string = "";
+		if (litedbpathIndex >= 0) {
+			litedbpath = process.argv[litedbpathIndex + 1]
+		}
+		console.log(`litedbpath: ${litedbpath}`);
+
+		let cmdParas = tables.map(table => {
+			var fullName = `${table.workbookName}-${table.name}`
+			let savePath = new OutFilePath(paras.outPath, fullName, ".json").fullPath
+			return savePath
+		})
+
+		await ConvJson2LiteDB(litedbpath, cmdParas);
+
+	}
+}

package/src/ExportUnityCSJsonPlugin.ts

@@ -0,0 +1,297 @@
+
+import { cmm, HandleSheetParams, Field, foreach, IPlugin, st, PluginBase, HandleBatchParams, OutFilePath, makeFirstLetterUpper } from "export-table-lib"
+import * as fs from "fs-extra"
+import { GetUsingJsonToolNamespace, TryConvValue, convMemberName, genTupleArrayValue, isEnableMMP, outputFileSync } from "./CSParseTool";
+
+var isSkipIndexLoader0 = process.argv.findIndex(v => v == "--SkipIndexLoader") >= 0
+var isWrapObject = process.argv.findIndex(v => v == "--WrapObject") >= 0
+
+let firstLetterUpper = makeFirstLetterUpper;
+export function exportUJson(paras: HandleSheetParams): string | null {
+	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 = convMemberName(key);
+			newObj[newKey] = obj[key];
+
+			let content = obj[key]
+			let result = 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
+
+}
+
+export function exportUJsonLoader(paras: HandleSheetParams): string | null {
+	let {
+		datas,
+		fields,
+		name,
+		objects,
+		table,
+		exportNamespace,
+		allTags,
+	} = paras;
+
+	let useJsonToolNamesapce = GetUsingJsonToolNamespace()
+
+	let RowClass = firstLetterUpper(name)
+	let fullName = `${table.workbookName}-${name}`
+
+	let isMMP = 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
+
+}
+
+export class ExportUJsonPlugin extends PluginBase {
+	name = "ujson"
+	tags: string[] = ["ujson"]
+
+	handleSheet(paras: HandleSheetParams) {
+		var fullName = `${paras.table.workbookName}-${paras.name}`
+		{
+			let content1 = exportUJsonLoader(paras)
+			if (content1 != null) {
+				let savePath = new OutFilePath(paras.outPath, fullName, "Loader.cs").fullPath
+				outputFileSync(savePath, content1, "utf-8")
+			}
+		}
+		{
+			let content2 = exportUJson(paras)
+			if (content2 != null) {
+				let savePath = new OutFilePath(paras.outPath, fullName, ".json").fullPath
+				outputFileSync(savePath, content2, "utf-8")
+			}
+			return content2
+		}
+	}
+
+	handleBatch(paras: HandleBatchParams): void {
+
+		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(){
+${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(){
+${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";
+		outputFileSync(savePath, temp, "utf-8");
+	}
+}

package/src/ExportUnityMMPPlugin.ts

@@ -0,0 +1,127 @@
+
+import { cmm, HandleSheetParams, Field, foreach, IPlugin, st, PluginBase, HandleBatchParams, OutFilePath, makeFirstLetterUpper, iff } from "export-table-lib"
+import * as fs from "fs-extra"
+import { convMemberName, convVarName, getFieldElementType, getFieldType, isTypeArray, outputFileSync, useMMPNamespace } from "./CSParseTool";
+
+var isEnableMMPB = process.argv.findIndex(v => v == "--EnableMMPB") >= 0
+
+let firstLetterUpper = makeFirstLetterUpper;
+
+export function exportMMP(paras: HandleSheetParams): string | null {
+	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;
+${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)
+		{
+${foreach(fields, f => `
+${iff(f.type == "string[]", () => `
+			var ${convVarName(f.name)} = this.${convMemberName(f.name)}; this.${convMemberName(f.name)} = null;
+`)}
+`)}
+			Marshal.StructureToPtr(this, paras.Ptr, false);
+${foreach(fields, f => `
+${iff(f.type == "string[]", () => `
+			this.${convMemberName(f.name)} = ${convVarName(f.name)};
+`)}
+`)}
+			paras.Offset += GetTypeSize();
+${foreach(fields, f => `
+${iff(f.type == "string", () => `
+			// ${f.name}
+			BitUtils.FromString(ref paras, this.${convMemberName(f.name)});
+${iff(f.rawType.startsWith("@") && f.rawType.endsWith("[]"), () => `
+			BitUtils.FromSArray(ref paras, this.${convMemberName(f.name)}Obj);
+`)}
+`).elseif(f.type == "string[]", () => `
+			// ${f.name}
+			BitUtils.FromArray(ref paras, this.${convMemberName(f.name)}, BitUtils.FromString);
+`).elseif(isTypeArray(f), () => `
+			// ${f.name}
+			BitUtils.FromRawArray(ref paras, this.${convMemberName(f.name)});
+`).else(() => `
+`)}
+`, "\n")}
+		}
+
+		public void Deserialize(ref DeserializeParas paras)
+		{
+			Marshal.PtrToStructure(paras.Ptr, this);
+			paras.Offset += GetTypeSize();
+${foreach(fields, f => `
+${iff(f.type == "string", () => `
+			// ${f.name}
+			this.${convMemberName(f.name)} = BitUtils.ToString(ref paras);
+${iff(f.rawType.startsWith("@") && f.rawType.endsWith("[]"), () => `
+			BitUtils.ToSArray(ref paras, ref this.${convMemberName(f.name)}Obj);
+`)}
+`).elseif(f.type == "string[]", () => `
+			// ${f.name}
+			this.${convMemberName(f.name)} = BitUtils.ToArray(ref paras, BitUtils.ToString);
+`).elseif(isTypeArray(f), () => `
+			// ${f.name}
+			this.${convMemberName(f.name)} = BitUtils.ToRawArray<${getFieldElementType(f)}>(ref paras);
+`).else(() => `
+`)}
+`)}
+		}
+
+		public static IEnumerable<IMMPSerializable> AsSerializableEnumerable()
+		{
+			return Configs;
+		}
+	}
+}
+`
+	return temp
+
+}
+
+export class ExportUnityMMPPlugin extends PluginBase {
+	name = "mmp"
+	tags: string[] = ["mmp"]
+
+	handleSheet(paras: HandleSheetParams) {
+		var fullName = `${paras.table.workbookName}-${paras.name}`
+		{
+			let content1 = exportMMP(paras)
+			if (content1 != null) {
+				let savePath = new OutFilePath(paras.outPath, fullName, "MMP.cs").fullPath
+				outputFileSync(savePath, content1, "utf-8")
+			}
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+
+import { ExportPlugin as ExportCSPlugin } from "./ExportCSPlugin"
+import { ExportLiteDBCSPlugin } from "./ExportLiteDBCSPlugin"
+import { ExportLiteDBUJsonPlugin } from "./ExportLiteDBUnityCSJsonPlugin"
+import { ExportUJsonPlugin } from "./ExportUnityCSJsonPlugin"
+import { ExportUnityMMPPlugin } from "./ExportUnityMMPPlugin"
+
+export const ExportPlugins = [
+	new ExportCSPlugin(),
+	new ExportUJsonPlugin(),
+	new ExportLiteDBCSPlugin(),
+	new ExportLiteDBUJsonPlugin(),
+	new ExportUnityMMPPlugin(),
+]

package/test/testCS.bat

@@ -0,0 +1 @@
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:cs --libs E:\DATA\Projects\netease\quicktable %*

package/test/testCSWithProto.bat

@@ -0,0 +1 @@
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:cs --libs E:\DATA\Projects\netease\quicktable --WithProto src/wasmproto.proto --scenes client %*

package/test/testLiteDB.bat

@@ -0,0 +1,2 @@
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:litedbcs --libs E:\DATA\Projects\netease\quicktable %*
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:litedbujson --libs E:\DATA\Projects\netease\quicktable --litedbpath ./dist/MainConfig.db.bytes %*

package/test/testUJson.bat

@@ -0,0 +1,2 @@
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:mmp;csharp:cs --libs E:\DATA\Projects\netease\quicktable %*
+node E:\DATA\Projects\netease\quicktable\export-table\dist\launch.js export src dist --tags csharp:ujson --EnableMMPB --libs E:\DATA\Projects\netease\quicktable %*