Example #1
0
 public static int ShowVersion(MBINFile mbin, bool quiet = false)
 {
     using (var forceConsole = new ForceConsoleOutput()) {
         Logger.LogInfo(Version.GetVersionString(mbin, quiet));
     }
     return(0);
 }
Example #2
0
        static void DecompileFile(string input, string output)
        {
            if (String.IsNullOrEmpty(output))
            {
                output = Path.ChangeExtension(input, ".exml"); // emoose XML, because there's no way this XML format is compatible with MXML
            }
            if (File.Exists(output))
            {
                File.Delete(output); // todo: ask for confirmation?
            }
            // no error checking ^^ (todo: error checking)
            var file = new MBINFile(input);

            file.Load();

            var data = file.GetData();

            if (data == null)
            {
                Console.WriteLine($"Failed to deserialize template \"{file.Header.GetXMLTemplateName()}\", has the structure been mapped yet?");
                return;
            }

            var xmlString = EXmlFile.WriteTemplate(data);

            if (string.IsNullOrEmpty(xmlString))
            {
                Console.WriteLine($"Error serializing template \"{file.Header.GetXMLTemplateName()}\" to XML!");
                return;
            }

            File.WriteAllText(output, xmlString);
            Console.WriteLine($"XML data written to \"{output}\" successfully?");
        }
Example #3
0
        private static int HandleVersionMode(CommandLineParser options)
        {
            var files = options.GetFileParams();

            if (files.Count == 0)
            {
                return(CommandLine.ShowVersion(Quiet));
            }
            if (files.Count > 1)
            {
                return(CommandLine.ShowInvalidCommandLineArg(files[1]));
            }

            var fIn  = new FileStream(files[0], FileMode.Open, FileAccess.Read);
            var mbin = new MBINFile(fIn);

            if (!mbin.Load() || !mbin.Header.IsValid)
            {
                return(CommandLine.ShowCommandLineError("Invalid file type.\n" +
                                                        "Only MBIN files can be versioned.\n" +
                                                        $"\"{files[0]}\""));
            }

            CommandLine.ShowVersion(mbin, Quiet);
            return((int)ErrorCode.Success);
        }
Example #4
0
 // TODO: (GH) not used
 static void ScanMBINs(string path, ref List <string> types)
 {
     foreach (var file in Directory.GetFiles(path, "*.mbin*"))
     {
         var mbin = new MBINFile(file);
         mbin.Load();
         types.Add($"{file} : {mbin.Header.GetXMLTemplateName()}");
     }
     foreach (var folder in Directory.GetDirectories(path))
     {
         ScanMBINs(folder, ref types);
     }
 }
Example #5
0
        static void CompileFile(string inputPath, string outputPath)
        {
            outputPath = String.IsNullOrEmpty(outputPath) ? inputPath : outputPath;

            outputPath = Path.ChangeExtension(outputPath, ".MBIN");

            var data = EXmlFile.ReadTemplate(inputPath);

            if (data == null)
            {
                Console.WriteLine("Failed to deserialize EXML file, is it formatted correctly?");
                return;
            }

            if (data.GetType() == typeof(TkGeometryData))
            {
                outputPath = Path.ChangeExtension(outputPath, ".MBIN.PC");
            }

            if (File.Exists(outputPath))
            {
                File.Delete(outputPath);   // todo: ask for confirmation?
            }

            using (var file = new MBINFile(outputPath)) {
                file.Header = new MBINHeader();
                file.Header.SetDefaults();
                if (data.GetType() == typeof(TkGeometryData))
                {
                    file.Header.Magic = 0xDDDDDDDD; // only used by TkGeometryData / .MBIN.PC files, maybe used to signal the file is PC only?
                }
                if (data.GetType() == typeof(TkAnimMetadata))
                {
                    file.Header.Tag         = 0xFFFFFFFFFFFFFFFF;
                    file.Header.MbinVersion = 0x9B251350AE1ABCA7;
                    file.Header.EndPadding  = 0xFEFEFEFEFEFEFEFE;
                }

                file.SetData(data);         // this will also get the length of the data

                if (data.GetType() != typeof(TkAnimMetadata))
                {
                    file.Header.EndPadding = file.FileLength;
                }

                file.Save();
            }

            Console.WriteLine($"MBIN data written to \"{outputPath}\" successfully?");
        }
Example #6
0
        /// <summary>Get the version info for a specified MBIN <paramref name="mbin"/>.</summary>
        /// <param name="mbin">The MBIN file to display the version info for.</param>
        /// <param name="quiet">
        ///     If true then a plain, script-friendly version string is displayed.
        ///     If false then a human-friendly message is displayed.
        /// </param>
        public static string GetVersionString(MBINFile mbin = null, bool quiet = false)
        {
            if (mbin == null)
            {
                return(GetVersionString(quiet));
            }

            System.Version mbinVersion   = mbin.Header.GetMBINVersion();
            string         versionString = mbinVersion.ToString();

            return(!quiet
                ? (versionString != "0.0.0.0")
                ? "Compiled with MBINCompiler v" + versionString
                : "Unknown MBIN version!\nNot compiled by MBINCompiler."
                : versionString);
        }
Example #7
0
        static void ShowMBINVersion(MBINFile file, bool verbose = false)
        {
            System.Version mbinVersion   = file.Header.GetMBINVersion();
            string         versionString = mbinVersion.ToString();

            if (verbose)
            {
                if (versionString != "0.0.0.0")
                {
                    versionString = "Compiled with MBINCompiler v" + versionString;
                }
                else
                {
                    versionString = "Unknown MBIN version!\nNot compiled by MBINCompiler.";
                }
            }
            Console.WriteLine(versionString);
        }
Example #8
0
        static void DecompileFile(string inputPath, string outputPath, bool getVersion = false, bool verbose = false)
        {
            outputPath = String.IsNullOrEmpty(outputPath) ? inputPath : outputPath;

            if (Path.GetExtension(outputPath) == ".PC")
            {
                outputPath = Path.GetFileNameWithoutExtension(outputPath); // remove the ".PC"
            }
            outputPath = Path.ChangeExtension(outputPath, ".exml");        // emoose XML, because there's no way this XML format is compatible with MXML

            if (File.Exists(outputPath))
            {
                File.Delete(outputPath);   // todo: ask for confirmation?
            }

            // no error checking ^^ (todo: error checking)
            var file = new MBINFile(inputPath);

            file.Load( );

            if (getVersion)
            {
                ShowMBINVersion(file, verbose);
            }
            else
            {
                var data = file.GetData();
                if (data == null)
                {
                    Console.WriteLine($"Failed to deserialize template \"{file.Header.GetXMLTemplateName()}\", has the structure been mapped yet?");
                    return;
                }

                var xmlString = EXmlFile.WriteTemplate(data);
                if (string.IsNullOrEmpty(xmlString))
                {
                    Console.WriteLine($"Error serializing template \"{file.Header.GetXMLTemplateName()}\" to XML!");
                    return;
                }
                File.WriteAllText(outputPath, xmlString);
                Console.WriteLine($"XML data written to \"{outputPath}\" successfully?");
            }
        }
Example #9
0
        static void CompileFile(string input, string output)
        {
            if (String.IsNullOrEmpty(output))
            {
                output = input;
            }

            output = Path.ChangeExtension(output, ".MBIN");

            var data = EXmlFile.ReadTemplate(input);

            if (data == null)
            {
                Console.WriteLine("Failed to deserialize EXML file, is it formatted correctly?");
                return;
            }

            if (data.GetType() == typeof(Models.Structs.TkGeometryData))
            {
                output = Path.ChangeExtension(output, ".MBIN.PC");
            }

            if (File.Exists(output))
            {
                File.Delete(output); // todo: ask for confirmation?
            }
            using (var file = new MBINFile(output))
            {
                file.Header = new Models.MBINHeader();
                file.Header.SetDefaults();
                if (data.GetType() == typeof(Models.Structs.TkGeometryData))
                {
                    file.Header.Magic = 0xDDDDDDDD; // only used by TkGeometryData / .MBIN.PC files, maybe used to signal the file is PC only?
                }
                file.SetData(data);
                file.Save();
            }

            Console.WriteLine($"MBIN data written to \"{output}\" successfully?");
        }
 public MbinException(string message, Exception innerException, MBINFile mbin) : this(message, innerException, "", mbin)
 {
 }
 public MbinException(Exception innerException, string fileName, MBINFile mbin) : this(DEFAULT_MESSAGE, innerException, fileName, mbin)
 {
 }
 public MbinException(Exception innerException, MBINFile mbin) : this(DEFAULT_MESSAGE, innerException, "", mbin)
 {
 }
 public MbinException(string message, string fileName, MBINFile mbin) : this(message, null, fileName, mbin)
 {
 }
 public MbinException(string message, MBINFile mbin) : this(message, null, "", mbin)
 {
 }
Example #15
0
        public static void ConvertFile(string fileIn, string fileOut, FormatType inputFormat, FormatType outputFormat)
        {
            fileOut = ChangeFileExtension(fileOut, outputFormat);

            FileMode fileMode = GetFileMode(fileOut);

            Directory.CreateDirectory(Path.GetDirectoryName(fileOut));

            try {
                using (var indentScope = new Logger.IndentScope())
                    using (var fIn = new FileStream(fileIn, FileMode.Open, FileAccess.Read))
                        using (var ms = new MemoryStream()) {
                            if (inputFormat == FormatType.MBIN)
                            {
                                var mbin = new MBINFile(fIn);
                                if (!mbin.Load() || !mbin.Header.IsValid)
                                {
                                    throw new InvalidDataException("Not a valid MBIN file!");
                                }

                                var sw = new StreamWriter(ms);

                                NMSTemplate data = null;
                                try {
                                    data = mbin.GetData();
                                    if (data is null)
                                    {
                                        throw new InvalidDataException("Invalid MBIN data.");
                                    }
                                } catch (Exception e) {
                                    throw new MbinException($"Failed to read {mbin.Header.GetXMLTemplateName()} from MBIN.", e, fileIn, mbin);
                                }

                                try {
                                    sw.Write(EXmlFile.WriteTemplate(data));
                                    sw.Flush();
                                    if (ms.Length == 0)
                                    {
                                        throw new InvalidDataException("Invalid EXML data.");
                                    }
                                } catch (Exception e) {
                                    throw new MbinException($"Failed serializing {mbin.Header.GetXMLTemplateName()} to EXML.", e, fileIn, mbin);
                                }
                            }
                            else if (inputFormat == FormatType.EXML)
                            {
                                NMSTemplate data = null;
                                try {
                                    data = EXmlFile.ReadTemplateFromStream(fIn);
                                    if (data is null)
                                    {
                                        throw new InvalidDataException($"Failed to deserialize EXML.");
                                    }
                                    if (data is TkGeometryData)
                                    {
                                        fileOut += ".PC";
                                    }
                                    var mbin = new MBINFile(ms)
                                    {
                                        Header = new MBINHeader()
                                    };
                                    mbin.Header.SetDefaults(data.GetType());
                                    mbin.SetData(data);
                                    mbin.Save();
                                } catch (Exception e) {
                                    throw new ExmlException(e, fileIn, data);
                                }
                            }

                            ms.Flush();
                            using (var fOut = new FileStream(fileOut, fileMode, FileAccess.Write)) ms.WriteTo(fOut);
                        }
            } catch (Exception e) {
                File.Delete(fileOut);
                if (e is CompilerException)
                {
                    throw;
                }
                throw new CompilerException(e, fileIn);
            }
        }
 public MbinException(string message, Exception innerException, string fileName, MBINFile mbin) : base(message, innerException, fileName)
 {
     this.Mbin = mbin;
 }
Example #17
0
        private static bool AutoDetectFormat(List <string> fileList)
        {
            // detect what types of file formats are found
            bool foundMBIN = false;
            bool foundEXML = false;

            foreach (var file in fileList)
            {
                if (Path.HasExtension(file))
                {
                    var ext = Path.GetExtension(file).ToUpper();
                    foundMBIN |= (ext == ".MBIN") || (ext == ".PC");
                    foundEXML |= (ext == ".EXML");
                }
            }

            // TODO: this should be handled better
            if (!foundMBIN && !foundEXML)
            {
                if ((fileList.Count == 1) && File.Exists(fileList[0]))
                {
                    using (var fIn = new FileStream(fileList[0], FileMode.Open)) {
                        // possibly MBIN? check for a valid header
                        using (var mbin = new MBINFile(fIn, true)) foundMBIN = (mbin.Load() && mbin.Header.IsValid);
                        if (!foundMBIN)     // possibly EXML? check for a valid xml tag
                        {
                            var xmlTag = "<?xml version=\"1.0\" encoding=\"utf-8\"?>".ToLower();
                            var bytes  = new byte[xmlTag.Length];
                            // TODO: handle potential leading whitespace?
                            if (fIn.Read(bytes, 0, xmlTag.Length) == xmlTag.Length)
                            {
                                var txt = System.Text.Encoding.ASCII.GetString(bytes).ToLower();
                                foundEXML = (txt == xmlTag);
                            }
                        }
                    }
                }
            }

            if (foundMBIN && foundEXML)
            {
                const string msg = "Unable to automatically determine the --input-format type.";
                if (Quiet)
                {
                    return(CommandLine.ShowError(msg) == (int)ErrorCode.Success);
                }
                CommandLine.ShowWarning(msg);
                Console.Out.WriteLine("Both MBIN and EXML file types were detected!\n");
                InputFormat = Utils.PromptInputFormat();
                Console.Out.WriteLine();
            }
            else if (foundMBIN)
            {
                Logger.LogInfo("Auto-Detected --input-format=MBIN\n");
                InputFormat = FormatType.MBIN;
            }
            else if (foundEXML)
            {
                Logger.LogInfo("Auto-Detected --input-format=EXML\n");
                InputFormat = FormatType.EXML;
            }
            else
            {
                CommandLine.ShowError("No valid files found!");
                return(false);
            }

            OutputFormat = (InputFormat == FormatType.MBIN) ? FormatType.EXML : FormatType.MBIN;
            Logger.LogDebug($"--input-format={InputFormat} --output-format={OutputFormat}\n");

            return(true);
        }
Example #18
0
 public static string GetFileInfo(MBINFile mbin)
 {
     return($"MBIN\tversion:\t{mbin.Header.GetMBINVersion()}\tguid:\t{mbin.Header.TemplateGUID:X}\ttemplate:\t{mbin.Header.TemplateName}");
 }
 public MbinException(string message, string fileName, MBINFile mbin) : base(message, null, fileName)
 {
 }