public byte[] Import(FieldDefinition def, FieldType arrayFieldType, XPathNavigator nav)
{
using (var temp = new MemoryStream())
{
var items = nav.Select("item");
temp.WriteValueS32(items.Count);
while (items.MoveNext() == true)
{
temp.WriteBytes(FieldHandling.Import(null, arrayFieldType, FieldType.Invalid, items.Current));
}
return(temp.ToArray());
}
}
public FieldDefinition GetFieldDefinition(uint hash, IEnumerable <FileFormats.BinaryObject> chain)
{
if (this._FieldLookup.ContainsKey(hash) == true)
{
return(this._FieldLookup[hash]);
}
var chainArray = chain != null?chain.ToArray() : null;
foreach (var friend in this.Friends)
{
if (string.IsNullOrEmpty(friend.ConditionField) == false)
{
if (chain == null)
{
throw new NotSupportedException();
}
byte[] fieldData;
var hasFieldData = GetFieldData(friend.ConditionField, chainArray, out fieldData);
if (hasFieldData == false)
{
continue;
}
var conditionData = FieldHandling.Import(null, friend.ConditionType, friend.ConditionValue);
if (fieldData.SequenceEqual(conditionData) == false)
{
continue;
}
}
var def = friend.Class.GetFieldDefinition(hash, chainArray);
if (def != null)
{
return(def);
}
}
return(null);
}
private static void ResolveField(XmlWriter writer, KeyValuePair <uint, byte[]> kv)
{
string fieldType = FieldHandling.GetTypeName(FieldType.BinHex);
string fieldValue = BitConverter.ToString(kv.Value).Replace("-", "");
string r_fieldTypeString = fieldType;
string r_fieldValueString = fieldValue;
if (kv.Key == TextHidNameHash)
{
FieldType fileNameFieldType = FieldType.String;
string fileNameFieldValue = FieldHandling.Deserialize <string>(fileNameFieldType, kv.Value);
writer.WriteAttributeString("type", FieldHandling.GetTypeName(fileNameFieldType));
writer.WriteString(fileNameFieldValue);
Console.WriteLine($"Resolved name field in file \"{fileNameFieldValue}\"");
}
else
{
if (TypeGuesser.FieldHandler(kv.Value, out r_fieldTypeString, out r_fieldValueString) == true)
{
if (r_fieldTypeString != FieldHandling.GetTypeName(FieldType.BinHex))
{
fieldType = r_fieldTypeString;
fieldValue = r_fieldValueString;
}
writer.WriteAttributeString($"value-{r_fieldTypeString}", fieldValue);
}
//writer.WriteAttributeString("type", r_fieldTypeString);
//writer.WriteString(fieldValue);
writer.WriteAttributeString("type", FieldHandling.GetTypeName(FieldType.BinHex));
writer.WriteBinHex(kv.Value, 0, kv.Value.Length);
}
//Utility.Log($"Field Value\n\tfrom: {BitConverter.ToString(kv.Value).Replace(" ", "")}\n\tto: {fieldValue}");
}
public void Export(FieldDefinition def,
FieldType arrayFieldType,
byte[] buffer,
int offset,
int count,
XmlWriter writer,
out int read)
{
if (Helpers.HasLeft(buffer, offset, buffer.Length, 4) == false)
{
throw new FormatException("Array32 requires at least 4 bytes");
}
var itemCount = BitConverter.ToUInt32(buffer, offset);
read = 4;
offset += 4;
int remaining = buffer.Length - offset;
for (uint i = 0; i < itemCount; i++)
{
writer.WriteStartElement("item");
int itemRead;
FieldHandling.Export(null,
arrayFieldType,
FieldType.Invalid,
buffer,
offset,
remaining,
writer,
out itemRead,
def,
i);
offset += itemRead;
remaining -= itemRead;
writer.WriteEndElement();
read += itemRead;
}
}
private static FieldInfo ResolveField(uint key, byte[] value)
{
FieldInfo field = new FieldInfo();
// key
string keyTypeString = "hash";
string keyNameString = $"{key:X8}";
if (StringHasher.CanResolveHash((int)key))
{
keyTypeString = "name";
keyNameString = StringHasher.ResolveHash((int)key);
}
// value
string valueTypeString = FieldHandling.GetTypeName(FieldType.BinHex);
string valueValueString = BitConverter.ToString(value).Replace("-", "");
string r_valueTypeString = valueTypeString;
string r_valueValueString = valueValueString;
if (TypeGuesser.FieldHandler(value, out r_valueTypeString, out r_valueValueString) == true)
{
valueTypeString = r_valueTypeString;
valueValueString = r_valueValueString;
}
// fill structure
field.key.type = keyTypeString;
field.key.name = keyNameString;
field.value.type = valueTypeString;
field.value.value = valueValueString;
return(field);
}
private void ReadNode(BinaryObject node,
IEnumerable <BinaryObject> parentChain,
ClassDefinition objectDef,
string basePath,
XPathNavigator nav,
string currentFileName)
{
var chain = parentChain.Concat(new[] { node });
string className;
uint classNameHash;
LoadNameAndHash(nav, out className, out classNameHash);
if (objectDef != null &&
objectDef.ClassFieldHash.HasValue == true)
{
var hash = GetClassDefinitionByField(objectDef.ClassFieldName, objectDef.ClassFieldHash, nav);
if (hash.HasValue == false)
{
throw new InvalidOperationException();
}
objectDef = this._InfoManager.GetClassDefinition(hash.Value);
}
node.NameHash = classNameHash;
var fields = nav.Select("field");
while (fields.MoveNext() == true)
{
if (fields.Current == null)
{
throw new InvalidOperationException();
}
LoadNameAndHash(fields.Current, out string fieldName, out uint fieldNameHash);
if (fieldName != null && fieldNameHash == 0x9D8873F8 && currentFileName != null) // crc32(text_hidName)
{
var specifiedName = fields.Current.Value;
specifiedName = specifiedName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (!currentFileName.Equals(specifiedName))
{
throw new ArgumentException(string.Format("Specified file name \"{0}\" does not match actual file name \"{1}\"", specifiedName, currentFileName), "text_hidName");
}
}
FieldType fieldType;
var fieldTypeName = fields.Current.GetAttribute("type", "");
if (Enum.TryParse(fieldTypeName, true, out fieldType) == false)
{
throw new InvalidOperationException();
}
var arrayFieldType = FieldType.Invalid;
var arrayFieldTypeName = fields.Current.GetAttribute("array_type", "");
if (string.IsNullOrEmpty(arrayFieldTypeName) == false)
{
if (Enum.TryParse(arrayFieldTypeName, true, out arrayFieldType) == false)
{
throw new InvalidOperationException();
}
}
var fieldDef = objectDef != null?objectDef.GetFieldDefinition(fieldNameHash, chain) : null;
var data = FieldHandling.Import(fieldDef, fieldType, arrayFieldType, fields.Current);
node.Fields.Add(fieldNameHash, data);
}
var children = nav.Select("object");
while (children.MoveNext() == true)
{
var child = new BinaryObject();
LoadChildNode(child, chain, objectDef, basePath, children.Current);
node.Children.Add(child);
}
}
private void ReadNode(BinaryObject node,
IEnumerable <BinaryObject> parentChain,
string basePath,
XPathNavigator nav,
string currentFileName)
{
var chain = parentChain.Concat(new[] { node });
string className;
uint classNameHash;
LoadNameAndHash(nav, out className, out classNameHash);
//Console.WriteLine($"currentFileName = {currentFileName}");
//Console.WriteLine($"{classNameHash:X8} = {className}");
node.NameHash = classNameHash;
var fields = nav.Select("field");
while (fields.MoveNext() == true)
{
if (fields.Current == null)
{
throw new InvalidOperationException();
}
LoadNameAndHash(fields.Current, out string fieldName, out uint fieldNameHash);
//if (fieldName != null && fieldNameHash == 0x9D8873F8 && currentFileName != null) // crc32(text_hidName)
if (fieldName != null && fieldNameHash == 0xB9295CC7 && currentFileName != null) // crc32(hidName)
{
//var specifiedName = Utility.HexToString(fields.Current.Value);
var specifiedName = fields.Current.Value;
specifiedName = specifiedName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (!currentFileName.Equals(specifiedName))
{
throw new ArgumentException(string.Format("Specified file name \"{0}\" does not match actual file name \"{1}\"", specifiedName, currentFileName), "text_hidName");
}
}
FieldType fieldType = new FieldType();
var fieldTypeName = fields.Current.GetAttribute("type", "");
//Utility.Log($"Reading field of type {fieldTypeName}");
if (Enum.TryParse(fieldTypeName, true, out fieldType) == false)
{
throw new InvalidOperationException();
}
var arrayFieldType = FieldType.Invalid;
var arrayFieldTypeName = fields.Current.GetAttribute("array_type", "");
if (string.IsNullOrEmpty(arrayFieldTypeName) == false)
{
if (Enum.TryParse(arrayFieldTypeName, true, out arrayFieldType) == false)
{
throw new InvalidOperationException();
}
}
var data = FieldHandling.Import(fieldType, arrayFieldType, fields.Current);
node.Fields.Add(fieldNameHash, data);
}
var children = nav.Select("object");
while (children.MoveNext() == true)
{
var child = new BinaryObject();
LoadChildNode(child, chain, basePath, children.Current);
node.Children.Add(child);
}
}
private void ReadNode(BinaryObject node,
IEnumerable <BinaryObject> parentChain,
ClassDefinition objectDef,
string basePath,
XPathNavigator nav)
{
var chain = parentChain.Concat(new[] { node });
string className;
uint classNameHash;
LoadNameAndHash(nav, out className, out classNameHash);
if (objectDef != null &&
objectDef.ClassFieldHash.HasValue == true)
{
var hash = GetClassDefinitionByField(objectDef.ClassFieldName, objectDef.ClassFieldHash, nav);
if (hash.HasValue == false)
{
throw new InvalidOperationException();
}
objectDef = this._InfoManager.GetClassDefinition(hash.Value);
}
node.NameHash = classNameHash;
var fields = nav.Select("field");
while (fields.MoveNext() == true)
{
if (fields.Current == null)
{
throw new InvalidOperationException();
}
string fieldName;
uint fieldNameHash;
LoadNameAndHash(fields.Current, out fieldName, out fieldNameHash);
FieldType fieldType;
var fieldTypeName = fields.Current.GetAttribute("type", "");
if (Enum.TryParse(fieldTypeName, true, out fieldType) == false)
{
throw new InvalidOperationException();
}
var arrayFieldType = FieldType.Invalid;
var arrayFieldTypeName = fields.Current.GetAttribute("array_type", "");
if (string.IsNullOrEmpty(arrayFieldTypeName) == false)
{
if (Enum.TryParse(arrayFieldTypeName, true, out arrayFieldType) == false)
{
throw new InvalidOperationException();
}
}
var fieldDef = objectDef != null?objectDef.GetFieldDefinition(fieldNameHash, chain) : null;
var data = FieldHandling.Import(fieldDef, fieldType, arrayFieldType, fields.Current);
node.Fields.Add(fieldNameHash, data);
}
var children = nav.Select("object");
while (children.MoveNext() == true)
{
var child = new BinaryObject();
LoadChildNode(child, chain, objectDef, basePath, children.Current);
node.Children.Add(child);
}
}
internal const uint TemplateHash = 0x6E167DD5; // crc32(Template)
public static void MultiExportEntityLibrary(ObjectFileDefinition objectFileDef,
string basePath,
string outputPath,
InfoManager infoManager,
BinaryObjectFile bof)
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
CheckCharacters = false,
OmitXmlDeclaration = false
};
var objectDef = objectFileDef != null ? objectFileDef.Object : null;
using (var writer = XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
var root = bof.Root;
{
writer.WriteStartElement("object");
writer.WriteAttributeString("name", "EntityLibraries");
if (objectFileDef != null &&
string.IsNullOrEmpty(objectFileDef.Name) == false)
{
writer.WriteAttributeString("def", objectFileDef.Name);
}
var libraryNames = new Dictionary <string, int>();
Directory.CreateDirectory(basePath);
foreach (var library in root.Children)
{
var chain = new[] { bof.Root, library };
var libraryDef = objectDef != null
? objectDef.GetObjectDefinition(library.NameHash, null)
: null;
var libraryName = FieldHandling.Deserialize <string>(null,
FieldType.String,
library.Fields[NameHash]);
var unsanitizedLibraryName = libraryName;
libraryName = libraryName.Replace('/', Path.DirectorySeparatorChar);
libraryName = libraryName.Replace('\\', Path.DirectorySeparatorChar);
if (libraryNames.ContainsKey(libraryName) == false)
{
libraryNames.Add(libraryName, 1);
}
else
{
libraryName = string.Format("{0} ({1})", libraryName, ++libraryNames[libraryName]);
}
var libraryPath = Path.Combine(libraryName, "@library.xml");
writer.WriteStartElement("object");
writer.WriteAttributeString("external", libraryPath);
writer.WriteEndElement();
libraryPath = Path.Combine(basePath, libraryPath);
var itemNames = new Dictionary <string, int>();
var libraryParentPath = Path.GetDirectoryName(libraryPath);
if (string.IsNullOrEmpty(libraryParentPath) == false)
{
Directory.CreateDirectory(libraryParentPath);
}
using (var libraryWriter = XmlWriter.Create(libraryPath, settings))
{
libraryWriter.WriteStartDocument();
libraryWriter.WriteStartElement("object");
libraryWriter.WriteAttributeString("name", "EntityLibrary");
libraryWriter.WriteStartElement("field");
libraryWriter.WriteAttributeString("name", "Name");
libraryWriter.WriteAttributeString("type", "String");
libraryWriter.WriteString(unsanitizedLibraryName);
libraryWriter.WriteEndElement();
foreach (var item in library.Children)
{
var itemDef = libraryDef != null
? libraryDef.GetObjectDefinition(item.NameHash, null)
: null;
var itemName = FieldHandling.Deserialize <string>(null,
FieldType.String,
item.Fields[NameHash]);
itemName = itemName.Replace('/', Path.DirectorySeparatorChar);
itemName = itemName.Replace('\\', Path.DirectorySeparatorChar);
if (itemNames.ContainsKey(itemName) == false)
{
itemNames.Add(itemName, 1);
}
else
{
itemName = string.Format("{0} ({1})", itemName, ++itemNames[itemName]);
}
var itemPath = itemName + ".xml";
libraryWriter.WriteStartElement("object");
libraryWriter.WriteAttributeString("external", itemPath);
libraryWriter.WriteEndElement();
itemPath = Path.Combine(basePath, libraryName, itemPath);
var itemParentPath = Path.GetDirectoryName(itemPath);
if (string.IsNullOrEmpty(itemParentPath) == false)
{
Directory.CreateDirectory(itemParentPath);
}
using (var itemWriter = XmlWriter.Create(itemPath, settings))
{
itemWriter.WriteStartDocument();
WriteNode(infoManager,
itemWriter,
chain,
item,
itemDef,
null);
itemWriter.WriteEndDocument();
}
}
libraryWriter.WriteEndDocument();
}
}
writer.WriteEndElement();
}
writer.WriteEndDocument();
}
}
private static void WriteNode(InfoManager infoManager,
XmlWriter writer,
IEnumerable <BinaryObject> parentChain,
BinaryObject node,
ClassDefinition def,
ObjectFileDefinition objectFileDef)
{
var chain = parentChain.Concat(new[] { node });
var originalDef = def;
if (def != null &&
def.ClassFieldHash.HasValue == true)
{
if (node.Fields.ContainsKey(def.ClassFieldHash.Value) == true)
{
var hash = FieldHandling.Deserialize <uint>(null,
FieldType.UInt32,
node.Fields[def.ClassFieldHash.Value]);
def = infoManager.GetClassDefinition(hash);
}
}
writer.WriteStartElement("object");
if (originalDef != null && originalDef.Name != null && originalDef.Hash == node.NameHash)
{
writer.WriteAttributeString("name", originalDef.Name);
}
else if (def != null && def.Name != null && def.Hash == node.NameHash)
{
writer.WriteAttributeString("name", def.Name);
}
else
{
writer.WriteAttributeString("hash", node.NameHash.ToString("X8"));
}
if (objectFileDef != null &&
string.IsNullOrEmpty(objectFileDef.Name) == false)
{
writer.WriteAttributeString("def", objectFileDef.Name);
}
if (node.Fields != null)
{
foreach (var kv in node.Fields)
{
writer.WriteStartElement("field");
var fieldDef = def != null?def.GetFieldDefinition(kv.Key, chain) : null;
if (fieldDef != null && fieldDef.Name != null && fieldDef.Hash == kv.Key)
{
writer.WriteAttributeString("name", fieldDef.Name);
}
else
{
writer.WriteAttributeString("hash", kv.Key.ToString("X8"));
}
if (fieldDef == null)
{
writer.WriteAttributeString("type", FieldHandling.GetTypeName(FieldType.BinHex));
writer.WriteBinHex(kv.Value, 0, kv.Value.Length);
}
else
{
writer.WriteAttributeString("type", FieldHandling.GetTypeName(fieldDef.Type));
if (fieldDef.ArrayType != FieldType.Invalid)
{
writer.WriteAttributeString("array_type", FieldHandling.GetTypeName(fieldDef.ArrayType));
}
int read;
FieldHandling.Export(fieldDef,
fieldDef.Type,
fieldDef.ArrayType,
kv.Value,
0,
kv.Value.Length,
writer,
out read);
}
writer.WriteEndElement();
}
}
if (def == null || def.DynamicNestedClasses == false)
{
foreach (var childNode in node.Children)
{
var childDef = def != null?def.GetObjectDefinition(childNode.NameHash, chain) : null;
WriteNode(infoManager, writer, chain, childNode, childDef, null);
}
}
else if (def.DynamicNestedClasses == true)
{
foreach (var childNode in node.Children)
{
var childDef = infoManager.GetClassDefinition(childNode.NameHash);
WriteNode(infoManager, writer, chain, childNode, childDef, null);
}
}
writer.WriteEndElement();
}
internal const uint TemplateHash = 0x6E167DD5; // crc32(Template)
public static void MultiExportEntityLibrary(string basePath,
string outputPath,
BinaryObjectFile bof)
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
CheckCharacters = false,
OmitXmlDeclaration = false
};
using (var writer = XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
var root = bof.Root;
{
writer.WriteStartElement("object");
writer.WriteAttributeString("name", "EntityLibraries");
// add version attribute to root object
string bofVersion = bof.Version.ToString();
if (bofVersion != null)
{
writer.WriteAttributeString("version", bofVersion);
}
// add header attribute to root object
string bofHeader = bof.Header;
if (bofHeader.Length > 0)
{
writer.WriteAttributeString("header", bofHeader);
}
var libraryNames = new Dictionary <string, int>();
Directory.CreateDirectory(basePath);
foreach (var library in root.Children)
{
var chain = new[] { bof.Root, library };
var libraryName = FieldHandling.Deserialize <string>(FieldType.String, library.Fields[NameHash]);
var unsanitizedLibraryName = libraryName;
libraryName = libraryName.Replace('/', Path.DirectorySeparatorChar);
libraryName = libraryName.Replace('\\', Path.DirectorySeparatorChar);
libraryName = libraryName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (libraryNames.ContainsKey(libraryName) == false)
{
libraryNames.Add(libraryName, 1);
}
else
{
libraryName = string.Format("{0} ({1})", libraryName, ++libraryNames[libraryName]);
}
var libraryPath = Path.Combine(libraryName, "@library.xml");
writer.WriteStartElement("object");
writer.WriteAttributeString("external", libraryPath);
writer.WriteEndElement();
libraryPath = Path.Combine(basePath, libraryPath);
var itemNames = new Dictionary <string, int>();
var libraryParentPath = Path.GetDirectoryName(libraryPath);
if (string.IsNullOrEmpty(libraryParentPath) == false)
{
Directory.CreateDirectory(libraryParentPath);
}
using (var libraryWriter = XmlWriter.Create(libraryPath, settings))
{
libraryWriter.WriteStartDocument();
libraryWriter.WriteStartElement("object");
libraryWriter.WriteAttributeString("name", "EntityLibrary");
libraryWriter.WriteStartElement("field");
libraryWriter.WriteAttributeString("name", "Name");
libraryWriter.WriteAttributeString("type", "String");
libraryWriter.WriteString(unsanitizedLibraryName);
libraryWriter.WriteEndElement();
foreach (var item in library.Children)
{
var itemName = FieldHandling.Deserialize <string>(FieldType.String, item.Fields[NameHash]);
itemName = itemName.Replace('/', Path.DirectorySeparatorChar);
itemName = itemName.Replace('\\', Path.DirectorySeparatorChar);
itemName = itemName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (itemNames.ContainsKey(itemName) == false)
{
itemNames.Add(itemName, 1);
}
else
{
itemName = string.Format("{0} ({1})", itemName, ++itemNames[itemName]);
}
var itemPath = itemName + ".xml";
libraryWriter.WriteStartElement("object");
libraryWriter.WriteAttributeString("external", itemPath);
libraryWriter.WriteEndElement();
itemPath = Path.Combine(basePath, libraryName, itemPath);
var itemParentPath = Path.GetDirectoryName(itemPath);
if (string.IsNullOrEmpty(itemParentPath) == false)
{
Directory.CreateDirectory(itemParentPath);
}
using (var itemWriter = XmlWriter.Create(itemPath, settings))
{
itemWriter.WriteStartDocument();
WriteNode(itemWriter,
chain,
item);
itemWriter.WriteEndDocument();
}
}
libraryWriter.WriteEndDocument();
}
}
writer.WriteEndElement();
}
writer.WriteEndDocument();
}
}
private static bool ValidateField(KeyValuePair <uint, byte[]> kvCurrent, KeyValuePair <uint, byte[]> kvNext, out FieldInfo overrideFieldInfo)
{
FieldInfo fieldInfo = new FieldInfo();
overrideFieldInfo = fieldInfo;
uint currentKey = kvCurrent.Key;
byte[] currentValue = kvCurrent.Value;
//string currentKeyName = StringHasher.ResolveHash((int)currentKey) ?? $"{currentKey:X8}";
string currentKeyName = "";
string currentValueString = BitConverter.ToString(currentValue).Replace("-", "");
string r_currentKeyName;
if (StringHasher.TryResolveHash((int)currentKey, out r_currentKeyName))
{
currentKeyName = r_currentKeyName;
}
if (kvNext.Value != null && kvNext.Value.Length > 0)
{
uint nextKey = kvNext.Key;
byte[] nextValue = kvNext.Value;
//string nextKeyName = StringHasher.ResolveHash((int) nextKey);
string nextKeyName = "";
string nextValueString = BitConverter.ToString(nextValue).Replace("-", "");
string r_nextKeyName;
if (StringHasher.TryResolveHash((int)nextKey, out r_nextKeyName))
{
nextKeyName = r_nextKeyName;
}
/*
* var textPrefix = "text_";
* var currentKeyGuessName = $"{textPrefix}{nextKeyName}";
* uint currentKeyGuessHash = FileFormats.Hashing.CRC32.Compute(currentKeyGuessName);
*
* if (currentKeyGuessHash == currentKey)
* {
* // current key is text of next key
*
* //Console.WriteLine($"{currentKeyGuessHash:X8} == {currentKey:X8}");
*
* currentValueString = FieldHandling.Deserialize<string>(FieldType.String, currentValue);
* }
*/
FieldType r_currentFieldType;
string r_currentValueString;
if (currentKeyName == "text_hidName")
{
currentValueString = FieldHandling.Deserialize <string>(FieldType.String, currentValue);
Utility.Log("Exporting " + currentValueString);
}
else if (TypeGuesser.TryParse(currentValue, out r_currentFieldType, out r_currentValueString))
{
if (r_currentFieldType == FieldType.String)
{
currentValueString = r_currentValueString;
}
}
uint r_nextValueHash32 = 0;
ulong r_nextValueHash64 = 0;
ulong nextValueHash = 0;
if (uint.TryParse(nextValueString, NumberStyles.HexNumber, null, out r_nextValueHash32))
{
nextValueHash = r_nextValueHash32;
//Console.WriteLine($"Parsing uint: {nextValueHash:X8}");
}
else if (ulong.TryParse(nextValueString, NumberStyles.HexNumber, null, out r_nextValueHash64))
{
nextValueHash = r_nextValueHash64;
//Console.WriteLine($"Parsing ulong: {nextValueHash:X16}");
}
ulong[] hashValues = HashHandler.CollectHashes(currentValueString);
var hashTypeIterator = 0;
for (int b = 0; b < hashValues.Length; b++)
{
ulong hash = hashValues[b];
//Console.WriteLine($"Iterating hash: {hash:X}");
if (hash > 0 && hash == nextValueHash)
{
hashTypeIterator = b;
//Console.WriteLine($"{hash:X} == {nextValueHash:X}");
break;
}
}
ulong resolvedHash = hashValues[hashTypeIterator];
if (hashTypeIterator > 0 && resolvedHash == nextValueHash)
{
// current value is text of next value
//string fieldName = nextKeyName ?? $"{nextValueHash:X8}";
if (string.IsNullOrEmpty(nextKeyName))
{
fieldInfo.key.type = "hash";
fieldInfo.key.name = $"{nextKey:X8}";
}
else
{
fieldInfo.key.type = "name";
fieldInfo.key.name = nextKeyName;
}
fieldInfo.value.type = Convert.ToString((HashType)hashTypeIterator);
fieldInfo.value.value = currentValueString;
Console.WriteLine($"{fieldInfo.key.name} = {currentValueString}");
overrideFieldInfo = fieldInfo;
//Utility.Log($"{fieldName} = \"{currentValueString}\"");
//Utility.Log($"Found text value of field \"{fieldName}\": \"{currentValueString}\"");
//Utility.Log($"Element:\n\tcurrent:\n\t\tname: {currentKey:X8} -> {currentKeyName}\n\t\tvalue: {currentValueString} -> {resolvedHash:X8}\n\tnext:\n\t\tname: {nextKeyName} -> {nextKey:X8}\n\t\tvalue: {nextValueString}");
return(false);
}
}
return(true);
}
public static void MultiExportNomadObjectTemplates(string basePath,
string outputPath,
BinaryObjectFile bof)
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
CheckCharacters = false,
OmitXmlDeclaration = false
};
using (var writer = XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
var root = bof.Root;
var chain = new[] { root };
{
writer.WriteStartElement("object");
writer.WriteAttributeString("name", "NomadObjectTemplates");
Directory.CreateDirectory(basePath);
var itemNames = new Dictionary <string, int>();
foreach (var item in root.Children)
{
var itemName = FieldHandling.Deserialize <string>(FieldType.String, item.Fields[NameHash]);
itemName = itemName.Replace('/', Path.DirectorySeparatorChar);
itemName = itemName.Replace('\\', Path.DirectorySeparatorChar);
itemName = itemName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (itemNames.ContainsKey(itemName) == false)
{
itemNames.Add(itemName, 1);
}
else
{
itemName = string.Format("{0} ({1})", itemName, ++itemNames[itemName]);
}
var itemPath = itemName + ".xml";
writer.WriteStartElement("object");
writer.WriteAttributeString("external", itemPath);
writer.WriteEndElement();
itemPath = Path.Combine(basePath, itemPath);
var itemParentPath = Path.GetDirectoryName(itemPath);
if (string.IsNullOrEmpty(itemParentPath) == false)
{
Directory.CreateDirectory(itemParentPath);
}
using (var itemWriter = XmlWriter.Create(itemPath, settings))
{
itemWriter.WriteStartDocument();
WriteNode(itemWriter,
chain,
item);
itemWriter.WriteEndDocument();
}
}
}
writer.WriteEndDocument();
}
}
public static void MultiExportLibrary(string basePath,
string outputPath,
BinaryObjectFile bof)
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
CheckCharacters = false,
OmitXmlDeclaration = false
};
using (var writer = XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
var root = bof.Root;
var chain = new[] { root };
{
writer.WriteStartElement("object");
writer.WriteAttributeString("name", "lib");
// add version attribute to root object
string bofVersion = bof.Version.ToString();
if (bofVersion != null)
{
writer.WriteAttributeString("version", bofVersion);
}
// add header attribute to root object
string bofHeader = bof.Header;
if (bofHeader.Length > 0)
{
writer.WriteAttributeString("header", bofHeader);
/*
* var headerBytes = Utility.HexToBytes(bofHeader);
* var headerBytesString = BitConverter.ToString(headerBytes).Replace("-", "");
*
* Console.WriteLine($"Test = {headerBytesString}");
*/
}
Directory.CreateDirectory(basePath);
var itemNames = new Dictionary <string, int>();
foreach (var item in root.Children)
{
var itemName = FieldHandling.Deserialize <string>(FieldType.String, item.Fields[TextHidNameHash]);
itemName = itemName.Replace('/', Path.DirectorySeparatorChar);
itemName = itemName.Replace('\\', Path.DirectorySeparatorChar);
itemName = itemName.Replace('"', '_').Replace(':', '_').Replace('*', '_').Replace('?', '_').Replace('<', '_').Replace('>', '_').Replace('|', '_');
if (!itemNames.ContainsKey(itemName))
{
itemNames.Add(itemName, 1);
}
else
{
itemName = string.Format("{0} ({1})", itemName, ++itemNames[itemName]);
}
var itemPath = itemName + ".xml";
writer.WriteStartElement("object");
writer.WriteAttributeString("external", itemPath);
writer.WriteEndElement();
itemPath = Path.Combine(basePath, itemPath);
var itemParentPath = Path.GetDirectoryName(itemPath);
if (string.IsNullOrEmpty(itemParentPath) == false)
{
Directory.CreateDirectory(itemParentPath);
}
using (var itemWriter = XmlWriter.Create(itemPath, settings))
{
itemWriter.WriteStartDocument();
WriteNode(itemWriter,
chain,
item);
itemWriter.WriteEndDocument();
}
}
}
writer.WriteEndDocument();
}
}
