public static bool IsSuitableForNomadObjectTemplatesMultiExport(BinaryObjectFile bof)
{
if (bof.Root.Fields.Count != 0 ||
bof.Root.NameHash != NomadObjectTemplatesHash ||
bof.Root.Children.Any(c => c.NameHash != NomadObjectTemplateHash) == true)
{
return(false);
}
var nameSeq = new[] { NameHash };
foreach (var library in bof.Root.Children)
{
if (library.Fields.Keys.SequenceEqual(nameSeq) == false)
{
return(false);
}
if (library.Children.Any(sc => sc.NameHash != TemplateHash) == true)
{
return(false);
}
}
return(true);
}
public static void Export(ObjectFileDefinition objectFileDef,
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 &&
objectFileDef.Object.Hash == bof.Root.NameHash
? objectFileDef.Object
: null;
using (var writer = XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
WriteNode(infoManager, writer, new BinaryObject[0], bof.Root, objectDef, objectFileDef);
writer.WriteEndDocument();
}
}
public static bool IsSuitableForLibraryMultiExport(BinaryObjectFile bof)
{
return(bof.Root.Fields.Count == 0 &&
bof.Root.NameHash == LibHash &&
bof.Root.Children.Any(c => c.NameHash != LibItemHash ||
c.Fields.ContainsKey(TextHidNameHash) == false) == false);
}
private static void WriteRootNode(XmlWriter writer,
IEnumerable <BinaryObject> parentChain,
BinaryObjectFile bof)
{
BinaryObject node = bof.Root;
var chain = parentChain.Concat(new[] { node });
writer.WriteStartElement("object");
// get object name from object hash via string list
var objectHashInput = (int)node.NameHash;
if (StringHasher.CanResolveHash(objectHashInput))
{
var objectHashOutput = StringHasher.ResolveHash(objectHashInput);
writer.WriteAttributeString("name", objectHashOutput);
}
else
{
writer.WriteAttributeString("hash", node.NameHash.ToString("X8"));
}
// 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);
}
WriteNodeField(writer, node);
foreach (var childNode in node.Children)
{
WriteNode(writer, chain, childNode);
}
writer.WriteEndElement();
}
public static void Export(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();
WriteRootNode(writer, new BinaryObject[0], bof);
writer.WriteEndDocument();
}
}
public static bool IsSuitableForEntityLibraryMultiExport(BinaryObjectFile bof)
{
if (bof.Root.Fields.Count != 0 ||
bof.Root.NameHash != EntityLibrariesHash ||
bof.Root.Children.Any(c => c.NameHash != EntityLibraryHash) == true)
{
return(false);
}
var nameSeq = new[] { NameHash };
var idAndNameSeq = new[] { DisLibItemIdHash, NameHash };
foreach (var library in bof.Root.Children)
{
if (library.Fields.Keys.SequenceEqual(nameSeq) == false)
{
return(false);
}
if (library.Children.Any(sc => sc.NameHash != EntityLibraryItemHash) == true)
{
return(false);
}
foreach (var item in library.Children)
{
if (item.Fields.Keys.OrderBy(h => h).SequenceEqual(idAndNameSeq) == false)
{
return(false);
}
if (item.Children.Any(sc => sc.NameHash != EntityHash) == true)
{
return(false);
}
}
}
return(true);
}
private static void Main(string[] args)
{
var mode = Mode.Unknown;
string baseName = "";
bool showHelp = false;
bool verbose = false;
bool useMultiExporting = true;
var options = new OptionSet()
{
{ "i|import|fcb", "convert XML to FCB", v => mode = v != null ? Mode.Import : mode },
{ "e|export|xml", "convert FCB to XML", v => mode = v != null ? Mode.Export : mode },
{ "b|base-name=", "when converting, use specified base name instead of file name", v => baseName = v },
{
"nme|no-multi-export", "when exporting, disable multi-exporting of entitylibrary and lib files",
v => useMultiExporting = v == null
},
{ "v|verbose", "be verbose", v => verbose = v != null },
{ "h|help", "show this message and exit", v => showHelp = v != null },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (mode == Mode.Unknown &&
extras.Count >= 1)
{
var extension = Path.GetExtension(extras[0]);
if (string.IsNullOrEmpty(extension) == false)
{
extension = extension.ToLowerInvariant();
}
if (extension == ".fcb" ||
extension == ".obj" ||
extension == ".lib")
{
mode = Mode.Export;
}
else if (extension == ".xml")
{
mode = Mode.Import;
}
}
if (showHelp == true ||
mode == Mode.Unknown ||
extras.Count < 1 ||
extras.Count > 2)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ input [output]", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
if (verbose == true)
{
Console.WriteLine("Loading project...");
}
var manager = ProjectData.Manager.Load();
if (manager.ActiveProject == null)
{
Console.WriteLine("Warning: no active project loaded.");
return;
}
var project = manager.ActiveProject;
if (verbose == true)
{
Console.WriteLine("Loading binary class and object definitions...");
}
BinaryObjectInfo.InfoManager infoManager;
if (System.Diagnostics.Debugger.IsAttached == false)
{
try
{
infoManager = BinaryObjectInfo.InfoManager.Load(project.ListsPath);
}
catch (BinaryObjectInfo.LoadException e)
{
Console.WriteLine("Failed to load binary definitions!");
Console.WriteLine(" {0}", e.Message);
return;
}
catch (BinaryObjectInfo.XmlLoadException e)
{
Console.WriteLine("Failed to load binary definitions!");
Console.WriteLine(" in \"{0}\"", e.FilePath);
Console.WriteLine(" {0}", e.Message);
return;
}
catch (Exception e)
{
Console.WriteLine("Exception while loading binary definitions!");
Console.WriteLine();
Console.WriteLine("{0}", e);
return;
}
}
else
{
infoManager = BinaryObjectInfo.InfoManager.Load(project.ListsPath);
}
if (mode == Mode.Import)
{
string inputPath = extras[0];
string outputPath;
if (extras.Count > 1)
{
outputPath = extras[1];
}
else
{
outputPath = Path.ChangeExtension(inputPath, null);
outputPath += "_converted.fcb";
}
var basePath = Path.ChangeExtension(inputPath, null);
inputPath = Path.GetFullPath(inputPath);
outputPath = Path.GetFullPath(outputPath);
basePath = Path.GetFullPath(basePath);
var bof = new BinaryObjectFile();
using (var input = File.OpenRead(inputPath))
{
var doc = new XPathDocument(input);
var nav = doc.CreateNavigator();
var root = nav.SelectSingleNode("/object");
if (root == null)
{
throw new FormatException();
}
if (string.IsNullOrEmpty(baseName) == true)
{
var baseNameFromObject = root.GetAttribute("def", "");
if (string.IsNullOrEmpty(baseNameFromObject) == false)
{
baseName = baseNameFromObject;
}
else
{
baseName = GetBaseNameFromPath(inputPath);
}
}
if (verbose == true)
{
Console.WriteLine("Reading XML...");
}
var objectFileDef = infoManager.GetObjectFileDefinition(baseName);
if (objectFileDef == null)
{
Console.WriteLine("Warning: could not find binary object file definition '{0}'", baseName);
}
var importing = new Importing(infoManager);
var classDef = objectFileDef != null ? objectFileDef.Object : null;
bof.Root = importing.Import(classDef, basePath, root);
}
if (verbose == true)
{
Console.WriteLine("Writing FCB...");
}
using (var output = File.Create(outputPath))
{
bof.Serialize(output);
}
}
else if (mode == Mode.Export)
{
HashFinder.Load(manager.ActiveProject.ListsPath);
string inputPath = extras[0];
string outputPath;
string basePath;
if (extras.Count > 1)
{
outputPath = extras[1];
basePath = Path.ChangeExtension(outputPath, null);
}
else
{
outputPath = Path.ChangeExtension(inputPath, null);
outputPath += "_converted";
basePath = outputPath;
outputPath += ".xml";
}
if (string.IsNullOrEmpty(baseName) == true)
{
baseName = GetBaseNameFromPath(inputPath);
}
if (string.IsNullOrEmpty(baseName) == true)
{
throw new InvalidOperationException();
}
inputPath = Path.GetFullPath(inputPath);
outputPath = Path.GetFullPath(outputPath);
basePath = Path.GetFullPath(basePath);
var objectFileDef = infoManager.GetObjectFileDefinition(baseName);
if (objectFileDef == null)
{
Console.WriteLine("Warning: could not find binary object file definition '{0}'", baseName);
}
if (verbose == true)
{
Console.WriteLine("Reading FCB...");
}
var bof = new BinaryObjectFile();
using (var input = File.OpenRead(inputPath))
{
bof.Deserialize(input);
}
if (verbose == true)
{
Console.WriteLine("Writing XML...");
}
if (useMultiExporting == true &&
Exporting.IsSuitableForEntityLibraryMultiExport(bof) == true)
{
Exporting.MultiExportEntityLibrary(objectFileDef, basePath, outputPath, infoManager, bof);
}
else if (useMultiExporting == true &&
Exporting.IsSuitableForLibraryMultiExport(bof) == true)
{
Exporting.MultiExportLibrary(objectFileDef, basePath, outputPath, infoManager, bof);
}
else if (useMultiExporting == true &&
Exporting.IsSuitableForNomadObjectTemplatesMultiExport(bof) == true)
{
Exporting.MultiExportNomadObjectTemplates(objectFileDef, basePath, outputPath, infoManager, bof);
}
else
{
Exporting.Export(objectFileDef, outputPath, infoManager, bof);
}
}
else
{
throw new InvalidOperationException();
}
}
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 = FieldTypeDeserializers.Deserialize <string>(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 =
FieldTypeDeserializers.Deserialize <string>(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();
}
}
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();
}
}
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();
}
}
private static void Main(string[] args)
{
var mode = Mode.Unknown;
string baseName = "";
bool showHelp = false;
bool verbose = false;
bool useMultiExporting = true;
var options = new OptionSet()
{
{ "i|import|fcb", "convert XML to FCB", v => mode = v != null ? Mode.Import : mode },
{ "e|export|xml", "convert FCB to XML", v => mode = v != null ? Mode.Export : mode },
{ "b|base-name=", "when converting, use specified base name instead of file name", v => baseName = v },
{
"nme|no-multi-export", "when exporting, disable multi-exporting of entitylibrary and lib files",
v => useMultiExporting = v == null
},
{ "v|verbose", "be verbose", v => verbose = v != null },
{ "h|help", "show this message and exit", v => showHelp = v != null },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (mode == Mode.Unknown && extras.Count >= 1)
{
var extension = Path.GetExtension(extras[0]);
if (!string.IsNullOrEmpty(extension))
{
extension = extension.ToLowerInvariant();
}
if (extension == ".xml")
{
mode = Mode.Import;
}
else
{
mode = Mode.Export;
}
}
if (showHelp || mode == Mode.Unknown || extras.Count < 1 || extras.Count > 2)
{
Console.WriteLine("Usage: {0} [OPTIONS]+ input [output]", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
// custom
Prepare();
if (mode == Mode.Import)
{
string inputPath = extras[0];
string outputPath;
if (extras.Count > 1)
{
outputPath = extras[1];
}
else
{
outputPath = RemoveConverted(Path.ChangeExtension(inputPath, null));
if (string.IsNullOrEmpty(Path.GetExtension(outputPath)))
{
var filename = Path.GetFileName(outputPath);
if (new Regex(@".+_[0-9a-fA-F]{8}").IsMatch(filename))
{
outputPath += ".obj";
}
else
{
outputPath += ".lib";
}
}
}
// Twice to remove *.lib.xml
var basePath = Path.ChangeExtension(Path.ChangeExtension(inputPath, null), null);
inputPath = Path.GetFullPath(inputPath);
outputPath = Path.GetFullPath(outputPath);
basePath = Path.GetFullPath(basePath);
var bof = new BinaryObjectFile();
using (var input = File.OpenRead(inputPath))
{
var header = "";
var version = "";
var doc = new XPathDocument(input);
var nav = doc.CreateNavigator();
var root = nav.SelectSingleNode("/object");
if (root == null)
{
throw new FormatException();
}
version = root.GetAttribute("version", "");
bof.Version = (ushort)Convert.ToInt32(version);
Utility.Log($"Imported version = {version}");
header = root.GetAttribute("header", "");
bof.Header = header;
Utility.Log($"Imported header = {header}");
baseName = GetBaseNameFromPath(inputPath);
if (verbose)
{
Console.WriteLine("Reading XML...");
}
var importing = new Importing();
bof.Root = importing.Import(basePath, root);
}
if (verbose)
{
Console.WriteLine("Writing FCB...");
}
using (var output = File.Create(outputPath))
{
bof.Serialize(output);
}
}
else if (mode == Mode.Export)
{
string inputPath = extras[0];
string outputPath;
string basePath;
if (extras.Count > 1)
{
outputPath = extras[1];
basePath = Path.ChangeExtension(outputPath, null);
}
else
{
basePath = Path.ChangeExtension(inputPath, null);
outputPath = inputPath + ".xml";
}
if (string.IsNullOrEmpty(baseName))
{
baseName = GetBaseNameFromPath(inputPath);
}
if (string.IsNullOrEmpty(baseName))
{
throw new InvalidOperationException();
}
inputPath = Path.GetFullPath(inputPath);
outputPath = Path.GetFullPath(outputPath);
basePath = Path.GetFullPath(basePath);
if (verbose)
{
Console.WriteLine("Reading FCB...");
}
var bof = new BinaryObjectFile();
using (var input = File.OpenRead(inputPath))
{
bof.Deserialize(input);
}
if (verbose)
{
Console.WriteLine("Writing XML...");
}
if (useMultiExporting && Exporting.IsSuitableForEntityLibraryMultiExport(bof))
{
Exporting.MultiExportEntityLibrary(basePath, outputPath, bof);
}
else if (useMultiExporting && Exporting.IsSuitableForLibraryMultiExport(bof))
{
Exporting.MultiExportLibrary(basePath, outputPath, bof);
}
else if (useMultiExporting && Exporting.IsSuitableForNomadObjectTemplatesMultiExport(bof))
{
Exporting.MultiExportNomadObjectTemplates(basePath, outputPath, bof);
}
else
{
Exporting.Export(outputPath, bof);
}
}
}
