public void Load_Local(string rLocalAssetPath)
{
string rSkillListPath = rLocalAssetPath + "/SkillList.txt";
string rSkillListConfig = File.ReadAllText(rSkillListPath);
this.ActorSkills = new Dict <int, List <GPCSymbolObject> >();
JsonNode rJsonArray = JsonParser.Parse(rSkillListConfig);
for (int i = 0; i < rJsonArray.Count; i++)
{
int nSkillID = int.Parse(rJsonArray[i].Value);
string rSkillPath = rLocalAssetPath + "/" + nSkillID + ".txt";
string rSkillConfig = File.ReadAllText(rSkillPath);
var rParser = new GamePlayComponentParser(rSkillConfig);
var rSymbolObjs = rParser.Parser();
this.ActorSkills.Add(nSkillID, rSymbolObjs);
}
string rBinaryPath = UtilTool.PathCombine(rLocalAssetPath.Replace("Text", "Binary"), "SkillConfig.bytes");
using (var fs = new FileStream(rBinaryPath, FileMode.Create, FileAccess.ReadWrite))
{
using (var br = new BinaryWriter(fs))
{
//this.Serialize(br);
}
}
}
public static void SaveHistory(this ABVersion rVersion, string rOutPath)
{
if (rVersion == null)
{
return;
}
string rHistoryDateStr = string.Format("History/{0}", DateTime.Now.ToString("yyyyMMdd_HHmmss"));
string rVersionBinPath = UtilTool.PathCombine(rOutPath, rHistoryDateStr, ABVersion.ABVersion_File_Bin);
string rDirPath = Path.GetDirectoryName(rVersionBinPath);
if (!Directory.Exists(rDirPath))
{
Directory.CreateDirectory(rDirPath);
}
using (FileStream fs = new FileStream(rVersionBinPath, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
rVersion.Serialize(bw);
}
}
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
}
public void Analysis(string rGeneratePathRoot, string rDLLModuleName, System.Action <string, float> rProgressAction = null)
{
string rGeneratePath = rGeneratePathRoot;
string rCommonSerializerPath = rGeneratePath + "CommonSerializer.cs";
mClassSerializers = new List <CodeGenerator_ClassSerializer>();
mCommonSerializer = new CodeGenerator_CommonSerializer(rCommonSerializerPath);
mCommonSerializer.WriteHead();
var rSBTypes = SerializerBinaryTypes.Types;
for (int i = 0; i < rSBTypes.Count; i++)
{
if (!rSBTypes[i].Assembly.GetName().Name.Equals(rDLLModuleName))
{
continue;
}
var rGroupName = string.Empty;
var rAttributes = rSBTypes[i].GetCustomAttributes <SBGroupAttribute>(true);
if (rAttributes.Length > 0)
{
rGroupName = rAttributes[0].GroupName;
}
var rClassSerializer = new CodeGenerator_ClassSerializer(UtilTool.PathCombine(rGeneratePath, rGroupName, rSBTypes[i].FullName + ".Binary.cs"));
rClassSerializer.WriteHead();
rClassSerializer.WriteClass(rSBTypes[i]);
rClassSerializer.WriteEnd();
mClassSerializers.Add(rClassSerializer);
var rSerializeMemberInfo = SerializerAssists.FindSerializeMembers(rSBTypes[i]);
foreach (var rMemberInfo in rSerializeMemberInfo)
{
var bDynamic = rMemberInfo.IsDefined(typeof(SBDynamicAttribute), false);
if (rMemberInfo.MemberType == MemberTypes.Field)
{
mCommonSerializer.AnalyzeGenerateCommon((rMemberInfo as FieldInfo).FieldType, bDynamic);
}
else if (rMemberInfo.MemberType == MemberTypes.Property)
{
mCommonSerializer.AnalyzeGenerateCommon((rMemberInfo as PropertyInfo).PropertyType, bDynamic);
}
}
UtilTool.SafeExecute(rProgressAction, $"Generate File: {rSBTypes[i].FullName}", (float)i / (float)rSBTypes.Count);
rClassSerializer.Save();
}
mCommonSerializer.WriteEnd();
mCommonSerializer.Save();
}
public void LoadLocal(string rLocalAssetPath)
{
var rMemberInfos = this.GetType().GetMembers();
foreach (var rMemberInfo in rMemberInfos)
{
if ((rMemberInfo.MemberType != MemberTypes.Field && rMemberInfo.MemberType != MemberTypes.Property))
{
continue;
}
if (!rMemberInfo.IsApplyAttr(typeof(ConfigPathAttribute), false))
{
continue;
}
var rConfigPathAttr = rMemberInfo.GetCustomAttribute <ConfigPathAttribute>(false);
if (rConfigPathAttr == null)
{
continue;
}
string rAssetPath = UtilTool.PathCombine(rLocalAssetPath, rConfigPathAttr.AssetName);
string rJsonText = File.ReadAllText(rAssetPath);
JsonNode rJsonNode = JsonParser.Parse(rJsonText);
if (rMemberInfo.MemberType == MemberTypes.Field)
{
FieldInfo rFieldInfo = rMemberInfo.DeclaringType.GetField(rMemberInfo.Name);
object rValue = rJsonNode.ToObject(rFieldInfo.FieldType);
rFieldInfo.SetValue(this, rValue);
}
else if (rMemberInfo.MemberType == MemberTypes.Property)
{
PropertyInfo rPropInfo = rMemberInfo.DeclaringType.GetProperty(rMemberInfo.Name);
object rValue = rJsonNode.ToObject(rPropInfo.PropertyType);
rPropInfo.SetValue(this, rValue, null);
}
}
string rBinaryPath = UtilTool.PathCombine(rLocalAssetPath.Replace("Text", "Binary"), "GameConfig.bytes");
using (var fs = new FileStream(rBinaryPath, FileMode.Create, FileAccess.ReadWrite))
{
using (var br = new BinaryWriter(fs))
{
this.Serialize(br);
}
}
}
public static void SaveIncrement(this ABVersion rVersion, string rABPath, string rTargetPath)
{
if (rVersion == null)
{
return;
}
// 保存增量版本文件
string rTargetVersionBinPath = UtilTool.PathCombine(rTargetPath, ABVersion.ABVersion_File_Bin);
using (FileStream fs = new FileStream(rTargetVersionBinPath, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
rVersion.Serialize(bw);
}
}
// 复制增量AB包
foreach (var rVersionPair in rVersion.Entries)
{
var rAVEntry = rVersionPair.Value;
string rSrcABPath = UtilTool.PathCombine(rABPath, rAVEntry.Name);
string rDistABPath = UtilTool.PathCombine(rTargetPath, rAVEntry.Name);
string rDistDir = Path.GetDirectoryName(rDistABPath);
if (!Directory.Exists(rDistDir))
{
Directory.CreateDirectory(rDistDir);
}
File.Copy(rSrcABPath, rDistABPath, true);
}
// 复制MD5文件
string rSrcMD5Path = UtilTool.PathCombine(rABPath, ABVersion.ABVersion_File_MD5);
string rDistMD5Path = UtilTool.PathCombine(rTargetPath, ABVersion.ABVersion_File_MD5);
string rDistMD5Dir = Path.GetDirectoryName(rDistMD5Path);
if (!Directory.Exists(rDistMD5Dir))
{
Directory.CreateDirectory(rDistMD5Dir);
}
File.Copy(rSrcMD5Path, rDistMD5Path, true);
}
public void Analysis(System.Action <string, float> rProgressAction = null)
{
mClassSerializers = new List <HotfixCodeGenerator_ClassSerializer>();
mCommonSerializer = new HotfixCodeGenerator_CommonSerializer(mCommonSerializerPath);
mCommonSerializer.WriteHead();
var rSBTypes = HotfixSerializerBinaryTypes.Types;
for (int i = 0; i < rSBTypes.Count; i++)
{
var rGroupName = string.Empty;
var rAttributes = new List <HotfixSBGroupAttribute>();
rAttributes.AddRange(rSBTypes[i].GetCustomAttributes <HotfixSBGroupAttribute>(true));
if (rAttributes.Count > 0)
{
rGroupName = rAttributes[0].GroupName;
}
var rClassSerializer = new HotfixCodeGenerator_ClassSerializer(UtilTool.PathCombine(mGeneratePath, rGroupName, rSBTypes[i].FullName + ".Binary.cs"));
rClassSerializer.WriteHead();
rClassSerializer.WriteClass(rSBTypes[i]);
rClassSerializer.WriteEnd();
mClassSerializers.Add(rClassSerializer);
var rSerializeMemberInfo = HotfixSerializerAssists.FindSerializeMembers(rSBTypes[i]);
foreach (var rMemberInfo in rSerializeMemberInfo)
{
var bDynamic = rMemberInfo.IsDefined(typeof(HotfixSBDynamicAttribute), false);
if (rMemberInfo.MemberType == MemberTypes.Field)
{
mCommonSerializer.AnalyzeGenerateCommon((rMemberInfo as FieldInfo).FieldType, bDynamic);
}
else if (rMemberInfo.MemberType == MemberTypes.Property)
{
mCommonSerializer.AnalyzeGenerateCommon((rMemberInfo as PropertyInfo).PropertyType, bDynamic);
}
}
UtilTool.SafeExecute(rProgressAction, $"Generate File: {rSBTypes[i].FullName}", (float)i / (float)rSBTypes.Count);
rClassSerializer.Save();
}
mCommonSerializer.WriteEnd();
mCommonSerializer.Save();
this.GenCsproj();
}
public void Initialize(string rOutPath)
{
mEntries = new Dict <string, Entry>();
string rHistoryPath = UtilTool.PathCombine(rOutPath, "History");
DirectoryInfo rHistoryDirInfo = new DirectoryInfo(rHistoryPath);
if (!rHistoryDirInfo.Exists)
{
return;
}
ABVersion rCurVersion = ABVersionEditor.Load(rOutPath);
var rSubDirs = rHistoryDirInfo.GetDirectories();
for (int i = 0; i < rSubDirs.Length; i++)
{
Entry rEntry = new Entry();
rEntry.Path = UtilTool.PathCombine(rHistoryPath, rSubDirs[i].Name, ABVersion.ABVersion_File_Bin);
rEntry.Time = rSubDirs[i].Name;
rEntry.IncVer = new ABVersion();
rEntry.IncVer.Entries = new Dict <string, ABVersionEntry>();
ABVersion rHistoryVersion = ABVersionEditor.Load(rSubDirs[i].FullName);
// 比较两个版本
foreach (var rPair in rCurVersion.Entries)
{
var rAVEntry = rPair.Value;
var rOldEntry = rHistoryVersion.GetEntry(rAVEntry.Name);
if (rOldEntry == null) // 说明是新增的
{
rEntry.IncVer.Entries.Add(rAVEntry.Name, rAVEntry);
}
else
{
if (rOldEntry.Version != rAVEntry.Version) // 版本不一致
{
rEntry.IncVer.Entries.Add(rAVEntry.Name, rAVEntry);
}
}
}
mEntries.Add(rEntry.Time, rEntry);
}
}
public override void CSGenerateProcess(CSGenerate rGenerate)
{
StartGenerateCommon();
foreach (var rType in SerializerBinaryTypes.Types)
{
var rText = new StringBuilder();
rText
.A("using System.IO;").N()
.A("using Core;").N()
.A("using Core.Serializer;").N()
.A("using Game.Serializer;").N()
.L(2)
.A("/// <summary>").N()
.A("/// 文件自动生成无需又该！如果出现编译错误，删除文件后会自动生成").N()
.A("/// </summary>").N();
if (!string.IsNullOrEmpty(rType.Namespace))
{
rText
.F("namespace {0}", rType.Namespace).N()
.A("{").N();
}
rText
.F("public partial class {0}", rType.Name).N()
.A("{").N();
var rSerializeMemberInfo = SearchSerializeMember(rType);
// Serialize Function
rText
.T(1).A("public override void Serialize(BinaryWriter rWriter)").N()
.T(1).A("{").N()
.T(2).A("base.Serialize(rWriter);").N();
foreach (var rMemberInfo in rSerializeMemberInfo)
{
var rParamText = GenerateClassMemberDummyText(rMemberInfo);
if (rMemberInfo.IsDefined(typeof(SBDynamicAttribute), true) && !IsBaseType(GetMemberType(rMemberInfo), false))
{
rText.T(2).F("rWriter.SerializeDynamic({0});", rParamText).N();
}
else
{
rText.T(2).F("rWriter.Serialize({0});", rParamText).N();
}
}
rText
.T(1).A("}").N();
// Deserialize Function
rText
.T(1).A("public override void Deserialize(BinaryReader rReader)").N()
.T(1).A("{").N()
.T(2).A("base.Deserialize(rReader);").N();
foreach (var rMemberInfo in rSerializeMemberInfo)
{
if (rMemberInfo.IsDefined(typeof(SBDynamicAttribute), false) && !IsBaseType(GetMemberType(rMemberInfo), false))
{
rText.T(2).F("this.{0} = {1}rReader.DeserializeDynamic({2});", rMemberInfo.Name,
GenerateClassMemberTypeText(rMemberInfo),
GenerateClassMemberDummyText(rMemberInfo)).N();
}
else
{
rText.T(2).F("this.{0} = {1}rReader.Deserialize({2});", rMemberInfo.Name,
GenerateClassMemberTypeText(rMemberInfo),
GenerateClassMemberDummyText(rMemberInfo)).N();
}
}
rText
.T(1).A("}").N();
rText.A("}").N();
if (!string.IsNullOrEmpty(rType.Namespace))
{
rText.A("}").N();
}
var rGroupName = string.Empty;
var rAttributes = rType.GetCustomAttributes <SBGroupAttribute>(true);
if (rAttributes.Length > 0)
{
rGroupName = rAttributes[0].GroupName;
}
rGenerate.Add(rText.ToString(), UtilTool.PathCombine(GeneratePath, rGroupName, rType.FullName + ".Binary.cs"));
foreach (var rMemberInfo in rSerializeMemberInfo)
{
var bDynamic = rMemberInfo.IsDefined(typeof(SBDynamicAttribute), false);
if (rMemberInfo.MemberType == MemberTypes.Field)
{
AnalyzeGenerateCommon((rMemberInfo as FieldInfo).FieldType, bDynamic);
}
else if (rMemberInfo.MemberType == MemberTypes.Property)
{
AnalyzeGenerateCommon((rMemberInfo as PropertyInfo).PropertyType, bDynamic);
}
}
}
EndGenerateCommon();
rGenerate.AddHead(mCommonSerializer.ToString(), CommonSerializerPath);
}
/// <summary>
/// 得到Persistent空间下的Url路径
/// </summary>
public string GetPersistentUrl(Platform rPlatform)
{
int rPlatformIndex = (int)rPlatform;
return(PlatformPrefixs[rPlatformIndex] + UtilTool.PathCombine(Application.persistentDataPath, PlatformNames[rPlatformIndex] + "_Assetbundles") + "/");
}
/// <summary>
/// 导出Excel
/// </summary>
public void Export(ExcelFormat rExcelFormat)
{
string rConfigFile = UtilTool.PathCombine(this.ExcelConfigRootPath, "Excel", rExcelFormat.ExcelName);
string rExportDir = UtilTool.PathCombine(this.ExcelConfigRootPath, "Text");
FileStream rStream = File.Open(rConfigFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
IExcelDataReader rExcelReader = ExcelReaderFactory.CreateOpenXmlReader(rStream);
DataSet rResult = rExcelReader.AsDataSet();
DataTable rDataTable = rResult.Tables[rExcelFormat.SheetName];
if (rDataTable == null)
{
Debug.LogErrorFormat("Excel {0} has not sheet {1}.", rExcelFormat.ExcelName, rExcelFormat.SheetName);
rExcelReader.Close();
rStream.Close();
return;
}
int rColumns = rDataTable.Columns.Count;
int rRows = rDataTable.Rows.Count;
if (rRows == 0)
{
Debug.LogErrorFormat("Excel {0} has empty rows.", rExcelFormat.ExcelName);
rExcelReader.Close();
rStream.Close();
return;
}
Type rDataType = MainAssemblyExpand.GetType(rExcelFormat.ClassName);
if (rDataType == null)
{
Debug.LogErrorFormat("Excel {0} can not find Class {1}, please check it.", rExcelFormat.ExcelName, rExcelFormat.ClassName);
rExcelReader.Close();
rStream.Close();
return;
}
var rTitleRow = rDataTable.Rows[0];
var rFields = new Dict <string, FieldInfo>();
var rKeyIDs = new Dict <string, int>();
for (int i = 0; i < rColumns; i++)
{
FieldInfo rFileInfo = rDataType.GetField(rTitleRow[i].ToString());
rFields.Add(rTitleRow[i].ToString(), rFileInfo);
rKeyIDs.Add(rTitleRow[i].ToString(), i);
}
JsonNode rDataJson = new JsonClass();
for (int i = 1; i < rRows; i++)
{
JsonNode rItemJson = new JsonClass();
foreach (var rPair in rFields)
{
string rFieldValue = rDataTable.Rows[i][rKeyIDs[rPair.Key]].ToString();
JsonParser rJsonParser = new JsonParser(rFieldValue);
JsonNode rTempNode = null;
try {
rTempNode = rJsonParser.Parser();
}
catch (Exception) {
rJsonParser.isValid = false;
}
if (!rJsonParser.isValid)
{
rTempNode = new JsonData(rFieldValue);
}
rItemJson.Add(rPair.Key, rTempNode);
}
rDataJson.Add(rDataTable.Rows[i][rKeyIDs[rExcelFormat.PrimaryKey]].ToString(), rItemJson);
}
File.WriteAllText(UtilTool.PathCombine(rExportDir, rExcelFormat.SheetName + ".json"), rDataJson.ToString());
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
rExcelReader.Close();
rStream.Close();
}
