Exemple #1
0
        private string extractIros(string iroFile, string path)
        {
            bPreview.Enabled = false;
            _7thWrapperLib.IrosArc iro = new _7thWrapperLib.IrosArc(iroFile);
            var sw = new System.Diagnostics.Stopwatch();

            sw.Start();
            string filter = path;
            string fn     = "";

            foreach (string file in iro.AllFileNames())
            {
                if (!String.IsNullOrEmpty(filter) && (file.IndexOf(filter) < 0))
                {
                    continue;
                }
                byte[] data = iro.GetBytes(file);
                fn = System.IO.Path.Combine(System.IO.Path.GetTempPath(), file);
                System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
                System.IO.File.WriteAllBytes(fn, data);
            }
            sw.Stop();
            bPreview.Enabled = true;
            return(fn);
        }
Exemple #2
0
            private void ProcessDownload(object state)
            {
                try {
                    string source = System.IO.Path.Combine(Sys.Settings.LibraryLocation, "temp", File);
                    _dest = System.IO.Path.Combine(Sys.Settings.LibraryLocation, File);
                    byte[] sig = new byte[4];
                    using (var iro = new _7thWrapperLib.IrosArc(source, true)) {
                        if (!iro.CheckValid())
                        {
                            throw new Exception("IRO archive appears to be invalid: corrupted download?");
                        }
                        if (!Controller.WaitForPatches())
                        {
                            throw new Exception("Failed to acquire patches");
                        }

                        int numPatch = Controller.PatchFiles.Count;
                        int pDone    = 0;
                        foreach (string pfile in Controller.PatchFiles)
                        {
                            string patchfile = System.IO.Path.Combine(Sys.Settings.LibraryLocation, "temp", pfile);
                            using (var patch = new _7thWrapperLib.IrosArc(patchfile)) {
                                iro.ApplyPatch(patch, (d, _) => SetPCComplete((int)((100 / numPatch) * pDone + 100 * d / numPatch)));
                            }
                            pDone++;
                        }
                    }
                    System.IO.File.Move(source, _dest);
                } catch (Exception e) {
                    Error(e);
                    return;
                }
                SetPCComplete(100);
                Complete();
            }
Exemple #3
0
        void bw_Patch(object sender, DoWorkEventArgs e)
        {
            PatchOp patch = (PatchOp)e.Argument;

            using (var orig = new _7thWrapperLib.IrosArc(patch.OrigFile, true)) {
                using (var newiro = new _7thWrapperLib.IrosArc(patch.NewFile)) {
                    using (var fs = new System.IO.FileStream(patch.SaveFile, System.IO.FileMode.Create))
                        _7thWrapperLib.IrosPatcher.Create(orig, newiro, fs, patch.Compress, IroProgress);
                }
            }
        }
        public _7thWrapperLib.RuntimeMod GetRuntime(_7thWrapperLib.LoaderContext context)
        {
            var mod = Sys.Library.GetItem(ModID);

            if (mod == null)
            {
                return(null);
            }
            string location = System.IO.Path.Combine(Sys.Settings.LibraryLocation, mod.LatestInstalled.InstalledLocation);

            _7thWrapperLib.ModInfo modinfo = null;
            if (mod.LatestInstalled.InstalledLocation.EndsWith(".iro"))
            {
                using (var arc = new _7thWrapperLib.IrosArc(location)) {
                    if (arc.HasFile("mod.xml"))
                    {
                        var doc = new System.Xml.XmlDocument();
                        doc.Load(arc.GetData("mod.xml"));
                        modinfo = new _7thWrapperLib.ModInfo(doc, context);
                    }
                }
            }
            else
            {
                string mfile = System.IO.Path.Combine(location, "mod.xml");
                if (System.IO.File.Exists(mfile))
                {
                    modinfo = new _7thWrapperLib.ModInfo(mfile, context);
                }
            }
            modinfo = modinfo ?? new _7thWrapperLib.ModInfo();

            foreach (var opt in modinfo.Options)
            {
                if (!Settings.Any(s => s.ID.Equals(opt.ID, StringComparison.InvariantCultureIgnoreCase)))
                {
                    Settings.Add(new ProfileSetting()
                    {
                        ID = opt.ID, Value = opt.Default
                    });
                }
            }

            return(new _7thWrapperLib.RuntimeMod(
                       location,
                       modinfo.Conditionals.Where(f => IsActive(f.ActiveWhen)),
                       modinfo.ModFolders.Where(f => IsActive(f.ActiveWhen)).Select(f => f.Folder),
                       modinfo.LoadLibraries,
                       modinfo.LoadAssemblies,
                       modinfo.LoadPlugins
                       ));
        }
Exemple #5
0
        void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            IroOp            io = e.Argument as IroOp;
            BackgroundWorker bw = sender as BackgroundWorker;

            using (var arc = new _7thWrapperLib.IrosArc(io.Iro)) {
                var files = arc.AllFileNames().ToList();
                int count = 0;
                foreach (string file in files)
                {
                    string path = System.IO.Path.Combine(io.Folder, file);
                    System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
                    System.IO.File.WriteAllBytes(path, arc.GetBytes(file));
                    count++;
                    IroProgress(1.0 * count / files.Count, file);
                }
            }
        }
Exemple #6
0
        internal Task UnpackIro()
        {
            string pathToOutput = PathToOutputFolder;
            string pathToIro    = PathToIroFile;

            IsUnpacking = true;

            Task unpackTask = Task.Factory.StartNew(() =>
            {
                using (_7thWrapperLib.IrosArc arc = new _7thWrapperLib.IrosArc(pathToIro))
                {
                    List <string> files = arc.AllFileNames().ToList();
                    int count           = 0;
                    foreach (string file in files)
                    {
                        string path = Path.Combine(pathToOutput, file);

                        Directory.CreateDirectory(Path.GetDirectoryName(path));
                        File.WriteAllBytes(path, arc.GetBytes(file));

                        count++;
                        IroProgress(1.0 * count / files.Count, file);
                    }
                }
            });

            unpackTask.ContinueWith((result) =>
            {
                IsUnpacking   = false;
                ProgressValue = 0;

                if (result.IsFaulted)
                {
                    Logger.Warn(result.Exception.GetBaseException());
                    StatusText = $"An error occured while unpacking: {result.Exception.GetBaseException().Message}";
                    return;
                }

                StatusText = "Unpacking complete!";
            });

            return(unpackTask);
        }
        public System.IO.Stream GetData(string name)
        {
            string path = System.IO.Path.Combine(Sys.Settings.LibraryLocation, InstalledLocation);

            if (InstalledLocation.EndsWith(".iro", StringComparison.InvariantCultureIgnoreCase) && System.IO.File.Exists(path))
            {
                using (var arc = new _7thWrapperLib.IrosArc(path))
                    return(arc.GetData(name));
            }
            else
            {
                path = System.IO.Path.Combine(path, name);
                if (System.IO.File.Exists(path))
                {
                    return(new System.IO.FileStream(path, System.IO.FileMode.Open, System.IO.FileAccess.Read));
                }
            }
            return(null);
        }
Exemple #8
0
            private void ProcessDownload(object state)
            {
                string patchfile = System.IO.Path.Combine(Sys.Settings.LibraryLocation, "temp", File);

                try {
                    string source = System.IO.Path.Combine(Sys.Settings.LibraryLocation, Install.LatestInstalled.InstalledLocation);
                    using (var iro = new _7thWrapperLib.IrosArc(source, true)) {
                        using (var patch = new _7thWrapperLib.IrosArc(patchfile)) {
                            iro.ApplyPatch(patch, (d, _) => SetPCComplete((int)(100 * d)));
                        }
                    }
                } catch (Exception e) {
                    Error(e);
                    return;
                }
                Sys.Library.QueuePendingDelete(new[] { patchfile });
                SetPCComplete(100);
                Complete();
            }
            private void ProcessDownload(object state)
            {
                string patchfile = Path.Combine(Sys.Settings.LibraryLocation, "temp", Filename);

                try
                {
                    if (Install == null)
                    {
                        Install = Sys.Library.GetItem(Mod.ID);

                        if (Install == null)
                        {
                            // don't go any further since mod is not installed
                            Error(new Exception($"{Mod.Name} not installed"));
                            return;
                        }
                    }

                    string source = Path.Combine(Sys.Settings.LibraryLocation, Install.LatestInstalled.InstalledLocation);
                    using (var iro = new _7thWrapperLib.IrosArc(source, true))
                    {
                        using (var patch = new _7thWrapperLib.IrosArc(patchfile))
                        {
                            iro.ApplyPatch(patch, (d, msg) =>
                            {
                                Sys.Message(new WMessage(msg, WMessageLogLevel.LogOnly));
                                SetPercentComplete((int)(100 * d));
                            });
                        }
                    }

                    File.Delete(patchfile);
                }
                catch (Exception e)
                {
                    Error(e);
                    return;
                }

                SetPercentComplete(100);
                Complete();
            }
Exemple #10
0
        internal void PatchIro()
        {
            string pathToOriginalIro = PathToOriginalIroFile;
            string pathToNewIro      = PathToNewIroFile;
            string iropFile          = PathToIropFile;

            _7thWrapperLib.CompressType compressType = (_7thWrapperLib.CompressType)CompressionSelectedIndex;

            IsPatching = true;

            Task patchTask = Task.Factory.StartNew(() =>
            {
                using (_7thWrapperLib.IrosArc orig = new _7thWrapperLib.IrosArc(pathToOriginalIro, true))
                {
                    using (_7thWrapperLib.IrosArc newiro = new _7thWrapperLib.IrosArc(pathToNewIro))
                    {
                        using (var fs = new FileStream(iropFile, FileMode.Create))
                            _7thWrapperLib.IrosPatcher.Create(orig, newiro, fs, compressType, IroProgress);
                    }
                }
            });

            patchTask.ContinueWith((result) =>
            {
                IsPatching    = false;
                ProgressValue = 0;

                if (result.IsFaulted)
                {
                    Logger.Warn(result.Exception.GetBaseException());
                    StatusText = $"{ResourceHelper.Get(StringKey.AnErrorOccuredWhilePatching)}: {result.Exception.GetBaseException().Message}";
                    return;
                }

                StatusText = ResourceHelper.Get(StringKey.PatchingComplete);
            });
        }
Exemple #11
0
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                System.Console.WriteLine(HELP);
                return;
            }
            _7thWrapperLib.RuntimeLog.Enabled = args.Any(s => s.Equals("/LOG", StringComparison.InvariantCultureIgnoreCase));

            Action <double, string> onProgress = (d, s) => {
                Console.WriteLine(String.Format("{0}%: {1}", (int)(d * 100), s));
            };

            if (args[0].Equals("LIST", StringComparison.InvariantCultureIgnoreCase))
            {
                _7thWrapperLib.IrosArc iro = new _7thWrapperLib.IrosArc(args[1]);
                foreach (string s in iro.GetInformation())
                {
                    Console.WriteLine(s);
                }
            }
            else if (args[0].Equals("CREATE", StringComparison.InvariantCultureIgnoreCase))
            {
                List <_7thWrapperLib.IrosArc.ArchiveCreateEntry> entries = new List <_7thWrapperLib.IrosArc.ArchiveCreateEntry>();
                string dir = args[2];
                foreach (string file in System.IO.Directory.GetFiles(dir, "*", System.IO.SearchOption.AllDirectories))
                {
                    entries.Add(_7thWrapperLib.IrosArc.ArchiveCreateEntry.FromDisk(dir, file.Substring(dir.Length).Trim('/', '\\')));
                }
                _7thWrapperLib.CompressType compress = (_7thWrapperLib.CompressType)Enum.Parse(typeof(_7thWrapperLib.CompressType), args[3]);

                using (var fs = new System.IO.FileStream(args[1], System.IO.FileMode.Create))
                    _7thWrapperLib.IrosArc.Create(fs,
                                                  entries,
                                                  _7thWrapperLib.ArchiveFlags.None,
                                                  compress,
                                                  onProgress
                                                  );
            }
            else if (args[0].Equals("EXTRACT", StringComparison.InvariantCultureIgnoreCase))
            {
                _7thWrapperLib.IrosArc iro = new _7thWrapperLib.IrosArc(args[1]);
                var sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                string filter = args.Length > 3 ? args[3] : String.Empty;
                foreach (string file in iro.AllFileNames())
                {
                    if (!String.IsNullOrEmpty(filter) && (file.IndexOf(filter) < 0))
                    {
                        continue;
                    }
                    Console.WriteLine("Writing " + file);
                    byte[] data = iro.GetBytes(file);
                    string fn   = System.IO.Path.Combine(args[2], file);
                    fn = fn.Replace("%", "___").Replace(":", "---");
                    System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
                    System.IO.File.WriteAllBytes(fn, data);
                }
                sw.Stop();
                Console.WriteLine("Done in " + (sw.ElapsedMilliseconds / 1000f) + " seconds");
            }
            else if (args[0].Equals("MAKEPATCH", StringComparison.InvariantCultureIgnoreCase))
            {
                _7thWrapperLib.IrosArc      orig     = new _7thWrapperLib.IrosArc(args[1]);
                _7thWrapperLib.IrosArc      newarc   = new _7thWrapperLib.IrosArc(args[2]);
                _7thWrapperLib.CompressType compress = (_7thWrapperLib.CompressType)Enum.Parse(typeof(_7thWrapperLib.CompressType), args[4]);
                using (var fs = new System.IO.FileStream(args[3], System.IO.FileMode.Create)) {
                    _7thWrapperLib.IrosPatcher.Create(orig, newarc, fs, compress, onProgress);
                }
            }
            else if (args[0].Equals("APPLYPATCH", StringComparison.InvariantCultureIgnoreCase))
            {
                _7thWrapperLib.IrosArc orig  = new _7thWrapperLib.IrosArc(args[1], true);
                _7thWrapperLib.IrosArc patch = new _7thWrapperLib.IrosArc(args[2]);
                orig.ApplyPatch(patch, onProgress);
            }
        }
Exemple #12
0
            private void ProcessDownload(object state)
            {
                try
                {
                    string source = System.IO.Path.Combine(Sys.Settings.LibraryLocation, "temp", File);
                    _dest = System.IO.Path.Combine(Sys.Settings.LibraryLocation, File);
                    byte[] sig = new byte[4];
                    using (var fs = new System.IO.FileStream(source, System.IO.FileMode.Open, System.IO.FileAccess.Read))
                    {
                        fs.Read(sig, 0, 4);
                        int isig = BitConverter.ToInt32(sig, 0);
                        if (isig == _7thWrapperLib.IrosArc.SIG)
                        {
                            //plain IRO file, just move into place
                            fs.Close();
                            using (var iro = new _7thWrapperLib.IrosArc(source))
                                if (!iro.CheckValid())
                                {
                                    throw new Exception("IRO archive appears to be invalid: corrupted download?");
                                }

                            SetPCComplete(50);

                            System.IO.File.Copy(source, _dest, overwrite: true);
                            System.IO.File.Delete(source);
                        }
                        else
                        {
                            var archive = ArchiveFactory.Open(fs);
                            var iroEnt  = archive.Entries.FirstOrDefault(e => System.IO.Path.GetExtension(e.Key).Equals(".iro", StringComparison.InvariantCultureIgnoreCase));
                            if (iroEnt != null)
                            {
                                SetPCComplete(50);
                                iroEnt.WriteToFile(_dest);
                            }
                            else
                            {
                                //extract entire archive...
                                if (_dest.EndsWith(".iro", StringComparison.InvariantCultureIgnoreCase))
                                {
                                    _dest = _dest.Substring(0, _dest.Length - 4);
                                }
                                var    entries   = archive.Entries.ToArray();
                                string extractTo = _dest;
                                if (!String.IsNullOrEmpty(ExtractInto))
                                {
                                    extractTo = System.IO.Path.Combine(extractTo, ExtractInto);
                                }
                                System.IO.Directory.CreateDirectory(extractTo);
                                using (var reader = archive.ExtractAllEntries())
                                {
                                    int count = 0;
                                    while (reader.MoveToNextEntry())
                                    {
                                        if (!reader.Entry.IsDirectory)
                                        {
                                            string filepath = reader.Entry.Key.Replace('/', '\\');
                                            if (String.IsNullOrEmpty(ExtractSubFolder) || filepath.StartsWith(ExtractSubFolder, StringComparison.InvariantCultureIgnoreCase))
                                            {
                                                string path = System.IO.Path.Combine(extractTo, filepath.Substring(ExtractSubFolder.Length).TrimStart('\\', '/'));
                                                System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
                                                using (var fOut = new System.IO.FileStream(path, System.IO.FileMode.Create))
                                                    reader.WriteEntryTo(fOut);
                                            }
                                            count++;
                                            float prog = (float)count / (float)entries.Length;
                                            SetPCComplete((int)(50 * prog) + 50);  // start at 50% go up to 100%
                                        }
                                    }
                                }
                            }
                            fs.Close();
                            System.IO.File.Delete(source);
                        }
                    }
                }
                catch (Exception e)
                {
                    Error(e);
                    return;
                }
                SetPCComplete(100);
                Complete();
            }
Exemple #13
0
        public static void ImportMod(string source, string name, bool iroMode, bool noCopy)
        {
            Mod m = new Mod()
            {
                Author        = String.Empty,
                Description   = "Imported mod",
                ID            = Guid.NewGuid(),
                Link          = String.Empty,
                Tags          = new List <string>(),
                Name          = name,
                LatestVersion = new ModVersion()
                {
                    CompatibleGameVersions = GameVersions.All,
                    Links        = new List <string>(),
                    PreviewImage = String.Empty,
                    ReleaseDate  = DateTime.Now,
                    ReleaseNotes = String.Empty,
                    Version      = 1.00m,
                }
            };

            string location;

            if (noCopy)
            {
                location = System.IO.Path.GetFileName(source);
            }
            else
            {
                location = String.Format("{0}_{1}", m.ID, name);
            }
            System.Xml.XmlDocument doc     = null;
            Func <string, byte[]>  getData = null;

            if (!iroMode)
            {
                if (!noCopy)
                {
                    foreach (string file in System.IO.Directory.GetFiles(source, "*", System.IO.SearchOption.AllDirectories))
                    {
                        string part = file.Substring(source.Length).Trim('\\', '/');
                        string dest = System.IO.Path.Combine(Sys.Settings.LibraryLocation, location, part);
                        System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(dest));
                        System.IO.File.Copy(file, dest, true);
                    }
                }
                string mx = System.IO.Path.Combine(Sys.Settings.LibraryLocation, location, "mod.xml");
                if (System.IO.File.Exists(mx))
                {
                    doc = new System.Xml.XmlDocument();
                    doc.Load(mx);
                }
                getData = s => {
                    string file = System.IO.Path.Combine(Sys.Settings.LibraryLocation, location, s);
                    if (System.IO.File.Exists(file))
                    {
                        return(System.IO.File.ReadAllBytes(file));
                    }
                    return(null);
                };
                //System.IO.Directory.Move(txtFolder.Text, System.IO.Path.Combine(Sys.Settings.LibraryLocation, location));
            }
            else
            {
                if (!noCopy)
                {
                    location = location + ".iro";
                    System.IO.File.Copy(source, System.IO.Path.Combine(Sys.Settings.LibraryLocation, location), true);
                }
                var arc = new _7thWrapperLib.IrosArc(source);
                if (arc.HasFile("mod.xml"))
                {
                    doc = new System.Xml.XmlDocument();
                    doc.Load(arc.GetData("mod.xml"));
                }
                getData = s => arc.HasFile(s) ? arc.GetBytes(s) : null;
            }

            if (doc != null)
            {
                m.Author      = doc.SelectSingleNode("/ModInfo/Author").NodeTextS();
                m.Link        = doc.SelectSingleNode("/ModInfo/Link").NodeTextS();
                m.Description = doc.SelectSingleNode("/ModInfo/Description").NodeTextS();
                decimal ver;
                if (decimal.TryParse(doc.SelectSingleNode("/ModInfo/Version").NodeTextS().Replace(',', '.'), out ver))
                {
                    m.LatestVersion.Version = ver;
                }
                var pv = doc.SelectSingleNode("/ModInfo/PreviewFile");
                if (pv != null)
                {
                    byte[] data = getData(pv.InnerText);
                    if (data != null)
                    {
                        string url = "iros://Preview/Auto/" + m.ID.ToString();
                        m.LatestVersion.PreviewImage = url;
                        Sys.ImageCache.InsertManual(url, data);
                    }
                }
            }

            Sys.Library.AddInstall(new InstalledItem()
            {
                CachedDetails = m,
                CachePreview  = String.Empty,
                ModID         = m.ID,
                UpdateType    = UpdateType.Ignore,
                Versions      = new List <InstalledVersion>()
                {
                    new InstalledVersion()
                    {
                        VersionDetails = m.LatestVersion, InstalledLocation = location
                    }
                },
            });
        }
Exemple #14
0
        /// <summary>
        /// Parses mod.xml from a folder or .iro and returns the <see cref="Mod"/>
        /// </summary>
        /// <param name="sourceFileOrFolder">absolute path to folder or .iro file </param>
        /// <param name="defaultModIfMissing"> default mod properties to use if the mod.xml file is not found </param>
        /// <returns></returns>
        public Mod ParseModXmlFromSource(string sourceFileOrFolder, Mod defaultModIfMissing = null)
        {
            if (defaultModIfMissing == null)
            {
                defaultModIfMissing = new Mod()
                {
                    Author        = String.Empty,
                    Description   = "Imported mod",
                    Category      = "Unknown",
                    ID            = ParseModGuidFromFileOrFolderName(sourceFileOrFolder),
                    Link          = String.Empty,
                    Tags          = new List <string>(),
                    Name          = "",
                    LatestVersion = new ModVersion()
                    {
                        CompatibleGameVersions = GameVersions.All,
                        Links        = new List <string>(),
                        PreviewImage = String.Empty,
                        ReleaseDate  = DateTime.Now,
                        ReleaseNotes = String.Empty,
                        Version      = 1.00m,
                    }
                };
            }


            Mod parsedMod = Mod.CopyMod(defaultModIfMissing);

            if (string.IsNullOrWhiteSpace(sourceFileOrFolder))
            {
                return(parsedMod);
            }

            if (!File.Exists(sourceFileOrFolder) && !Directory.Exists(sourceFileOrFolder))
            {
                return(parsedMod);
            }

            bool isIroFile = sourceFileOrFolder.EndsWith(".iro");

            System.Xml.XmlDocument doc          = null;
            Func <string, byte[]>  getImageData = null;

            _7thWrapperLib.IrosArc arc = null;

            string[] musicFiles = FF7FileLister.GetMusicFiles();
            string[] movieFiles = FF7FileLister.GetMovieFiles().Keys.ToArray();


            if (isIroFile)
            {
                RaiseProgressChanged("Getting mod.xml data from .iro", 10);

                arc = new _7thWrapperLib.IrosArc(sourceFileOrFolder, patchable: false, (i, fileCount) =>
                {
                    double newProgress = 10.0 + ((double)i / fileCount) * 30.0;
                    RaiseProgressChanged($"Scanning .iro archive files {i} / {fileCount}", newProgress);
                });

                if (arc.HasFile("mod.xml"))
                {
                    doc = new System.Xml.XmlDocument();
                    doc.Load(arc.GetData("mod.xml"));
                }

                RaiseProgressChanged($"Scanning .iro archive files for movie and music files", 45);
                foreach (string file in arc.AllFileNames())
                {
                    if (musicFiles.Any(f => f.Equals(Path.GetFileName(file), StringComparison.InvariantCultureIgnoreCase)))
                    {
                        parsedMod.ContainsMusic = true;
                    }

                    if (movieFiles.Any(f => f.Equals(Path.GetFileName(file), StringComparison.InvariantCultureIgnoreCase)))
                    {
                        parsedMod.ContainsMovies = true;
                    }

                    if (parsedMod.ContainsMovies && parsedMod.ContainsMusic)
                    {
                        break; // break out of loop to stop scanning since confirmed both music and movie files exist in mod
                    }
                }


                getImageData = s =>
                {
                    return(arc.HasFile(s) ? arc.GetBytes(s) : null);
                };
            }
            else
            {
                string pathToModXml = Path.Combine(sourceFileOrFolder, "mod.xml");

                RaiseProgressChanged("Getting mod.xml data from file", 10);
                if (File.Exists(pathToModXml))
                {
                    doc = new System.Xml.XmlDocument();
                    doc.Load(pathToModXml);
                }

                RaiseProgressChanged($"Scanning mod folder for movie and music files", 25);
                foreach (string file in FileUtils.GetAllFilesInDirectory(sourceFileOrFolder))
                {
                    if (musicFiles.Any(f => f.Equals(Path.GetFileName(file), StringComparison.InvariantCultureIgnoreCase)))
                    {
                        parsedMod.ContainsMusic = true;
                    }

                    if (movieFiles.Any(f => f.Equals(Path.GetFileName(file), StringComparison.InvariantCultureIgnoreCase)))
                    {
                        parsedMod.ContainsMovies = true;
                    }

                    if (parsedMod.ContainsMovies && parsedMod.ContainsMusic)
                    {
                        break; // break out of loop to stop scanning since confirmed both music and movie files exist in mod
                    }
                }

                getImageData = s =>
                {
                    string file = Path.Combine(sourceFileOrFolder, s);
                    if (File.Exists(file))
                    {
                        return(File.ReadAllBytes(file));
                    }
                    return(null);
                };
            }


            if (doc != null)
            {
                RaiseProgressChanged("Parsing information from mod.xml", 50);

                //If mod.xml contains an ID GUID, then use that instead of generating random one
                string modidstr = doc.SelectSingleNode("/ModInfo/ID").NodeTextS();
                if (!string.IsNullOrWhiteSpace(modidstr))
                {
                    try
                    {
                        parsedMod.ID = new Guid(modidstr);
                    }
                    catch (Exception e)
                    {
                        Sys.Message(new WMessage("Invalid GUID found for Mod ID ... Using guid from file/folder name (or new guid).", WMessageLogLevel.LogOnly, e));
                        parsedMod.ID = ParseModGuidFromFileOrFolderName(sourceFileOrFolder);
                    }
                }

                parsedMod.Name = doc.SelectSingleNode("/ModInfo/Name").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.Name))
                {
                    parsedMod.Name = defaultModIfMissing.Name;
                }

                parsedMod.Author = doc.SelectSingleNode("/ModInfo/Author").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.Author))
                {
                    parsedMod.Author = defaultModIfMissing.Author;
                }


                parsedMod.Link = doc.SelectSingleNode("/ModInfo/Link").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.Link))
                {
                    parsedMod.Link = defaultModIfMissing.Link;
                }

                parsedMod.Description = doc.SelectSingleNode("/ModInfo/Description").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.Description))
                {
                    parsedMod.Description = defaultModIfMissing.Description;
                }

                parsedMod.Category = doc.SelectSingleNode("/ModInfo/Category").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.Category))
                {
                    parsedMod.Category = defaultModIfMissing.Category;
                }

                parsedMod.LatestVersion.ReleaseNotes = doc.SelectSingleNode("/ModInfo/ReleaseNotes").NodeTextS();
                if (string.IsNullOrWhiteSpace(parsedMod.LatestVersion.ReleaseNotes))
                {
                    parsedMod.LatestVersion.ReleaseNotes = defaultModIfMissing.LatestVersion.ReleaseNotes;
                }


                if (DateTime.TryParse(doc.SelectSingleNode("/ModInfo/ReleaseDate").NodeTextS(), out DateTime parsedDate))
                {
                    parsedMod.LatestVersion.ReleaseDate = parsedDate;
                }
                else
                {
                    parsedMod.LatestVersion.ReleaseDate = defaultModIfMissing.LatestVersion.ReleaseDate;
                }

                string versionText = doc.SelectSingleNode("/ModInfo/Version").NodeTextS().Replace(',', '.'); // in-case Xml has "1,7" format then replace with "1.7"
                if (decimal.TryParse(versionText, System.Globalization.NumberStyles.AllowDecimalPoint, new System.Globalization.CultureInfo(""), out decimal ver))
                {
                    parsedMod.LatestVersion.Version = ver;
                }
                else
                {
                    parsedMod.LatestVersion.Version = defaultModIfMissing.LatestVersion.Version;
                }

                var pv = doc.SelectSingleNode("/ModInfo/PreviewFile");
                if (pv != null)
                {
                    // add the preview file to image cache and set the url prefixed with iros://Preview/Auto since it came from auto-import
                    byte[] data = getImageData(pv.InnerText);
                    if (data != null)
                    {
                        string url = $"iros://Preview/Auto/{parsedMod.ID}_{pv.InnerText.Replace('\\', '_')}";
                        parsedMod.LatestVersion.PreviewImage = url;
                        Sys.ImageCache.InsertManual(url, data);
                    }
                }
            }

            if (arc != null)
            {
                arc.Dispose();
            }

            return(parsedMod);
        }
Exemple #15
0
            private void ProcessDownload(object state)
            {
                // check if already finished processing download and call Complete()
                if (HasProcessed)
                {
                    SetPercentComplete?.Invoke(100);
                    Complete();
                    return;
                }

                try
                {
                    string source = Path.Combine(Sys.Settings.LibraryLocation, "temp", FileName);
                    _dest = Path.Combine(Sys.Settings.LibraryLocation, FileName);

                    byte[] sig  = new byte[4];
                    int    isig = 0;
                    using (var fs = new FileStream(source, FileMode.Open, FileAccess.Read))
                    {
                        fs.Read(sig, 0, 4);
                        isig = BitConverter.ToInt32(sig, 0);
                        fs.Close();
                    }

                    if (isig == _7thWrapperLib.IrosArc.SIG)
                    {
                        //plain IRO file, just move into place
                        using (var iro = new _7thWrapperLib.IrosArc(source))
                            if (!iro.CheckValid())
                            {
                                throw new Exception("IRO archive appears to be invalid: corrupted download?");
                            }

                        SetPercentComplete?.Invoke(50);

                        File.Copy(source, _dest, overwrite: true);
                        File.Delete(source);
                    }
                    else
                    {
                        using (var fs = new FileStream(source, FileMode.Open, FileAccess.Read))
                        {
                            var archive = ArchiveFactory.Open(fs);
                            var iroEnt  = archive.Entries.FirstOrDefault(e => Path.GetExtension(e.Key).Equals(".iro", StringComparison.InvariantCultureIgnoreCase));
                            if (iroEnt != null)
                            {
                                SetPercentComplete?.Invoke(50);
                                iroEnt.WriteToFile(_dest, new SharpCompress.Common.ExtractionOptions()
                                {
                                    Overwrite = true
                                });
                            }
                            else
                            {
                                //extract entire archive...
                                if (_dest.EndsWith(".iro", StringComparison.InvariantCultureIgnoreCase))
                                {
                                    _dest = _dest.Substring(0, _dest.Length - 4);
                                }
                                string extractTo = _dest;
                                if (!String.IsNullOrEmpty(ExtractInto))
                                {
                                    extractTo = Path.Combine(extractTo, ExtractInto);
                                }
                                Directory.CreateDirectory(extractTo);

                                using (var reader = archive.ExtractAllEntries())
                                {
                                    var entries = archive.Entries.ToArray();
                                    int count   = 0;
                                    while (reader.MoveToNextEntry())
                                    {
                                        if (!reader.Entry.IsDirectory)
                                        {
                                            reader.WriteEntryToDirectory(extractTo, new ExtractionOptions()
                                            {
                                                ExtractFullPath = true, Overwrite = true
                                            });
                                        }

                                        count++;
                                        float prog = (float)count / (float)entries.Length;
                                        SetPercentComplete?.Invoke((int)(50 * prog) + 50); // start at 50% go up to 100%
                                    }
                                }
                            }
                            fs.Close();
                        }

                        File.Delete(source);
                    }
                }
                catch (Exception e)
                {
                    Error(e);
                    return;
                }


                HasProcessed = true; // if reached this point then successfully processed the download with no error
                SetPercentComplete?.Invoke(100);
                Complete();
            }