private void MapEntryToFomodOption(List <Tuple <FomodFile, ModOption> > map, Entry entry, ModOption archiveModOption) { string entryPath = entry.GetPath(); string fomodBasePath = archiveModOption.BaseInstallerPath; if (fomodBasePath.Length > 0) { entryPath = entryPath.Replace(fomodBasePath, ""); } foreach (Tuple <FomodFile, ModOption> mapping in map) { FomodFile fileNode = mapping.Item1; ModOption option = mapping.Item2; if (fileNode.MatchesPath(entryPath)) { string mappedPath = fileNode.MappedPath(entryPath); if (mappedPath == "") { continue; } if (option.Assets.IndexOf(mappedPath) > -1) { continue; } option.Assets.Add(mappedPath); option.Size += (long)entry.Size; // enqueue jobs for analyzing archives and plugins MapEntryToOption(entry, option, archiveModOption); } } }
public DownloadFilesViewModel(IEventAggregator eventAggregator, string downloadURL, string downloadPath, ModOption option) { _eventAggregator = eventAggregator; _dialogCoordinator = DialogCoordinator.Instance; _downloadURL = downloadURL; _downloadPath = downloadPath; _option = option; Title = "Скачивание " + _option.Name; _webClient = new MyWebClient { CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore) }; if (AutoUpdater.Proxy != null) { _webClient.Proxy = AutoUpdater.Proxy; } var uri = new Uri(_downloadURL); _tempFile = string.IsNullOrEmpty(_downloadPath) ? Path.GetTempFileName() : Path.Combine(_downloadPath, $"{Guid.NewGuid().ToString()}.tmp"); _webClient.DownloadProgressChanged += OnDownloadProgressChanged; _webClient.DownloadFileCompleted += WebClientOnDownloadFileCompleted; _webClient.DownloadFileAsync(uri, _tempFile); }
public List <ModOption> BuildModOptions(string fomodBasePath) { List <ModOption> options = new List <ModOption>(); if (BaseFiles != null) { ModOption baseOption = new ModOption("Base FOMOD Files", true, true); AddFileMappings(baseOption, BaseFiles); options.Add(baseOption); } foreach (FomodPlugin plugin in Plugins) { ModOption option = new ModOption(plugin); if (plugin.Files != null) { AddFileMappings(option, plugin.Files); } if (!options.Exists(o => o.Matches(option))) { options.Add(option); } } foreach (ModOption option in options) { List <ModOption> matchingOpts = options.FindAll(o => o.Name.Equals(option.Name)); if (matchingOpts.Count > 1) { SpecifyModOptionNames(matchingOpts); } } return(options); }
/// <summary> /// The event handler for the remove options button clicked /// </summary> private void RemoveOptionButton_Click(object sender, RoutedEventArgs e) { _selectedModOption = (from option in _modOptions where option.Name.Equals(OptionList.SelectedItem.ToString()) select option).FirstOrDefault(); _modOptions.Remove(_selectedModOption); foreach (var item in OptionList.Items) { if (item.ToString().Equals(_selectedModOption.Name)) { if (OptionList.Items.Count > 0) { OptionList.SelectedIndex = 0; } else { OptionList.SelectedIndex = -1; } OptionList.Items.Remove(item); break; } } }
/// <summary> /// Adds the option to the group /// </summary> /// <param name="optionText">The option name</param> /// <param name="optionNum">The option number</param> private void AddOption(string optionText, int optionNum = 0) { if (OptionNameTextBox.Text.Equals(string.Empty)) { return; } var optionListItems = OptionList.Items.Cast <string>().ToList(); if (optionListItems.IndexOf(optionText) != -1) { AddOption($"{OptionNameTextBox.Text} {optionNum + 1}", optionNum + 1); } else { var modOption = new ModOption { Name = optionText }; _modOptions.Add(modOption); OptionList.Items.Add(optionText); OptionList.SelectedIndex = OptionList.Items.Count - 1; } OptionNameTextBox.Text = string.Empty; }
// create mod option based on underlying type and attributes of cfgField public static ModOption create(Config.Field cfgField) { ModOption option = null; #if DEBUG // trying to use all creators to check for ambiguity foreach (var c in creators) { var optionTmp = c.create(cfgField); Debug.assert(option == null || optionTmp == null, $"Options.Factory: ambiguity for field '{cfgField.path}' (both {option?.GetType().Name} and {optionTmp?.GetType().Name})"); option ??= optionTmp; } #else foreach (var c in creators) { if ((option = c.create(cfgField)) != null) { break; } } #endif if (option != null) { modifiers.ForEach(m => m.process(option)); } return(option); }
public void process(ModOption option) { if (option.cfgField.getAttr <CustomOrderAttribute>(true) is CustomOrderAttribute customOrder) { option.addHandler(new CustomOrderHandler(customOrder.modIDBefore)); } }
private bool ArchiveModOptionExists(string filePath) { ModOption existingArchiveOption = ArchiveModOptions.Where( x => x.SourceFilePath == filePath ).FirstOrDefault(); return(existingArchiveOption != null); }
private void Awake() { foreach (AbilityMods n in mods) { ModOption temp = Instantiate(modPrefab, options.transform).GetComponent <ModOption>(); temp.mod = n; temp.modSlot = this; } }
/// <summary> /// The event handler for the option list selection changed /// </summary> private void OptionList_SelectionChanged(object sender, SelectionChangedEventArgs e) { IncludedModsList.Items.Clear(); if (OptionList.SelectedIndex != -1) { _selectedModOption = (from option in _modOptions where option.Name.Equals(OptionList.SelectedItem.ToString()) select option).FirstOrDefault(); if (_selectedModOption.Description != null) { OptionDescription.Text = _selectedModOption.Description; } else { OptionDescription.Text = string.Empty; } if (_selectedModOption.Image != null) { OptionImage.Source = _selectedModOption.Image.ToBitmapSource(); } else { OptionImage.Source = null; } if (_selectedModOption.Mods != null && _selectedModOption.Mods.Count > 0) { foreach (var mod in _selectedModOption.Mods) { var includedMods = new IncludedMods { Name = $"{Path.GetFileNameWithoutExtension(mod.Key)} ({mod.Value.Name})", FullPath = mod.Value.FullPath }; IncludedModsList.Items.Add(includedMods); } } ModListGrid.IsEnabled = true; OptionDescription.IsEnabled = true; OptionImageButton.IsEnabled = true; RemoveOptionButton.IsEnabled = true; } else { ModListGrid.IsEnabled = false; OptionDescription.IsEnabled = false; OptionImageButton.IsEnabled = false; RemoveOptionButton.IsEnabled = false; } }
private string GetOutputFilename(List <ModOption> archiveModOptions) { ModOption baseOption = archiveModOptions.Find(modOption => modOption.Default); if (baseOption == null) { baseOption = archiveModOptions.First(); } return(baseOption.Name); }
public void process(ModOption option) { if (option.cfgField.getAttr <FieldAttribute>() is FieldAttribute fieldAttr) { if (fieldAttr.tooltipType != null || fieldAttr.tooltip != null) { option.addHandler(new Components.Tooltip.Add(fieldAttr.tooltipType, fieldAttr.tooltip)); } } }
public static void add(ModOption option) { if (instance == null) { registerLabel("Name", ref optionsName); OptionsPanelHandler.RegisterModOptions(instance = new Options()); } instance.modOptions.Add(option); }
private string GetDestinationPath(ModOption archiveModOption, Entry entry) { if (ArchiveHelpers.ShouldExtract(entry)) { return(archiveModOption.GetExtractedEntryPath(entry)); } else { return(null); } }
public static async Task CreateModConfigWorker(ModOption mod) { if (ConfigWorkers.ContainsKey(mod.Id)) { var workerCollection = ConfigWorkers[mod.Id]; var worker = Activator.CreateInstance(workerCollection.configWorker) as ModConfigWorkerBase; worker.id = workerCollection.workerAttribute.id; worker.mod = mod; worker.helper = new ModConfigHelper(mod); await worker.Work(); } }
private void AddFileMappings(ModOption option, List <FomodFile> files) { option.FomodFiles.AddRange(files); foreach (FomodFile file in files) { Tuple <FomodFile, ModOption> mapping = new Tuple <FomodFile, ModOption>(file, option); if (FileMap.IndexOf(mapping) == -1) { FileMap.Add(mapping); } } }
public void process(ModOption option) { if (option.cfgField.getAttr <HideableAttribute>(true) is HideableAttribute hideableAttr) { string groupID = hideableAttr.groupID; if (groupID == null) { option.cfgField.getAttrs <HideableAttribute>(true).forEach(attr => groupID ??= attr.groupID); } option.addHandler(new Components.Hider.Add(hideableAttr.visChecker, groupID)); } }
private void ReportFomodOption(ModOption option) { _backgroundWorker.ReportMessage(option.Name, true); foreach (FomodFile fomodFile in option.FomodFiles) { if (string.IsNullOrEmpty(fomodFile.Destination)) { _backgroundWorker.ReportMessage(" " + fomodFile.Source, false); } else { _backgroundWorker.ReportMessage(string.Format(" {0} -> {1}", fomodFile.Source, fomodFile.Destination), false); } } }
public void process(ModOption option) { if (processed || !(processed = true)) // process only the first added option { return; } Debug.assert(instance == null); // if this the first option, ModOptions shouldn't be created yet if (option.cfgField.getAttr <NameAttribute>(true) is NameAttribute nameAttr) { if (nameAttr.tooltipType != null || nameAttr.tooltip != null) { option.addHandler(new Components.Tooltip.AddToHeading(nameAttr.tooltipType, nameAttr.tooltip)); } } }
private void AnalyzeNormalArchive(ModOption archiveModOption) { ArchiveFile archive = archiveModOption.Archive; foreach (Entry modArchiveEntry in archive.FileEntries()) { // append entry path to option assets string entryPath = modArchiveEntry.GetPath(); archiveModOption.Assets.Add(entryPath); _backgroundWorker.ReportMessage(entryPath, false); // enqueue jobs for analyzing archives and plugins MapEntryToOption(modArchiveEntry, archiveModOption, archiveModOption); } _modAnalysis.ModOptions.Add(archiveModOption); }
private List <ModOption> AnalyzeFomodArchive(ModOption archiveModOption) { ArchiveFile archive = archiveModOption.Archive; _backgroundWorker.ReportMessage("Parsing FOMOD Options", true); List <ModOption> fomodOptions = new List <ModOption>(); // STEP 1: Find the fomod/ModuleConfig.xml file and extract it Entry configEntry = archive.FindArchiveEntry(@"fomod\ModuleConfig.xml"); _backgroundWorker.ReportMessage("Found FOMOD Config at " + configEntry.GetPath(), false); Directory.CreateDirectory(@".\fomod"); configEntry.ExtractToDirectory(@".\fomod"); _backgroundWorker.ReportMessage("FOMOD Config Extracted", false); // STEP 2: Parse ModuleConfig.xml and determine what the mod options are FomodConfig fomodConfig = new FomodConfig(@".\fomod\ModuleConfig.xml"); _backgroundWorker.ReportMessage("Detecting FOMOD options" + Environment.NewLine, true); fomodOptions = fomodConfig.BuildModOptions(archiveModOption.BaseInstallerPath); foreach (ModOption option in fomodOptions) { ReportFomodOption(option); } // STEP 4: Loop through the archive's assets appending them to mod options per mapping IList <Entry> fileEntries = archive.FileEntries(); _backgroundWorker.ReportMessage(string.Format("{0}Mapping {1} assets to {2} FOMOD Options", Environment.NewLine, fileEntries.Count, fomodOptions.Count), true); foreach (Entry entry in fileEntries) { MapEntryToFomodOption(fomodConfig.FileMap, entry, archiveModOption); } // STEP 5: Delete any options that have no assets or plugins in them _backgroundWorker.ReportMessage(Environment.NewLine + "Cleaning up...", true); fomodOptions.RemoveAll(ModOption.IsEmpty); // Return the mod options we built _backgroundWorker.ReportMessage(Environment.NewLine + "Done. " + fomodOptions.Count + " FOMOD Options found.", true); return(fomodOptions); }
// create mod option based on underlying type and attributes of cfgField public static ModOption create(Config.Field cfgField) { ModOption option = null; foreach (var c in creators) { if ((option = c.create(cfgField)) != null) { break; } } if (option != null) { modifiers.ForEach(m => m.process(option)); } return(option); }
// performs the enqueued entry analysis jobs // TODO: Raise exception if job fails private void AnalyzeEntries(ModOption archiveModOption) { foreach (string pluginPath in archiveModOption.PluginPaths) { PluginDump dump = _pluginAnalyzer.GetPluginDump(pluginPath); if (dump != null) { MapPluginDump(pluginPath, dump); } } foreach (string archivePath in archiveModOption.ArchivePaths) { List <string> assets = _assetArchiveAnalyzer.GetAssetPaths(archivePath); if (assets == null) { continue; } MapArchiveAssetPaths(archivePath, assets); } }
public void init(ModOption option) { parentOption = option; if (tooltip == null) { return; } // adjust text size for default tooltip (before we registering string with LanguageHelper) if (tooltipCmpType == null) { tooltip = $"<size={defaultTextSize}>" + tooltip + "</size>"; } string stringID = option.id + ".tooltip"; uniqueIDs.ensureUniqueID(ref stringID); // in case we add more than one tooltip to the option (e.g. for heading) registerLabel(stringID, ref tooltip, false); }
private List <ModOption> AnalyzeBainArchive(ModOption archiveModOption) { ArchiveFile archive = archiveModOption.Archive; bool flex = archiveModOption.IsFlexArchive; if (flex) { archiveModOption.BaseInstallerPath = archiveModOption.Archive.GetBaseDirectory(); } string bainType = flex ? "FLEX" : "BAIN"; _backgroundWorker.ReportMessage("Parsing " + bainType + " Options", true); List <ModOption> bainOptions = new List <ModOption>(); List <Tuple <string, ModOption> > bainMap = new List <Tuple <string, ModOption> >(); // STEP 1. Find BAIN directories and build mod options for them foreach (string bainDirectory in archiveModOption.GetInstallerDirectories(!flex)) { string bainOptionName = Path.GetFileName(bainDirectory); _backgroundWorker.ReportMessage("Found " + bainType + " Option " + bainOptionName, false); ModOption bainOption = new ModOption(bainOptionName, false, true); bainMap.Add(new Tuple <string, ModOption>(bainDirectory, bainOption)); bainOptions.Add(bainOption); } // STEP 2: Map entries to bain options IList <Entry> fileEntries = archive.FileEntries(); _backgroundWorker.ReportMessage(string.Format("{0}Mapping {1} assets to {2} {3} Options", Environment.NewLine, fileEntries.Count, bainOptions.Count, bainType), true); foreach (Entry entry in fileEntries) { MapEntryToBainOption(bainMap, entry, archiveModOption); } // Return the mod options we built _backgroundWorker.ReportMessage("Done. " + bainOptions.Count + " " + bainType + " Options found.", true); return(bainOptions.OrderBy(x => x.Name).ToList()); }
private void MapEntryToBainOption(List <Tuple <string, ModOption> > map, Entry entry, ModOption archiveModOption) { string entryPath = entry.GetPath(); foreach (Tuple <string, ModOption> mapping in map) { string bainPath = mapping.Item1 + @"\"; ModOption option = mapping.Item2; if (entryPath.StartsWith(bainPath)) { string mappedPath = entryPath.Replace(bainPath, ""); if (mappedPath == "") { continue; } option.Assets.Add(mappedPath); option.Size += (long)entry.Size; // enqueue jobs for analyzing archives and plugins MapEntryToOption(entry, option, archiveModOption); } } }
private void AnalyzeArchive(ModOption modOption) { if (modOption.IsFomodArchive) { List <ModOption> fomodOptions = AnalyzeFomodArchive(modOption); fomodOptions.ForEach(mo => { mo.MD5Hash = modOption.MD5Hash; mo.Default = mo.Default && modOption.Default; }); _modAnalysis.ModOptions.Add(modOption); _modAnalysis.ModOptions.AddRange(fomodOptions); } else if (modOption.IsBainArchive || modOption.IsFlexArchive) { List <ModOption> bainOptions = AnalyzeBainArchive(modOption); bainOptions.ForEach(mo => { mo.MD5Hash = modOption.MD5Hash; }); _modAnalysis.ModOptions.Add(modOption); _modAnalysis.ModOptions.AddRange(bainOptions); } else { AnalyzeNormalArchive(modOption); } }
public static PersistenceMod CreateData(ModOption option) => new PersistenceMod(option);
public void init(ModOption option) => id = option.id;
private async Task CreateAdvanced() { string modPackPath = Path.Combine(Properties.Settings.Default.ModPack_Directory, $"{ViewModel.Name}.ttmp2"); if (File.Exists(modPackPath)) { DialogResult overwriteDialogResult = FlexibleMessageBox.Show(new Wpf32Window(this), UIMessages.ModPackOverwriteMessage, UIMessages.OverwriteTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Warning); if (overwriteDialogResult != System.Windows.Forms.DialogResult.Yes) { return; } } await LockUi(UIStrings.Creating_Modpack, null, null); try { TTMP texToolsModPack = new TTMP(new DirectoryInfo(Settings.Default.ModPack_Directory), XivStrings.TexTools); var index = new Index(XivCache.GameInfo.GameDirectory); var dat = new Dat(XivCache.GameInfo.GameDirectory); var modding = new Modding(XivCache.GameInfo.GameDirectory); var ModList = modding.GetModList(); var wizardData = new ModPackData() { Name = ViewModel.Name, Author = ViewModel.Author, Version = ViewModel.Version, Description = ViewModel.Description, Url = ViewModel.Url, ModPackPages = new List <ModPackData.ModPackPage>() }; var page = new ModPackData.ModPackPage() { PageIndex = 1, ModGroups = new List <ModGroup>() }; wizardData.ModPackPages.Add(page); foreach (var e in ViewModel.Entries) { var item = e.Item; var files = e.AllFiles; var group = new ModGroup() { GroupName = item.Name, SelectionType = "Multi", OptionList = new List <ModOption>() }; page.ModGroups.Add(group); var option = new ModOption { GroupName = group.GroupName, IsChecked = true, Name = GetNiceLevelName(e.Level, true, true), Description = "Item: " + item.Name + "\nInclusion Level: " + GetNiceLevelName(e.Level) + "\nPrimary Files:" + e.MainFiles.Count + "\nTotal Files:" + e.AllFiles.Count, SelectionType = "Multi", }; group.OptionList.Add(option); foreach (var file in e.AllFiles) { var exists = await index.FileExists(file); // This is a funny case where in order to create the modpack we actually have to write a default meta entry to the dats first. // If we had the right functions we could just load and serialize the data, but we don't atm. if (!exists && Path.GetExtension(file) == ".meta") { var meta = await ItemMetadata.GetMetadata(file); await ItemMetadata.SaveMetadata(meta, XivStrings.TexTools); } var offset = await index.GetDataOffset(file); var dataFile = IOUtil.GetDataFileFromPath(file); var compressedSize = await dat.GetCompressedFileSize(offset, dataFile); var modEntry = ModList.Mods.FirstOrDefault(x => x.fullPath == file); var modded = modEntry != null && modEntry.enabled == true; var fData = new ModData { Name = e.Item.Name, Category = e.Item.SecondaryCategory, FullPath = file, IsDefault = !modded, ModDataBytes = dat.GetRawData(offset, dataFile, compressedSize) }; option.Mods.Add(file, fData); } } // Okay modpack is now created internally, just need to save it. var progressIndicator = new Progress <double>(ReportProgressAdv); await texToolsModPack.CreateWizardModPack(wizardData, progressIndicator, true); FlexibleMessageBox.Show(new Wpf32Window(this), "Modpack Created Successfully.", "Modpack Created", MessageBoxButtons.OK, MessageBoxIcon.Information); await UnlockUi(this); DialogResult = true; } catch (Exception ex) { FlexibleMessageBox.Show(new Wpf32Window(this), "An Error occured while creating the modpack.\n\n" + ex.Message, "Modpack Creation Error", MessageBoxButtons.OK, MessageBoxIcon.Error); await UnlockUi(this); } }