public LevelRulesEditor(FileManager fileManager, PackFileEntry fileEntry)
{
InitializeComponent();
DoubleBuffered = true;
_fileManager = fileManager;
byte[] fileBytes = fileManager.GetFileBytes(fileEntry);
_levelRules = new LevelRulesFile(fileEntry.Path, null);
_levelRules.ParseFileBytes(fileBytes);
foreach (LevelRulesFile.LevelRule levelRule in _levelRules.LevelRules)
{
if (levelRule.StaticRooms != null)
{
_LoadRooms(levelRule.StaticRooms, fileEntry.Path);
}
else
{
foreach (LevelRulesFile.Room[] levelRules in levelRule.Rules)
{
_LoadRooms(levelRules, fileEntry.Path);
}
}
}
}
/// <summary>
/// This function checks every row/col of every excel file, determining if it needs to be visible/public or not.
/// Any element non-zero for all rows, needs to be public (or add new OutputAttribute for "const" values?)
/// </summary>
public static void ExcelValuesDeepScan()
{
FileManager fileManager = new FileManager(Config.HglDir);
fileManager.ExtractAllExcel();
Dictionary<uint, uint> rowTypeCounts = new Dictionary<uint, uint>();
Dictionary<String, uint[]> outputMessages = new Dictionary<String, uint[]>();
Dictionary<String, ObjectDelegator> objectDelegators = new Dictionary<String, ObjectDelegator>();
foreach (PackFileEntry fileEntry in fileManager.FileEntries.Values)
{
if (!fileEntry.Name.EndsWith(ExcelFile.Extension)) continue;
byte[] fileBytes = fileManager.GetFileBytes(fileEntry, true);
Debug.Assert(fileBytes != null);
ExcelFile excelFile = new ExcelFile(fileBytes, fileEntry.Path);
if (excelFile.Attributes.IsEmpty) continue;
Debug.WriteLine("Checking file: " + fileEntry.Path);
uint structureId = excelFile.Attributes.StructureId;
uint structureUseCount = 0;
if (rowTypeCounts.TryGetValue(structureId, out structureUseCount))
{
rowTypeCounts[structureId] = ++structureUseCount;
}
else
{
rowTypeCounts.Add(structureId, 1);
}
ObjectDelegator excelDelegator;
Type rowType = excelFile.Attributes.RowType;
FieldInfo[] fieldInfos = rowType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
int rowCount = excelFile.Rows.Count;
// create delegates
if (!objectDelegators.TryGetValue(excelFile.StringId, out excelDelegator))
{
excelDelegator = new ObjectDelegator(fieldInfos);
objectDelegators.Add(excelFile.StringId, excelDelegator);
}
// check by column, by row
int col = -1;
foreach (FieldInfo fieldInfo in fieldInfos)
{
if (++col == 0) continue; // row header
ObjectDelegator.FieldGetValueDelegate getValue = excelDelegator.GetFieldGetDelegate(fieldInfo.Name);
ExcelFile.OutputAttribute outputAttribute = ExcelFile.GetExcelAttribute(fieldInfo);
bool isArray = false;
bool allEqual = true;
Object firstValue = null;
Array firstValueArray = null;
int arrayIndexFirstDifferent = -1;
int row = -1;
String message = null;
foreach (Object value in excelFile.Rows.Select(rowObject => getValue(rowObject)))
{
arrayIndexFirstDifferent = -1;
if (++row == 0)
{
if (fieldInfo.FieldType.BaseType == typeof(Array))
{
firstValueArray = (Array)value;
isArray = true;
IEnumerator enumerator = firstValueArray.GetEnumerator();
enumerator.MoveNext();
firstValue = enumerator.Current;
}
else
{
firstValue = value;
}
continue;
}
if (isArray)
{
Array objArray = (Array)value;
Debug.Assert(firstValueArray != null);
bool arrayEqual = true;
IEnumerator enumeratorFirst = firstValueArray.GetEnumerator();
IEnumerator enumeratorCurrent = objArray.GetEnumerator();
while (enumeratorFirst.MoveNext())
{
enumeratorCurrent.MoveNext();
arrayIndexFirstDifferent++;
Object objFirst = enumeratorFirst.Current;
Object objCurrent = enumeratorCurrent.Current;
if (firstValue == null) firstValue = objFirst;
if (objFirst.Equals(objCurrent)) continue;
arrayEqual = false;
break;
}
if (arrayEqual) continue;
allEqual = false;
break;
}
Debug.Assert(firstValue != null);
if (firstValue.Equals(value)) continue;
allEqual = false;
break;
}
Debug.Assert(firstValue != null);
Object constValue = null;
bool ignoreConstCheck = false;
if (outputAttribute != null)
{
constValue = outputAttribute.ConstantValue;
ignoreConstCheck = outputAttribute.DebugIgnoreConstantCheck;
}
if (fieldInfo.IsPrivate)
{
if (!allEqual)
{
message = String.Format("Warning: Private column (Type = {1}, StructureId = 0x{2}) \"{0}\" has per-row differing values",
fieldInfo.Name, fieldInfo.FieldType, structureId.ToString("X8")); // need to add structureId to ensure message is unique per structure type
if (isArray)
{
message += ", first index differing: " + arrayIndexFirstDifferent;
}
}
else // allEqual && IsPrivate
{
if (isArray)
{
if (fieldInfo.FieldType == typeof(Int32[]))
{
if (firstValue.Equals((Int32)0)) continue;
}
else if (fieldInfo.FieldType == typeof(byte[]))
{
if (firstValue.Equals((byte)0x00)) continue;
}
else
{
Debug.Assert(false, "Unexpected Array Type: " + fieldInfo.FieldType);
}
if (outputAttribute != null && firstValue.Equals(outputAttribute.ConstantValue)) continue;
message = String.Format("Warning: Private column (Type = {2}, StructureId = 0x{3}) \"{0}\" has constant value not zero \"{1}\"",
fieldInfo.Name, firstValue, fieldInfo.FieldType, structureId.ToString("X8"));
}
else // not array
{
if (firstValue.Equals(constValue)) continue;
if (fieldInfo.FieldType == typeof(Int32) &&
((Int32)firstValue == 0 && (firstValue.Equals(constValue) || constValue == null))) continue;
if (fieldInfo.FieldType == typeof(Int16) &&
((Int16)firstValue == 0 && (firstValue.Equals(constValue) || constValue == null))) continue;
message = String.Format("Warning: Private column (Type = {2}, StructureId = 0x{3}) \"{0}\" has constant value not zero \"{1}\"",
fieldInfo.Name, firstValue, fieldInfo.FieldType, structureId.ToString("X8"));
if (outputAttribute != null && outputAttribute.ConstantValue != null) message += " (outputAttribute.ConstantValue is set)";
}
}
}
else // IsPublic
{
if (ignoreConstCheck) continue;
if (allEqual && fieldInfo.IsPublic && rowCount != 1 && (outputAttribute == null || outputAttribute.ConstantValue == null))
{
message = String.Format("Notice: Public column (Type = {2}, StructureId = 0x{3}) \"{0}\" has constant value \"{1}\"",
fieldInfo.Name, firstValue, fieldInfo.FieldType, structureId.ToString("X8"));
}
}
if (message == null) continue;
uint[] messageCounts;
if (outputMessages.TryGetValue(message, out messageCounts))
{
outputMessages[message] = new[] { messageCounts[0] + 1, structureId };
}
else
{
outputMessages.Add(message, new uint[] { 1, structureId });
}
}
//int bp3 = 0;
}
String previousStringId = null;
StringWriter stringWriter = new StringWriter();
foreach (KeyValuePair<String, uint[]> message in outputMessages)
{
String msg = message.Key;
uint msgCount = message.Value[0];
uint forStructureId = message.Value[1];
uint structureCount = rowTypeCounts[forStructureId];
if (structureCount != msgCount) continue; // if not equal, then we have a message in one table, but in another table it's not applicable
String[] stringIds1 = (from dataTableAttribute in DataFile.DataFileMap
where dataTableAttribute.Value.StructureId == forStructureId
select dataTableAttribute.Key).ToArray();
String[] stringIds2 = (from dataTableAttribute in DataFile.DataFileMapTestCenter
where dataTableAttribute.Value.StructureId == forStructureId
select dataTableAttribute.Key).ToArray();
String[] stringIds3 = (from dataTableAttribute in DataFile.DataFileMapResurrection
where dataTableAttribute.Value.StructureId == forStructureId
select dataTableAttribute.Key).ToArray();
String[] stringIds4 = (from dataTableAttribute in DataFile.DataFileMapMod
where dataTableAttribute.Value.StructureId == forStructureId
select dataTableAttribute.Key).ToArray();
String stringIdPrepend = String.Join(",", stringIds1) + String.Join(",", stringIds2) + String.Join(",", stringIds3) + String.Join(",", stringIds4);
if (previousStringId != stringIdPrepend)
{
//Console.WriteLine(stringIdPrepend);
stringWriter.WriteLine(stringIdPrepend);
previousStringId = stringIdPrepend;
}
//Console.WriteLine(msg);
stringWriter.WriteLine(msg);
}
File.WriteAllText(@"C:\asdf.txt", stringWriter.ToString());
}
/// <summary>
/// This function is to test excel CSV cooking.
/// </summary>
public static void DoCookTest()
{
FileManager fileManager = new FileManager(Config.HglDir);
fileManager.LoadTableFiles();
fileManager.ExtractAllExcel();
ExcelScript.GlobalDebug(true);
foreach (PackFileEntry fileEntry in fileManager.FileEntries.Values)
{
if (!fileEntry.Name.EndsWith(ExcelFile.Extension)) continue;
byte[] fileBytes = fileManager.GetFileBytes(fileEntry, true);
Debug.Assert(fileBytes != null);
String filePath = Path.Combine(Config.HglDir, fileEntry.Path);
ExcelFile excelFile = new ExcelFile(fileBytes, fileEntry.Path);
if (excelFile.Attributes.IsEmpty) continue;
Console.WriteLine("Cooking file: " + fileEntry.Path);
//if (!fileEntry.RelativeFullPathWithoutPatch.Contains("display_item")) continue;
byte[] csvBytes = excelFile.ExportCSV(fileManager);
File.WriteAllBytes(filePath.Replace(ExcelFile.Extension, ExcelFile.ExtensionDeserialised), csvBytes);
ExcelFile excelFileCSV = new ExcelFile(fileEntry.Path);
excelFileCSV.ParseCSV(csvBytes, fileManager);
//byte[] recookedBytes = excelFileCSV.ToByteArray();
byte[] csvBytes2 = excelFileCSV.ExportCSV(fileManager);
//if (!csvBytes.SequenceEqual(csvBytes2))
//{
// int b5p = 0;
//}
//if (excelFile.StringId == "GLOBAL_STRING")
//{
// ExcelFile temp = new ExcelFile(recookedBytes, fileEntry.RelativeFullPathWithoutPatch);
// int bp1 = 0;
//}
//File.WriteAllBytes(filePath, recookedBytes);
}
//int bp = 0;
}
/// <summary>
/// Function to test all excel files cooking/recooking/etc to/from byte arrays and csv types.
/// </summary>
public static void TestExcelCooking(bool doTCv4 = false)
{
/* 0
0 byte[] fileBytes = fileManager.GetFileBytes(excelFile.FilePath, true); Bytes 0-gen bytes
0 1 2 3 4
foreach (DataFile dataFile in fileManager.DataFiles.Values) Bytes->Xls 1-gen Xls file
1 byte[] dataFileBytes = dataFile.ToByteArray(); Bytes->Xls->Bytes 1-gen bytes
fromBytesExcel.ParseData(dataFileBytes); Bytes->Xls->Bytes->Xls 2-gen Xls file
1a byte[] bytesXlsBytesXlsBytes = fromBytesExcel.ToByteArray(); Bytes->Xls->Bytes->Xls->Bytes 2-gen bytes
1ba byte[] bytesXlsCsv = dataFile.ExportCSV(fileManager); Bytes->Xls->CSV 1-gen CSV-bytes
bytesXlsCsvXls.ParseCSV(bytesXlsCsv, fileManager); Bytes->Xls->CSV ->Xls 2-gen Xls file
1bb byte[] bytesXlsCsvXlsBytes = bytesXlsCsvXls.ToByteArray(); Bytes->Xls->CSV ->Xls->Bytes 2-gen CSV-bytes
1b byte[] csvBytes = fromBytesExcel.ExportCSV(fileManager); Bytes->Xls->Bytes->Xls->CSV 2-gen CSV file
csvExcel.ParseCSV(csvBytes, fileManager); Bytes->Xls->Bytes->Xls->CSV->Xls 3-gen Xls file
1c byte[] bytesXlsBytesXlsCsvXlsBytes = csvExcel.ToByteArray(); Bytes->Xls->Bytes->Xls->CSV->Xls->Bytes 3-gen bytes
finalExcel.ParseData(recookedExcelBytes); Bytes->Xls->Bytes->Xls->CSV->Xls->Bytes->Xls 4-gen Xls file
1d byte[] csvCheck = finalExcel.ExportCSV(fileManager); Bytes->Xls->Bytes->Xls->CSV->Xls->Bytes->Xls->CSV 4-gen CSV file
1e byte[] finalCheck = finalExcel.ToByteArray(); Bytes->Xls->Bytes->Xls->CSV->Xls->Bytes->Xls->Bytes 4-gen bytes
*/
String root = @"C:\excel_debug";
FileManager.ClientVersions clientVersion = FileManager.ClientVersions.SinglePlayer;
if (doTCv4)
{
root = Path.Combine(root, "tcv4");
clientVersion = FileManager.ClientVersions.TestCenter;
}
root += @"\"; // lazy
Directory.CreateDirectory(root);
FileManager fileManager = new FileManager(Config.HglDir, clientVersion);
fileManager.BeginAllDatReadAccess();
fileManager.LoadTableFiles();
ExcelFile.EnableDebug = true;
int checkedCount = 0;
List<String> excelFailed = new List<String>();
foreach (DataFile bytesXls in fileManager.DataFiles.Values)
{
ExcelFile excelFile = bytesXls as ExcelFile;
if (excelFile == null) continue;
const String debugStr = "SKILLS";
//if (excelFile.StringId != debugStr) continue;
//if (excelFile.StringId == debugStr)
//{
// int bp = 0;
//}
checkedCount++;
Debug.Write(String.Format("Checking {0}... ", bytesXls.StringId));
byte[] bytes = fileManager.GetFileBytes(excelFile.FilePath, true);
try
{
byte[] bytesXlsBytes = bytesXls.ToByteArray();
if (bytesXls.StringId == "SOUNDS" && false)
{
byte[] csvBytesSounds = excelFile.ExportCSV(fileManager);
ExcelFile soundsCSV = new ExcelFile(excelFile.FilePath);
soundsCSV.ParseCSV(csvBytesSounds, fileManager);
byte[] soundsBytes = soundsCSV.ToByteArray();
//byte[] soundsBytesFromCSV = soundsCSV.ExportCSV();
//ExcelFile soundsCSVFromBytesFromCSV = new ExcelFile(soundsBytesFromCSV, fileEntry.RelativeFullPathWithoutPatch);
// some brute force ftw
byte[][] bytesArrays = new[] { bytes, soundsBytes };
for (int z = 0; z < bytesArrays.Length; z++)
{
byte[] bytesBrute = bytesArrays[z];
int offset = 0x20;
int stringsBytesCount = FileTools.ByteArrayToInt32(bytesBrute, ref offset);
StringWriter stringWriterByteStrings = new StringWriter();
stringWriterByteStrings.WriteLine(stringsBytesCount + " bytes");
List<String> strings = new List<String>();
List<int> offsets = new List<int>();
while (offset < stringsBytesCount + 0x20)
{
String str = FileTools.ByteArrayToStringASCII(bytesBrute, offset);
strings.Add(str);
offsets.Add(offset);
offset += str.Length + 1;
}
String[] sortedStrings = strings.ToArray();
int[] sortedOffsets = offsets.ToArray();
Array.Sort(sortedStrings, sortedOffsets);
stringWriterByteStrings.WriteLine(strings.Count + " strings");
for (int i = 0; i < strings.Count; i++)
{
stringWriterByteStrings.WriteLine(sortedStrings[i] + "\t\t\t" + sortedOffsets[i]);
}
File.WriteAllText(@"C:\excel_debug\strings" + z + ".txt", stringWriterByteStrings.ToString());
}
}
Debug.Write("ToByteArray... ");
if (bytes.Length != bytesXlsBytes.Length && !doTCv4) // some TCv4 tables don't have their sort columns yet
{
Debug.WriteLine("ToByteArray() dataFileBytes has differing length: " + bytesXls.StringId);
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
ExcelFile bytesXlsBytesXls = new ExcelFile(excelFile.FilePath, fileManager.ClientVersion);
bytesXlsBytesXls.ParseData(bytesXlsBytes);
Debug.Write("new ExcelFile... ");
if (!bytesXlsBytesXls.HasIntegrity)
{
Debug.WriteLine("fromBytesExcel = new Excel from ToByteArray() failed!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
// more checks
Debug.Write("ToByteArray->ToByteArray... ");
byte[] bytesXlsBytesXlsBytes = bytesXlsBytesXls.ToByteArray(); // bytesXlsBytesXlsBytes
if (bytes.Length != bytesXlsBytesXlsBytes.Length && !doTCv4) // some TCv4 tables don't have their sort columns yet
{
Debug.WriteLine("ToByteArray() dataFileBytesFromToByteArray has differing length!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.toByteArrayFromByteArray", bytesXlsBytesXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
// check generated sort index arrays);
Debug.Write("IndexSortArrays... ");
if (excelFile.IndexSortArray != null)
{
if (bytesXlsBytesXls.IndexSortArray == null || excelFile.IndexSortArray.Count != bytesXlsBytesXls.IndexSortArray.Count)
{
Debug.WriteLine("fromBytesExcel has not-matching IndexSortArray count!");
excelFailed.Add(bytesXls.StringId);
continue;
}
bool hasError = false;
for (int i = 0; i < excelFile.IndexSortArray.Count; i++)
{
if (excelFile.IndexSortArray[i].SequenceEqual(bytesXlsBytesXls.IndexSortArray[i])) continue;
Debug.WriteLine(String.Format("IndexSortArray[{0}] NOT EQUAL to original!", i));
hasError = true;
}
if (hasError)
{
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
}
// some csv stuff
Debug.Write("BaseXls->BaseCSV==");
byte[] bytesXlsCsv = bytesXls.ExportCSV(fileManager); // Bytes->Xls->CSV
Debug.Write("ExportCSV... ");
byte[] bytesXlsBytesXlsCsv = bytesXlsBytesXls.ExportCSV(fileManager);
if (!bytesXlsCsv.SequenceEqual(bytesXlsBytesXlsCsv))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
excelFailed.Add(bytesXls.StringId);
continue;
}
ExcelFile bytesXlsCsvXls = new ExcelFile(excelFile.FilePath, fileManager.ClientVersion);
bytesXlsCsvXls.ParseCSV(bytesXlsCsv, fileManager);
byte[] bytesXlsCsvXlsBytes = bytesXlsCsvXls.ToByteArray(); // used later as well
if (excelFile.ScriptBuffer == null && // can only compare here for no-script tables - can't compare to pure-base xls-bytes as xls->csv->xls rearranges script code
!excelFile.HasStringBuffer) // xls->csv->xls also rearranges the strings buffer
{
Debug.Write("BytesXlsBytesXlsBytes==BytesXlsCsvXlsBytes... ");
if (!bytesXlsBytesXlsBytes.SequenceEqual(bytesXlsCsvXlsBytes))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1bb.bytesXlsCsvXlsBytes", bytesXlsCsvXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
Debug.Write("BytesXlsBytes==BytesXlsCsvXlsBytes... ");
if (!bytesXlsBytes.SequenceEqual(bytesXlsCsvXlsBytes))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1bb.bytesXlsCsvXlsBytes", bytesXlsCsvXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
}
Debug.Write("BytesXlsBytesXlsCsv -> new ExcelFile");
ExcelFile bytesXlsBytesXlsCsvXls = new ExcelFile(excelFile.FilePath, fileManager.ClientVersion);
bytesXlsBytesXlsCsvXls.ParseCSV(bytesXlsBytesXlsCsv, fileManager);
Debug.Write("... ");
if (!bytesXlsBytesXlsCsvXls.HasIntegrity)
{
Debug.WriteLine("Failed!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
excelFailed.Add(bytesXls.StringId);
continue;
}
byte[] bytesXlsBytesXlsCsvXlsBytes = bytesXlsBytesXlsCsvXls.ToByteArray();
Debug.Write("BytesXlsCsvXlsBytes==BytesXlsBytesXlsCsvXlsBytes... ");
if (!bytesXlsCsvXlsBytes.SequenceEqual(bytesXlsBytesXlsCsvXlsBytes))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1bb.bytesXlsCsvXlsBytes", bytesXlsCsvXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1c.bytesXlsBytesXlsCsvXlsBytes", bytesXlsBytesXlsCsvXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
if (!fileManager.IsVersionTestCenter)
{
Debug.Write("StructureId... ");
UInt32 structureId = BitConverter.ToUInt32(bytes, 4);
UInt32 fromCSVStructureId = BitConverter.ToUInt32(bytesXlsBytesXlsCsvXlsBytes, 4);
if (structureId != fromCSVStructureId)
{
Debug.WriteLine("Structure Id value do not match: " + structureId + " != " + fromCSVStructureId);
excelFailed.Add(bytesXls.StringId);
continue;
}
}
Debug.Write("Almost Done... ");
ExcelFile bytesXlsBytesXlsCsvXlsBytesXls = new ExcelFile(excelFile.FilePath, fileManager.ClientVersion);
bytesXlsBytesXlsCsvXlsBytesXls.ParseData(bytesXlsBytesXlsCsvXlsBytes);
byte[] bytesXlsBytesXlsCsvXlsBytesXlsCsv = bytesXlsBytesXlsCsvXlsBytesXls.ExportCSV(fileManager);
int recookedLength = bytesXlsBytesXlsCsvXlsBytes.Length;
if (excelFile.StringId == "SKILLS") recookedLength += 12; // 12 bytes in int ptr data not used/referenced at all and are removed/lost in bytes -> csv -> bytes
if (bytes.Length != recookedLength && !doTCv4) // some TCv4 tables don't have their sort columns yet
{
Debug.WriteLine("Recooked Excel file has differing length!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1c.bytesXlsBytesXlsCsvXlsBytes", bytesXlsBytesXlsCsvXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1d.bytesXlsBytesXlsCsvXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsvXlsBytesXlsCsv);
excelFailed.Add(bytesXls.StringId);
continue;
}
Debug.Assert(bytesXlsBytesXlsCsvXlsBytesXls.HasIntegrity);
byte[] bytesXlsBytesXlsCsvXlsBytesXlsBytes = bytesXlsBytesXlsCsvXlsBytesXls.ToByteArray();
if (excelFile.StringId == "SKILLS") Debug.Assert(bytesXlsBytesXlsCsvXlsBytesXlsBytes.Length + 12 == bytesXlsBytes.Length);
else Debug.Assert(bytesXlsBytesXlsCsvXlsBytesXlsBytes.Length == bytesXlsBytes.Length || doTCv4);
if (!bytesXlsBytesXlsCsv.SequenceEqual(bytesXlsBytesXlsCsvXlsBytesXlsCsv))
{
Debug.WriteLine("csvBytes.SequenceEqual failed!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsBytesXlsBytes", bytesXlsBytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1ba.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1c.bytesXlsBytesXlsCsvXlsBytes", bytesXlsBytesXlsCsvXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1d.bytesXlsBytesXlsCsvXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsvXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1e.bytesXlsBytesXlsCsvXlsBytesXlsBytes", bytesXlsBytesXlsCsvXlsBytesXlsBytes);
excelFailed.Add(bytesXls.StringId);
continue;
}
Debug.Write("\nPerforming deep scan: ");
ObjectDelegator objectDelegator = fileManager.DataFileDelegators[excelFile.StringId];
int lastPercent = 0;
int col = 0;
bool failed = false;
foreach (FieldDelegate fieldDelegate in objectDelegator)
{
int percent = col * 100 / objectDelegator.FieldCount - 1;
int dotCount = percent - lastPercent;
for (int i = 0; i < dotCount; i++) Debug.Write(".");
lastPercent = percent;
ExcelFile.OutputAttribute excelAttribute = ExcelFile.GetExcelAttribute(fieldDelegate.Info);
bool isArray = (fieldDelegate.FieldType.BaseType == typeof(Array));
for (int row = 0; row < excelFile.Rows.Count; row++)
{
Object obj1 = fieldDelegate.GetValue(excelFile.Rows[row]);
Object obj2 = fieldDelegate.GetValue(bytesXlsBytesXlsCsvXlsBytesXls.Rows[row]);
if (isArray)
{
//if (excelFile.StringId == "TREASURE")
//{
// int bp = 0;
//}
IEnumerator arrayEnumator1 = ((Array)obj1).GetEnumerator();
IEnumerator arrayEnumator2 = ((Array)obj2).GetEnumerator();
int index = -1;
while (arrayEnumator1.MoveNext() && arrayEnumator2.MoveNext())
{
index++;
Object elementVal1 = arrayEnumator1.Current;
Object elementVal2 = arrayEnumator2.Current;
if (elementVal1.Equals(elementVal2)) continue;
Debug.WriteLine(String.Format("Array Element '{0}' != '{1}' on col({2}) = '{3}', row({4}), index({5})", elementVal1, elementVal2, col, fieldDelegate.Name, row, index));
failed = true;
break;
}
if (failed) break;
continue;
}
if (obj1.Equals(obj2)) continue;
if (excelAttribute != null)
{
if (excelAttribute.IsStringOffset)
{
int offset1 = (int)obj1;
int offset2 = (int)obj2;
String str1 = excelFile.ReadStringTable(offset1);
String str2 = bytesXlsBytesXlsCsvXlsBytesXls.ReadStringTable(offset2);
if (str1 == str2) continue;
obj1 = str1;
obj2 = str2;
}
if (excelAttribute.IsScript)
{
int offset1 = (int)obj1;
int offset2 = (int)obj2;
Int32[] script1 = excelFile.ReadScriptTable(offset1);
Int32[] script2 = bytesXlsBytesXlsCsvXlsBytesXls.ReadScriptTable(offset2);
if (script1.SequenceEqual(script2)) continue;
obj1 = script1.ToString(",");
obj2 = script2.ToString(",");
}
}
String str = obj1 as String;
if ((str != null && str.StartsWith("+N%-N% base damage as [elem]")) || // "+N%-N% base damage as [elem]…" != "+N%-N% base damage as [elem]?" on col(2) = 'exampleDescription', row(132) // the '?' at end
fieldDelegate.Name == "bonusStartingTreasure") // refernces multiple different blank rows
continue;
Debug.WriteLine(String.Format("'{0}' != '{1}' on col({2}) = '{3}', row({4})", obj1, obj2, col, fieldDelegate.Name, row));
failed = true;
break;
}
if (failed) break;
col++;
}
if (failed)
{
File.WriteAllBytes(root + bytesXls.StringId + ".bytesXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + ".bytesXlsBytesXlsCsvXlsBytesXlsCsv.csv", bytesXlsBytesXlsCsvXlsBytesXlsCsv);
excelFailed.Add(bytesXls.StringId);
continue;
}
Debug.WriteLine("OK\n");
}
catch (Exception e)
{
Debug.WriteLine("Excel file Exception: " + bytesXls.StringId + "\n" + e);
}
}
Debug.WriteLine(checkedCount + " excel files checked.");
if (excelFailed.Count <= 0) return;
Debug.WriteLine(excelFailed.Count + " failed excel checks! (" + ((float)excelFailed.Count / checkedCount * 100) + "%)");
foreach (String str in excelFailed) Debug.Write(str + ", ");
}
/// <summary>
/// Function to test saving/importing/exported/etc relating to DataTables (i.e. actions from WITHIN Reanimator etc.)
/// </summary>
public static void TestDataTableExportAndImport(bool doTCv4 = false)
{
/*
bytesXls Bytes->Xls
bytesXlsBytes Bytes->Xls->Bytes
bytesXlsCsv Bytes->Xls->CSV
bytesXlsCsvXls Bytes->Xls->CSV->Xls
bytesXlsCsvXlsBytes Bytes->Xls->CSV->Xls->Bytes == bytesXlsTableXlsBytes as single byte is stripped ->CSV
bytesXlsTable Bytes->Xls->Table
bytesXlsTableXls Bytes->Xls->Table->Xls
bytesXlsTableXlsBytes Bytes->Xls->Table->Xls->Bytes != bytesXlsBytes because of single script byte thingy lost to table
bytesXlsTableXlsCsv Bytes->Xls->Table->Xls->CSV
bytesXlsTableXlsCsvXls Bytes->Xls->Table->Xls->CSV->Xls
bytesXlsTableXlsCsvXlsBytes Bytes->Xls->Table->Xls->CSV->Xls->Bytes
byte[] bytesXlsBytes = bytesXls.ToByteArray();
byte[] bytesXlsTableXlsCsvXlsBytes = bytesXlsTableXlsCsvXls.ToByteArray();
*/
String root = @"C:\excel_datatable_debug";
FileManager.ClientVersions clientVersion = FileManager.ClientVersions.SinglePlayer;
if (doTCv4)
{
root = Path.Combine(root, "tcv4");
clientVersion = FileManager.ClientVersions.TestCenter;
}
root += @"\"; // lazy
Directory.CreateDirectory(root);
FileManager fileManager = new FileManager(Config.HglDir, clientVersion);
fileManager.BeginAllDatReadAccess();
fileManager.LoadTableFiles();
List<String> sequenceFailed = new List<String>();
List<String> sequenceChecked = new List<String>();
foreach (KeyValuePair<String, DataFile> keyValuePair in fileManager.DataFiles)
{
String stringId = keyValuePair.Key;
DataFile dataFile = keyValuePair.Value;
if (dataFile.IsStringsFile) continue;
//if (stringId != "WARDROBE_LAYER") continue;
//if (stringId == "WARDROBE_LAYER")
//{
// int bp = 0;
//}
Debug.Write("Checking " + stringId + "... ");
ExcelFile bytesXls = (ExcelFile)dataFile;
byte[] bytes = fileManager.GetFileBytes(bytesXls.FilePath, true);
sequenceChecked.Add(stringId);
sequenceFailed.Add(stringId);
if (stringId == "PROPERTIES") continue; // can't do this atm - need to export Properties script table to DataTable etc.
Debug.Write("DataTable... ");
DataTable bytesXlsTable = fileManager.GetDataTable(stringId);
if (bytesXlsTable == null)
{
Debug.WriteLine("FAILED!");
continue;
}
// parse as DataTable
Debug.Write("new Excel... ");
DataFile bytesXlsTableXls = new ExcelFile(bytesXls.FilePath, fileManager.ClientVersion);
if (!bytesXlsTableXls.ParseDataTable(bytesXlsTable, fileManager))
{
Debug.WriteLine("FAILED!");
continue;
}
// check just data table import/export
byte[] bytesXlsBytes = bytesXls.ToByteArray();
byte[] bytesXlsTableXlsBytes = bytesXlsTableXls.ToByteArray();
if (bytesXls.ScriptBuffer == null && // can't check this as ScriptBuffer[0] is NOT always 0x00 (even though it's unused and means no script normally when pointed to)
!bytesXls.HasStringBuffer) // as above - gets re-arranged etc (only consistant comparint CSV->XLS->DATA
{
Debug.Write("bytesXlsBytes==bytesXlsTableXlsBytes... ");
if (!bytesXlsBytes.SequenceEqual(bytesXlsTableXlsBytes))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "2.bytesXlsTableXlsBytes", bytesXlsTableXlsBytes);
continue;
}
}
// export CSV
Debug.Write("ExportCSV... ");
byte[] bytesXlsTableXlsCsv = bytesXlsTableXls.ExportCSV(fileManager);
if (bytesXlsTableXlsCsv == null)
{
Debug.WriteLine("FAILED!");
continue;
}
Debug.Write("bytesXlsCsv==bytesXlsTableXlsCsv... ");
byte[] bytesXlsCsv = bytesXls.ExportCSV(fileManager);
if (!bytesXlsCsv.SequenceEqual(bytesXlsTableXlsCsv))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "2.bytesXlsTableXlsBytes", bytesXlsTableXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "3.bytesXlsTableXlsCsv.csv", bytesXlsTableXlsCsv);
continue;
}
Debug.Write("bytesXlsCsvXlsBytes==bytesXlsTableXlsBytes... ");
DataFile bytesXlsCsvXls = new ExcelFile(bytesXls.FilePath, fileManager.ClientVersion);
bytesXlsCsvXls.ParseCSV(bytesXlsCsv, fileManager);
byte[] bytesXlsCsvXlsBytes = bytesXlsCsvXls.ToByteArray();
if (!bytesXlsCsvXlsBytes.SequenceEqual(bytesXlsTableXlsBytes) &&
stringId != "ITEMDISPLAY" && stringId != "LEVEL") // ITEMDISPLAY has weird single non-standard ASCII char that is lost (from using MS Work on their part lol)
{ // and LEVEL references blank TREASURE rows and hence rowId references differ on recooks
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "1a.bytesXlsCsv.csv", bytesXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "1b.bytesXlsCsvXlsBytes", bytesXlsCsvXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "2.bytesXlsTableXlsBytes", bytesXlsTableXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "3.bytesXlsTableXlsCsv.csv", bytesXlsTableXlsCsv);
continue;
}
// import CSV
Debug.Write("ParseCSV... ");
DataFile bytesXlsTableXlsCsvXls = new ExcelFile(bytesXls.FilePath, fileManager.ClientVersion);
if (!bytesXlsTableXlsCsvXls.ParseCSV(bytesXlsTableXlsCsv, fileManager))
{
Debug.WriteLine("FAILED!");
continue;
}
// export imported as cooked and do byte compare
Debug.Write("ToByteArray... ");
byte[] bytesXlsTableXlsCsvXlsBytes = bytesXlsTableXlsCsvXls.ToByteArray();
Debug.Write("bytesXlsCsvXlsBytes==bytesXlsTableXlsCsvXlsBytes... ");
if (!bytesXlsCsvXlsBytes.SequenceEqual(bytesXlsTableXlsCsvXlsBytes))
{
Debug.WriteLine("FALSE!");
File.WriteAllBytes(root + bytesXls.StringId + "0.bytes", bytes);
File.WriteAllBytes(root + bytesXls.StringId + "1.bytesXlsBytes", bytesXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "2.bytesXlsTableXlsBytes", bytesXlsTableXlsBytes);
File.WriteAllBytes(root + bytesXls.StringId + "3.bytesXlsTableXlsCsv", bytesXlsTableXlsCsv);
File.WriteAllBytes(root + bytesXls.StringId + "4.bytesXlsTableXlsCsvXlsBytes", bytesXlsTableXlsCsvXlsBytes);
continue;
}
// yay
Debug.WriteLine("OK!");
sequenceFailed.RemoveAt(sequenceFailed.Count - 1);
}
Debug.WriteLine("Totals: {0} sequence checks, {1} fails. ({2}% failed!)", sequenceChecked.Count, sequenceFailed.Count, (float)sequenceFailed.Count * 100f / sequenceChecked.Count);
Debug.Write("Failed Tables: ");
foreach (String stringIdFailed in sequenceFailed)
{
Debug.Write(stringIdFailed + ", ");
}
}
public static void TestAllXml(bool doTCv4 = false)
{
//System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
//const String root = @"D:\Games\Hellgate\Data\";
//const String root = @"D:\Games\Hellgate London\data\mp_hellgate_1.10.180.3416_1.0.86.4580\";
//const String root = @"D:\Games\Hellgate London\data\mp_hellgate_1.10.180.3416_1.0.86.4580\data\background\";
//List<String> xmlFiles = new List<String>(Directory.GetFiles(root, "*.xml.cooked", SearchOption.AllDirectories));
String debugPath = @"C:\xml_debug\";
FileManager.ClientVersions clientVersion = FileManager.ClientVersions.SinglePlayer;
if (doTCv4)
{
debugPath = Path.Combine(debugPath, "tcv4");
clientVersion = FileManager.ClientVersions.TestCenter;
}
debugPath += @"\"; // lazy
Directory.CreateDirectory(debugPath);
FileManager fileManager = new FileManager(Config.HglDir, clientVersion);
fileManager.BeginAllDatReadAccess();
fileManager.LoadTableFiles();
int count = 0;
List<XmlCookedFile> excelStringWarnings = new List<XmlCookedFile>();
List<String> testCentreWarnings = new List<String>();
List<String> resurrectionWarnings = new List<String>();
int i = 0;
foreach (PackFileEntry fileEntry in fileManager.FileEntries.Values)
{
if (!fileEntry.Path.EndsWith(XmlCookedFile.Extension)) continue;
String xmlFilePath = fileEntry.Path;
//const String debugStr = "buildintx_inside_env";
//if (!xmlFilePath.Contains(debugStr)) continue;
//if (xmlFilePath.Contains(debugStr))
//{
// int bp = 0;
//}
//foreach (String xmlFilePath in xmlFiles)
//{
//bool skip = ((i++ % 23) > 0);
//if (skip)
//{
// if (xmlFilePath.Contains("\\Data\\colorsets.xml")) continue;
// if (xmlFilePath.Contains("\\Data\\ai\\")) continue;
// if (xmlFilePath.Contains("\\Data\\background\\")) continue;
// if (xmlFilePath.Contains("\\Data\\demolevel\\")) continue;
// if (xmlFilePath.Contains("\\Data\\lights\\")) continue;
// if (xmlFilePath.Contains("\\Data\\materials\\")) continue;
// if (xmlFilePath.Contains("\\Data\\particles\\")) continue;
// if (xmlFilePath.Contains("\\Data\\screenfx\\")) continue;
// if (xmlFilePath.Contains("\\Data\\skills\\")) continue;
// if (xmlFilePath.Contains("\\Data\\sounds\\")) continue;
// if (xmlFilePath.Contains("\\Data\\states\\")) continue;
// if (xmlFilePath.Contains("\\Data\\units\\items\\")) continue;
// if (xmlFilePath.Contains("\\Data\\units\\missiles\\")) continue;
// if (xmlFilePath.Contains("\\Data\\units\\monsters\\")) continue;
// if (xmlFilePath.Contains("\\Data\\units\\npc\\")) continue;
// if (xmlFilePath.Contains("\\Data\\units\\objects\\")) continue;
//}
String path = xmlFilePath;
String fileName = Path.GetFileName(path);
Debug.Assert(!String.IsNullOrEmpty(fileName));
//path = @"D:\Games\Hellgate London\data\mp_hellgate_1.10.180.3416_1.0.86.4580\data\background\city\treasury\cap_path.xml.cooked";
//path = "D:\\Games\\Hellgate\\Data\\background\\_environments\\outdoor_redhellcow_env.xml.cooked";
//path = "D:\\Games\\Hellgate\\Data\\particles\\background\\t_background\\tokyo_dark_smoke_c_large_01.xml.cooked";
//if (path == @"D:\Games\Hellgate\Data\background\cans and boxes.xml.cooked")
//{
// int bp = 0;
//}
XmlCookedFile xmlCookedFile = new XmlCookedFile(fileManager, fileName) { CookExcludeTestCentre = !doTCv4 };
byte[] data = fileManager.GetFileBytes(fileEntry);
Debug.Assert(data != null && data.Length > 0);
Console.Write("Uncooking " + fileName + "... ");
try
{
xmlCookedFile.ParseFileBytes(data, true);
}
catch (Exception e)
{
File.WriteAllBytes(debugPath + fileName, data);
Console.WriteLine("Failed to uncooked file \"" + path + "\"\n" + e + "\n");
continue;
}
byte[] newXmlBytes = xmlCookedFile.ExportAsDocument();
count++;
if (xmlCookedFile.HasExcelStringsMissing) excelStringWarnings.Add(xmlCookedFile);
if (xmlCookedFile.HasTestCentreElements) testCentreWarnings.Add(Path.GetFileName(fileName));
if (xmlCookedFile.HasResurrectionElements) resurrectionWarnings.Add(Path.GetFileName(fileName));
//if (xmlCookedFile.HasExcelStringsMissing || xmlCookedFile.HasTestCentreElements || xmlCookedFile.HasResurrectionElements) continue;
XmlCookedFile recookedXmlFile = new XmlCookedFile(fileManager, fileName) { CookExcludeTestCentre = !doTCv4 };
byte[] newXmlCookedBytes = recookedXmlFile.ParseFileBytes(newXmlBytes);
// check if *cooking method* is working. i.e. is the cook from the *new* XML format == the original cooked
bool identicalNew = data.SequenceEqual(newXmlCookedBytes);
// if file passes byte-byte test, then continue
if (identicalNew)
{
Console.WriteLine("OK!");
continue;
}
if (
path.Contains("female_3p_appearance.xml") || // this file has some weird bytes in a string element
path.Contains("focus_item12_mesh_appearance.xml") || // this file has non-zeroed flag base masks (all differing)
path.Contains("focus_item10_mesh_appearance.xml") || // as above // (all 3 probably from not zeroing a ptr at original cooking)
path.Contains("dof_test.xml") || // as above
path.Contains("motionblur.xml") || // as above
path.Contains("player dead.xml")
)
{
Console.WriteLine("OK!");
continue;
}
File.WriteAllBytes(debugPath + fileName, data);
File.WriteAllBytes(debugPath + fileName + "recooked", newXmlCookedBytes);
File.WriteAllBytes(debugPath + fileName.Replace(".cooked", ""), newXmlBytes);
Console.WriteLine("FAILED!");
}
TextWriter consoleOut = Console.Out;
TextWriter textWriter = new StreamWriter("uncook_results.txt");
Console.SetOut(textWriter);
Console.WriteLine("XML Files Uncooked: " + count);
if (excelStringWarnings.Count > 0)
{
Console.WriteLine("Warning: " + excelStringWarnings.Count + " files had excel strings missing:");
foreach (XmlCookedFile xmlCookedFile in excelStringWarnings)
{
Console.WriteLine("\t" + xmlCookedFile.FileName);
foreach (String str in xmlCookedFile.ExcelStringsMissing) Console.WriteLine("\t\t- \"" + str + "\"");
}
}
if (testCentreWarnings.Count > 0)
{
Console.WriteLine("Warning: " + testCentreWarnings.Count + " files had TestCentre-specific elements:");
foreach (String str in testCentreWarnings) Console.WriteLine("\t" + str);
}
if (resurrectionWarnings.Count > 0)
{
Console.WriteLine("Warning: " + resurrectionWarnings.Count + " files had Resurrection-specific elements:");
foreach (String str in resurrectionWarnings) Console.WriteLine("\t" + str);
}
textWriter.Close();
Console.SetOut(consoleOut);
}
public static void TestAllLevelRules(bool doTCv4=false)
{
//const String root = @"D:\Games\Hellgate London\data\background\";
//List<String> drlFiles = new List<String>(Directory.GetFiles(root, "*.drl", SearchOption.AllDirectories));
String debugPath = @"C:\drl_debug\";
FileManager.ClientVersions clientVersion = FileManager.ClientVersions.SinglePlayer;
if (doTCv4)
{
debugPath = Path.Combine(debugPath, "tcv4");
clientVersion = FileManager.ClientVersions.TestCenter;
}
debugPath += @"\"; // lazy
Directory.CreateDirectory(debugPath);
FileManager fileManager = new FileManager(Config.HglDir, clientVersion);
fileManager.BeginAllDatReadAccess();
fileManager.LoadTableFiles();
int tested = 0;
int failed = 0;
//foreach (String drlFilePath in drlFiles)
foreach (PackFileEntry fileEntry in fileManager.FileEntries.Values)
{
if (!fileEntry.Path.EndsWith(LevelRulesFile.Extension)) continue;
tested++;
failed++;
//String path = drlFilePath;
String path = fileEntry.Path;
//path = @"D:\Games\Hellgate London\data\background\catacombs\ct_rule_100.drl";
//path = @"D:\Games\Hellgate London\data\background\city\rule_pmt02.drl";
//byte[] levelRulesBytes = File.ReadAllBytes(path);
byte[] bytes = fileManager.GetFileBytes(fileEntry);
LevelRulesFile bytesObj = new LevelRulesFile();
//String fileName = path.Replace(@"D:\Games\Hellgate London\data\background\", "");
String fileName = Path.GetFileName(path);
String xmlPath = path.Replace(LevelRulesFile.Extension, LevelRulesFile.ExtensionDeserialised);
Console.WriteLine("Loading: " + fileName);
try
{
bytesObj.ParseFileBytes(bytes);
byte[] bytesObjXml = bytesObj.ExportAsDocument();
MemoryStream ms = new MemoryStream(bytesObjXml);
//File.WriteAllBytes(xmlPath, xmlBytes);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(ms);//.Load(xmlPath);
LevelRulesFile bytesObjXmlObj = new LevelRulesFile();
bytesObjXmlObj.ParseXmlDocument(xmlDocument);
byte[] bytesObjXmlObjXml = bytesObjXmlObj.ExportAsDocument();
byte[] bytesObjXmlObjXmlBytes = bytesObjXmlObj.ToByteArray();
if (!bytesObjXml.SequenceEqual(bytesObjXmlObjXml))
{
File.WriteAllBytes(debugPath + fileName + "0.bytesObjXml.xml", bytesObjXml);
File.WriteAllBytes(debugPath + fileName + "1.bytesObjXmlObjXml.xml", bytesObjXmlObjXml);
}
// note: ct_rule_100.drl has unreferenced rules (only one found out of all files)
if (bytes.Length != bytesObjXmlObjXmlBytes.Length && !path.Contains("ct_rule_100"))
{
File.WriteAllBytes(debugPath + fileName + "0.bytesObjXml.xml", bytesObjXml);
File.WriteAllBytes(debugPath + fileName + "1.bytesObjXmlObjXml.xml", bytesObjXmlObjXml);
File.WriteAllBytes(debugPath + fileName + "2.bytes", bytes);
File.WriteAllBytes(debugPath + fileName + "3.bytesObjXmlObjXmlBytes", bytesObjXmlObjXmlBytes);
}
failed--;
}
catch (Exception e)
{
Console.WriteLine("Failed to load file!\n" + e);
continue;
}
}
Console.WriteLine("Tested: " + tested);
Console.WriteLine("Failed: " + failed);
}
