internal static bool GenerateMetadataEntityScripts()
{
var result = false;
var settings = MetadataAssetSettings.Load();
MetadataAssetSettings.CreateEntityScriptsStoreFolder(settings);
if (string.IsNullOrEmpty(settings.ExcelWorkbookFilesFolderPath))
{
if (UnityEditorUtility.DisplayDialog("Error", "'Excel Workbook Files Folder Path' is not valid path!", "OK"))
{
UnityEditorUtility.ClearProgressBar();
}
}
else
{
ForEachExcelFile(settings.ExcelWorkbookFilesFolderPath, (table, fileName, index, length) =>
{
if (table == null)
{
return;
}
var info = $"Generating Metadata Entity Script: {fileName}.cs... {index + 1}/{length}";
var progress = (float)(index + 1) / length;
UnityEditorUtility.DisplayProgressBar("Hold on...", info, progress);
var rawInfoList = CreateMetadataEntityRawInfoList(settings, table);
result = GenerateMetadataEntityScript(settings, fileName, rawInfoList);
});
}
UnityEditorUtility.ClearProgressBar();
return(result);
}
private static Type GetEntityClassType(MetadataAssetSettings settings, string entityClassName)
{
var scriptAssetPath = PathUtility.UnifyToAltDirectorySeparatorChar(Path.Combine(settings.EntityScriptsStorePath, $"{entityClassName}.cs"));
var scriptObject = AssetDatabase.LoadAssetAtPath <MonoScript>(scriptAssetPath);
return(scriptObject ? scriptObject.GetClass() : null);
}
private static void EncryptFileRawData(string filePath)
{
var settings = MetadataAssetSettings.Load();
var rawData = File.ReadAllBytes(filePath);
var dataEncryptionFlag = BitConverter.GetBytes(settings.DataEncryptionAndDecryption);
using var writer = new BinaryWriter(new MemoryStream());
// Write flag to judge if data need to decryption
writer.Write(dataEncryptionFlag);
if (settings.DataEncryptionAndDecryption)
{
// Write key and cipher data
var key = CryptoUtility.GenerateRandomKey(MetadataManager.EncryptionKeyLength);
var cipherData = CryptoUtility.AesEncrypt(rawData, key);
writer.Write(key);
writer.Write(cipherData);
}
else
{
// Write raw data
writer.Write(rawData);
}
var bufferData = ((MemoryStream)writer.BaseStream).GetBuffer();
File.WriteAllBytes(filePath, bufferData);
}
private static List <MetadataEntity> CreateEntityDataList(MetadataAssetSettings settings, DataTable table, Type entityClassType, List <MetadataEntityRawInfo> rawInfoList)
{
var list = new List <MetadataEntity>();
var rowCount = table.Rows.Count;
for (var i = settings.EntityDataStartingRowIndex; i < rowCount; ++i)
{
var entityData = (MetadataEntity)entityClassType.InvokeConstructor();
for (int j = 0, propertiesCount = rawInfoList.Count; j < propertiesCount; ++j)
{
var cellValue = table.Rows[i][j].ToString();
var rowInfo = rawInfoList[j];
var typeParser = PropertyTypeConverterFactory.GetTypeConverter(rowInfo.PropertyType, rowInfo.PropertyName);
if (typeParser != null)
{
var value = typeParser.Parse(cellValue.Trim(), rowInfo.Parameters);
entityData.SetPropertyValue(rowInfo.PropertyName, value);
}
else
{
UnityDebug.LogWarningFormat("Type '{0}' is not supported!", rowInfo.PropertyType);
}
}
list.Add(entityData);
}
return(list);
}
private static List <MetadataEntityRawInfo> CreateMetadataEntityRawInfoList(MetadataAssetSettings settings, DataTable table)
{
var columns = table.Columns;
var rows = table.Rows;
var columnCount = columns.Count;
var list = new List <MetadataEntityRawInfo>();
for (var i = 0; i < columnCount; i++)
{
var propertyName = rows[settings.EntityPropertyNameRowIndex][i].ToString();
var propertyType = rows[settings.EntityPropertyTypeRowIndex][i].ToString();
var comment = rows[settings.EntityPropertyCommentRowIndex][i].ToString();
if (string.IsNullOrEmpty(propertyName) || string.IsNullOrEmpty(propertyType))
{
continue;
}
propertyName = propertyName.Trim().ToTitleCase();
propertyType = propertyType.Trim().ToLower();
comment = FormatCommentString(comment.Trim());
object[] arguments = null;
if (propertyType.Equals("enum"))
{
arguments = new object[3];
arguments[0] = propertyName;
arguments[1] = $"{propertyName}Enum";
var enumValues = new List <string> {
"None"
};
for (var j = settings.EntityDataStartingRowIndex; j < rows.Count; j++)
{
var enumValue = rows[j][i].ToString().Trim();
if (!string.IsNullOrEmpty(enumValue))
{
enumValues.AddUnique(enumValue);
}
}
arguments[2] = enumValues.ToArray();
propertyName = $"{propertyName}IntValue";
}
list.Add(new MetadataEntityRawInfo(comment, propertyType, propertyName, arguments));
}
return(list);
}
protected virtual void DrawGUIWithoutSettings()
{
GUILayout.Space(50);
if (GUILayout.Button("Create Metadata Settings"))
{
settings = MetadataAssetSettings.Create();
}
GUILayout.Space(20);
GUILayout.BeginHorizontal();
GUILayout.Space(50);
GUI.skin.label.wordWrap = true;
GUILayout.Label("Click the \"Create\" button above to start using Metadata. Once you begin, the Metadata system will save some assets to your project to keep up with its data");
GUILayout.Space(50);
GUILayout.EndHorizontal();
}
internal static bool CreateMetadataDatabaseFiles()
{
var result = false;
var settings = MetadataAssetSettings.Load();
MetadataAssetSettings.CreateMetadataPersistentStoreFolder(settings);
DeleteTempDbFiles();
var dbFolderPath = EditorPath.ConvertToAbsolutePath(settings.MetadataPersistentStorePath);
ForEachExcelFile(settings.ExcelWorkbookFilesFolderPath, (table, fileName, index, length) =>
{
if (table == null)
{
return;
}
var entityClassName = fileName.ToTitleCase();
var info = $"Creating Database File for Entity {entityClassName}... {index + 1}/{length}";
var progress = (float)(index + 1) / length;
UnityEditorUtility.DisplayProgressBar("Hold on...", info, progress);
var rawInfoList = CreateMetadataEntityRawInfoList(settings, table);
var entityClassType = GetEntityClassType(settings, entityClassName);
if (entityClassType != null)
{
var entityDataList = CreateEntityDataList(settings, table, entityClassType, rawInfoList);
typeof(MetadataAssetUtility).InvokeGenericStaticMethod("InsertEntityData", new[] { entityClassType }, new object[] { dbFolderPath, entityClassName, rawInfoList, entityDataList, index });
result = true;
}
else
{
UnityDebug.LogErrorFormat(null, "Can not find the entity class: {0}.cs!", entityClassName);
result = false;
}
});
// Copy MetadataEntityDBConfig database file.
if (result)
{
CopyDatabaseFile(dbFolderPath, MetadataEntityDBConfig.DatabaseLocalAddress);
}
UnityEditorUtility.ClearProgressBar();
return(result);
}
private static bool GenerateMetadataEntityScript(MetadataAssetSettings settings, string entityScriptName, List <MetadataEntityRawInfo> rawInfoList)
{
try
{
entityScriptName = entityScriptName.ToTitleCase();
var scriptTextContent = ScriptTemplate.LoadScriptTemplateFile("NewMetadataEntityScriptTemplate.txt", UnityPackageName);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.Namespace, settings.EntityScriptNamespace);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.ScriptName, entityScriptName);
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.EnumInsideOfClass, GenerateEntityScriptEnumString(rawInfoList));
scriptTextContent = scriptTextContent.Replace(ScriptTemplate.Placeholders.Properties, GenerateEntityScriptPropertiesString(rawInfoList));
var scriptStorePath = EditorPath.ConvertToAbsolutePath(settings.EntityScriptsStorePath, $"{entityScriptName}.cs");
var assetPath = EditorPath.ConvertToAssetPath(scriptStorePath);
File.WriteAllText(scriptStorePath, scriptTextContent, new UTF8Encoding(true));
AssetDatabase.ImportAsset(assetPath);
return(true);
}
catch (Exception ex)
{
UnityDebug.LogError(ex.ToString());
return(false);
}
}
internal MetadataImporter(MetadataAssetSettings settings)
{
this.settings = settings;
}
