public ImportModPackWizard(ModPackJson modPackJson, Dictionary <string, Image> imageDictionary, DirectoryInfo modPackDirectory, bool messageInImport = false)
{
InitializeComponent();
_imageDictionary = imageDictionary;
_modPackDirectory = modPackDirectory;
_messageInImport = messageInImport;
ModPackNameLabel.Content = modPackJson.Name;
ModPackAuthorLabel.Content = modPackJson.Author;
ModPackVersionLabel.Content = modPackJson.Version;
ModPackDescription.Text = modPackJson.Description;
_modPackEntry = new ModPack {
name = modPackJson.Name, author = modPackJson.Author, version = modPackJson.Version
};
_pageCount = modPackJson.ModPackPages.Count;
var wizPages = importModPackWizard.Items;
for (var i = 0; i < _pageCount; i++)
{
wizPages.Add(new WizardPage
{
Content = new ImportWizardModPackControl(modPackJson.ModPackPages[i], imageDictionary),
PageType = WizardPageType.Blank,
Background = null,
HeaderBackground = null
});
}
}
public ImportModPackWizard(ModPackJson modPackJson, Dictionary <string, MagickImage> imageDictionary, DirectoryInfo modPackDirectory)
{
InitializeComponent();
_imageDictionary = imageDictionary;
_modPackDirectory = modPackDirectory;
ModPackNameLabel.Content = modPackJson.Name;
ModPackAuthorLabel.Content = modPackJson.Author;
ModPackVersionLabel.Content = modPackJson.Version;
ModPackDescription.Text = modPackJson.Description;
_pageCount = modPackJson.ModPackPages.Count;
var wizPages = importModPackWizard.Items;
for (var i = 0; i < _pageCount; i++)
{
wizPages.Add(new WizardPage
{
Content = new ImportWizardModPackControl(modPackJson.ModPackPages[i], imageDictionary),
PageType = WizardPageType.Blank
});
}
}
/// <summary>
/// Imports a simple mod pack
/// </summary>
/// <param name="modPackJson">The mod pack json</param>
private async Task ImportSimpleModPack(ModPackJson modPackJson)
{
var modding = new Modding(_gameDirectory);
Dispatcher.Invoke(() =>
{
// This does not need to be an async task set.
for (int i = 0; i < modPackJson.SimpleModsList.Count; i++)
{
var jsonItem = modPackJson.SimpleModsList[i];
// For some reason the ModPackEntry was never set before 2.0.13 so this is necessary for modpacks created prior to then
if (jsonItem.ModPackEntry == null)
{
// Manually add the modpack entry that this mod is a part of
jsonItem.ModPackEntry = new ModPack
{
name = modPackJson.Name,
author = modPackJson.Author,
version = modPackJson.Version
};
}
JsonEntries.Add(jsonItem);
Entries.Add(new SimpleModpackEntry(JsonEntries.Count - 1, this));
}
if (String.IsNullOrEmpty(modPackJson.MinimumFrameworkVersion))
{
Version ver;
bool success = Version.TryParse(modPackJson.MinimumFrameworkVersion, out ver);
if (success)
{
var frameworkVersion = typeof(XivCache).Assembly.GetName().Version;
if (ver > frameworkVersion)
{
throw new NotSupportedException("This modpack requires a more recent TexTools version to install.");
}
}
}
ModPackName.Content = modPackJson.Name;
ModPackAuthor.Content = modPackJson.Author;
ModPackVersion.Content = modPackJson.Version;
var cv = (CollectionView)CollectionViewSource.GetDefaultView(ModListView.ItemsSource);
cv.SortDescriptions.Clear();
cv.SortDescriptions.Add(new SortDescription(nameof(SimpleModpackEntry.ItemName), _lastDirection));
SelectedEntries.Clear();
long size = 0;
for (int i = 0; i < JsonEntries.Count; i++)
{
SelectedEntries.Add(i);
size += JsonEntries[i].ModSize;
}
ModListView.SelectAll();
ModSize = size;
});
}
public SimpleModPackImporter(DirectoryInfo modPackDirectory, ModPackJson modPackJson, TextureViewModel textureViewModel, ModelViewModel modelViewModel, bool silent = false, bool messageInImport = false)
{
this.DataContext = this;
InitializeComponent();
JsonEntries = new List <ModsJson>();
SelectedEntries = new HashSet <int>();
_modPackDirectory = modPackDirectory;
_gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
_modding = new Modding(_gameDirectory);
_texToolsModPack = new TTMP(new DirectoryInfo(Properties.Settings.Default.ModPack_Directory),
XivStrings.TexTools);
_messageInImport = messageInImport;
_textureViewModel = textureViewModel;
_modelViewModel = modelViewModel;
var index = new Index(_gameDirectory);
_indexLockStatus = index.IsIndexLocked(XivDataFile._0A_Exd);
_packJson = modPackJson;
_silent = silent;
ModListView.IsEnabled = false;
LockedStatusLabel.Foreground = Brushes.Black;
LockedStatusLabel.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Left;
LockedStatusLabel.Content = UIStrings.Loading;
Task.Run(Initialize);
}
/// <summary>
/// Gets the data from a mod pack including images if present
/// </summary>
/// <param name="modPackDirectory">The directory of the mod pack</param>
/// <returns>A tuple containing the mod pack json data and a dictionary of images if any</returns>
public (ModPackJson ModPackJson, Dictionary <string, MagickImage> ImageDictionary) GetModPackJsonData(DirectoryInfo modPackDirectory)
{
ModPackJson modPackJson = null;
var imageDictionary = new Dictionary <string, MagickImage>();
using (var archive = ZipFile.OpenRead(modPackDirectory.FullName))
{
foreach (var entry in archive.Entries)
{
if (entry.FullName.EndsWith(".mpl"))
{
using (var streamReader = new StreamReader(entry.Open()))
{
var jsonString = streamReader.ReadToEnd();
modPackJson = JsonConvert.DeserializeObject <ModPackJson>(jsonString);
}
}
if (entry.FullName.EndsWith(".png"))
{
imageDictionary.Add(entry.FullName, new MagickImage(entry.Open()));
}
}
}
return(modPackJson, imageDictionary);
}
public ImportModPackWizard(ModPackJson modPackJson, Dictionary <string, Image> imageDictionary, DirectoryInfo modPackDirectory, TextureViewModel textureViewModel, ModelViewModel modelViewModel, bool messageInImport = false)
{
InitializeComponent();
_imageDictionary = imageDictionary;
_modPackDirectory = modPackDirectory;
_messageInImport = messageInImport;
_textureViewModel = textureViewModel;
_modelViewModel = modelViewModel;
ModPackNameLabel.Content = modPackJson.Name;
ModPackAuthorLabel.Content = modPackJson.Author;
ModPackVersionLabel.Content = modPackJson.Version;
ModPackDescription.Text = modPackJson.Description;
ModPackUrlLabel.Text = modPackJson.Url;
ModPackUrlLabel.PreviewMouseLeftButtonDown += ModPackUrlLabel_PreviewMouseLeftButtonDown;
if (!String.IsNullOrEmpty(modPackJson.MinimumFrameworkVersion))
{
Version ver;
bool success = Version.TryParse(modPackJson.MinimumFrameworkVersion, out ver);
if (success)
{
var frameworkVersion = typeof(XivCache).Assembly.GetName().Version;
if (ver > frameworkVersion)
{
var Win32Window = new WindowWrapper(new WindowInteropHelper(this).Handle);
FlexibleMessageBox.Show(Win32Window, "This Modpack requires a more recent version of TexTools to install.", "Framework Version Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
Close();
return;
}
}
}
_modPackEntry = new ModPack {
name = modPackJson.Name, author = modPackJson.Author, version = modPackJson.Version
};
_pageCount = modPackJson.ModPackPages.Count;
var wizPages = importModPackWizard.Items;
for (var i = 0; i < _pageCount; i++)
{
wizPages.Add(new WizardPage
{
Content = new ImportWizardModPackControl(modPackJson.ModPackPages[i], imageDictionary),
PageType = WizardPageType.Blank,
Background = null,
HeaderBackground = null
});
}
}
private async void Initialize(ModPackJson modPackJson, bool silent)
{
ModListView.IsEnabled = false;
LockedStatusLabel.Foreground = Brushes.Black;
LockedStatusLabel.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Left;
LockedStatusLabel.Content = UIStrings.Loading;
var progress = new Progress <(int count, int total)>(prog =>
{
LockedStatusLabel.Content = $"{UIStrings.Loading} ({prog.count}, {prog.total})";
if (prog.count == prog.total)
{
LockedStatusLabel.Content = UIStrings.Finalizing;
}
});
if (modPackJson != null)
{
await ImportSimpleModPack(modPackJson);
}
else
{
await ImportOldModPack(progress);
}
// Resize columns to fit content
foreach (var column in GridViewCol.Columns)
{
if (double.IsNaN(column.Width))
{
column.Width = column.ActualWidth;
}
column.Width = double.NaN;
}
LockedStatusLabel.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Right;
LockedStatusLabel.Foreground = Brushes.Red;
LockedStatusLabel.Content = string.Empty;
ModListView.IsEnabled = true;
if (_indexLockStatus)
{
LockedStatusLabel.Content = UIStrings.Index_Locked;
}
if (silent)
{
FinalizeImport();
}
}
public ImportModPackWizard(ModPackJson modPackJson, Dictionary <string, Image> imageDictionary, DirectoryInfo modPackDirectory, TextureViewModel textureViewModel, ModelViewModel modelViewModel, bool messageInImport = false)
{
InitializeComponent();
_imageDictionary = imageDictionary;
_modPackDirectory = modPackDirectory;
_messageInImport = messageInImport;
_textureViewModel = textureViewModel;
_modelViewModel = modelViewModel;
ModPackNameLabel.Content = modPackJson.Name;
ModPackAuthorLabel.Content = modPackJson.Author;
ModPackVersionLabel.Content = modPackJson.Version;
ModPackDescription.Text = modPackJson.Description;
if (String.IsNullOrEmpty(modPackJson.MinimumFrameworkVersion))
{
Version ver;
bool success = Version.TryParse(modPackJson.MinimumFrameworkVersion, out ver);
if (success)
{
var frameworkVersion = typeof(XivCache).Assembly.GetName().Version;
if (ver > frameworkVersion)
{
throw new NotSupportedException("This modpack requires a more recent TexTools version to install.");
}
}
}
_modPackEntry = new ModPack {
name = modPackJson.Name, author = modPackJson.Author, version = modPackJson.Version
};
_pageCount = modPackJson.ModPackPages.Count;
var wizPages = importModPackWizard.Items;
for (var i = 0; i < _pageCount; i++)
{
wizPages.Add(new WizardPage
{
Content = new ImportWizardModPackControl(modPackJson.ModPackPages[i], imageDictionary),
PageType = WizardPageType.Blank,
Background = null,
HeaderBackground = null
});
}
}
public BackupModPackImporter(DirectoryInfo modPackDirectory, ModPackJson modPackJson, bool messageInImport = false)
{
InitializeComponent();
MainWindow.MakeHighlander();
_modpackDirectory = modPackDirectory;
_modsJsons = modPackJson.SimpleModsList;
_messageInImport = messageInImport;
DataContext = new BackupModpackViewModel();
ModPackName.Content = modPackJson.Name;
ModpackList.ItemsSource = new List <BackupModpackItemEntry>();
MakeModpackList();
}
/// <summary>
/// Imports a simple mod pack
/// </summary>
/// <param name="modPackJson">The mod pack json</param>
private void ImportSimpleModPack(ModPackJson modPackJson)
{
var modding = new Modding(_gameDirectory);
foreach (var modsJson in modPackJson.SimpleModsList)
{
var race = GetRace(modsJson.FullPath);
var number = GetNumber(modsJson.FullPath);
var type = GetType(modsJson.FullPath);
var map = GetMap(modsJson.FullPath);
var active = false;
var isActive = modding.IsModEnabled(modsJson.FullPath, false);
if (isActive == XivModStatus.Enabled)
{
active = true;
}
modsJson.ModPackEntry = new ModPack
{
name = modPackJson.Name, author = modPackJson.Author, version = modPackJson.Version
};
_simpleDataList.Add(new SimpleModPackEntries
{
Name = modsJson.Name,
Category = modsJson.Category,
Race = race.ToString(),
Part = type,
Num = number,
Map = map,
Active = active,
JsonEntry = modsJson,
});
}
ModPackName.Content = modPackJson.Name;
ModPackAuthor.Content = modPackJson.Author;
ModPackVersion.Content = modPackJson.Version;
_simpleDataList.Sort();
ModListView.ItemsSource = new ObservableCollection <SimpleModPackEntries>(_simpleDataList);
ModListView.SelectAll();
}
public SimpleModPackImporter(DirectoryInfo modPackDirectory, ModPackJson modPackJson)
{
InitializeComponent();
_modPackDirectory = modPackDirectory;
_gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
_texToolsModPack = new TTMP(new DirectoryInfo(Properties.Settings.Default.ModPack_Directory),
XivStrings.TexTools);
if (modPackJson != null)
{
ImportSimpleModPack(modPackJson);
}
else
{
ImportOldModPack();
}
}
public SimpleModPackImporter(DirectoryInfo modPackDirectory, ModPackJson modPackJson, bool silent = false, bool messageInImport = false)
{
InitializeComponent();
_modPackDirectory = modPackDirectory;
_gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
_texToolsModPack = new TTMP(new DirectoryInfo(Properties.Settings.Default.ModPack_Directory),
XivStrings.TexTools);
_messageInImport = messageInImport;
var index = new Index(_gameDirectory);
_indexLockStatus = index.IsIndexLocked(XivDataFile._0A_Exd);
ModListView.ItemsSource = _simpleDataList;
Initialize(modPackJson, silent);
}
/// <summary>
/// Imports a simple mod pack
/// </summary>
/// <param name="modPackJson">The mod pack json</param>
private async Task ImportSimpleModPack(ModPackJson modPackJson)
{
var modding = new Modding(_gameDirectory);
var tasks = modPackJson.SimpleModsList.Select(modsJson => AddToList(modsJson, modding, modPackJson));
await Task.WhenAll(tasks);
ModPackName.Content = modPackJson.Name;
ModPackAuthor.Content = modPackJson.Author;
ModPackVersion.Content = modPackJson.Version;
var cv = (CollectionView)CollectionViewSource.GetDefaultView(ModListView.ItemsSource);
cv.SortDescriptions.Clear();
cv.SortDescriptions.Add(new SortDescription(nameof(SimpleModPackEntries.Name), _lastDirection));
ModListView.SelectAll();
}
private async void Initialize(ModPackJson modPackJson, bool silent)
{
ModListView.IsEnabled = false;
LockedStatusLabel.Foreground = Brushes.Black;
LockedStatusLabel.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Left;
var progress = new Progress <(int count, int total)>(prog =>
{
LockedStatusLabel.Content = $"{UIStrings.Loading} ({prog.count}, {prog.total})";
if (prog.count == prog.total)
{
LockedStatusLabel.Content = UIStrings.Finalizing;
}
});
if (modPackJson != null)
{
await ImportSimpleModPack(modPackJson, progress);
}
else
{
await ImportOldModPack(progress);
}
LockedStatusLabel.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Right;
LockedStatusLabel.Foreground = Brushes.Red;
LockedStatusLabel.Content = string.Empty;
ModListView.IsEnabled = true;
if (_indexLockStatus)
{
LockedStatusLabel.Content = UIStrings.Index_Locked;
}
if (silent)
{
FinalizeImport();
}
}
/// <summary>
/// Gets the version from a mod pack
/// </summary>
/// <param name="modPackDirectory">The mod pack directory</param>
/// <returns>The version of the mod pack as a string</returns>
public string GetVersion(DirectoryInfo modPackDirectory)
{
ModPackJson modPackJson = null;
using (var archive = ZipFile.OpenRead(modPackDirectory.FullName))
{
foreach (var entry in archive.Entries)
{
if (entry.FullName.EndsWith(".mpl"))
{
using (var streamReader = new StreamReader(entry.Open()))
{
var jsonString = streamReader.ReadToEnd();
modPackJson = JsonConvert.DeserializeObject <ModPackJson>(jsonString);
}
}
}
}
return(modPackJson.TTMPVersion);
}
public override List <FileInfo> Extract(FileInfo file, DirectoryInfo outputDirectory)
{
List <FileInfo> extractedFiles = new List <FileInfo>();
string mplPath = outputDirectory + "ttmp.mpl";
string mpdPath = outputDirectory + "ttmp.mpd";
using (ZipArchive zipFile = ZipFile.OpenRead(file.FullName))
{
// Extract the mpl
ZipArchiveEntry mpl = zipFile.Entries.First(x => x.FullName.EndsWith(".mpl"));
Console.WriteLine("Extracting MPL to " + mplPath);
mpl.ExtractToFile(mplPath);
// Extract the mpd
ZipArchiveEntry mpd = zipFile.Entries.First(x => x.FullName.EndsWith(".mpd"));
Console.WriteLine("Extracting MPD to " + mpdPath);
mpd.ExtractToFile(mpdPath);
}
ModPackJson modPack = JsonConvert.DeserializeObject <ModPackJson>(File.ReadAllText(mplPath));
Console.WriteLine("Read MPL: " + modPack.Name);
Console.WriteLine("Extracting Modded resources");
FileStream fs = new FileStream(mpdPath, FileMode.Open);
using (SqPackStream pack = new SqPackStream(fs))
{
if (modPack.SimpleModsList != null)
{
foreach (ModsJson mods in modPack.SimpleModsList)
{
extractedFiles.AddRange(this.Extract(mods, pack, outputDirectory));
}
}
if (modPack.ModPackPages != null)
{
foreach (ModPackPageJson page in modPack.ModPackPages)
{
foreach (ModGroupJson group in page.ModGroups)
{
foreach (ModOptionJson option in group.OptionList)
{
foreach (ModsJson mods in option.ModsJsons)
{
string directoryName = page.PageIndex.ToString() + "_" + group.GroupName + "_" + option.Name;
DirectoryInfo dir = outputDirectory.CreateSubdirectory(directoryName);
extractedFiles.AddRange(this.Extract(mods, pack, dir));
}
}
}
}
}
}
File.Delete(mpdPath);
Console.WriteLine("Deleted MPD");
File.Delete(mplPath);
Console.WriteLine("Deleted MPL");
return(extractedFiles);
}
/// <summary>
/// Creates a mod pack that uses a wizard for installation
/// </summary>
/// <param name="modPackData">The data that will go into the mod pack</param>
/// <param name="progress">The progress of the mod pack creation</param>
/// <returns>The number of pages created for the mod pack</returns>
public async Task <int> CreateWizardModPack(ModPackData modPackData, IProgress <double> progress, bool overwriteModpack)
{
var processCount = await Task.Run <int>(() =>
{
_tempMPD = Path.GetTempFileName();
_tempMPL = Path.GetTempFileName();
var imageList = new Dictionary <string, string>();
var pageCount = 1;
var modPackJson = new ModPackJson
{
TTMPVersion = _currentWizardTTMPVersion,
Name = modPackData.Name,
Author = modPackData.Author,
Version = modPackData.Version.ToString(),
Description = modPackData.Description,
ModPackPages = new List <ModPackPageJson>()
};
using (var binaryWriter = new BinaryWriter(File.Open(_tempMPD, FileMode.Open)))
{
foreach (var modPackPage in modPackData.ModPackPages)
{
var modPackPageJson = new ModPackPageJson
{
PageIndex = modPackPage.PageIndex,
ModGroups = new List <ModGroupJson>()
};
modPackJson.ModPackPages.Add(modPackPageJson);
foreach (var modGroup in modPackPage.ModGroups)
{
var modGroupJson = new ModGroupJson
{
GroupName = modGroup.GroupName,
SelectionType = modGroup.SelectionType,
OptionList = new List <ModOptionJson>()
};
modPackPageJson.ModGroups.Add(modGroupJson);
foreach (var modOption in modGroup.OptionList)
{
var randomFileName = "";
if (modOption.Image != null)
{
randomFileName = $"{Path.GetRandomFileName()}.png";
imageList.Add(randomFileName, modOption.ImageFileName);
}
var modOptionJson = new ModOptionJson
{
Name = modOption.Name,
Description = modOption.Description,
ImagePath = randomFileName,
GroupName = modOption.GroupName,
SelectionType = modOption.SelectionType,
IsChecked = modOption.IsChecked,
ModsJsons = new List <ModsJson>()
};
modGroupJson.OptionList.Add(modOptionJson);
foreach (var modOptionMod in modOption.Mods)
{
var dataFile = GetDataFileFromPath(modOptionMod.Key);
var modsJson = new ModsJson
{
Name = modOptionMod.Value.Name,
Category = modOptionMod.Value.Category.GetEnDisplayName(),
FullPath = modOptionMod.Key,
ModSize = modOptionMod.Value.ModDataBytes.Length,
ModOffset = binaryWriter.BaseStream.Position,
DatFile = dataFile.GetDataFileName(),
};
binaryWriter.Write(modOptionMod.Value.ModDataBytes);
modOptionJson.ModsJsons.Add(modsJson);
}
}
}
progress?.Report((double)pageCount / modPackData.ModPackPages.Count);
pageCount++;
}
}
File.WriteAllText(_tempMPL, JsonConvert.SerializeObject(modPackJson));
var modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}.ttmp2");
if (File.Exists(modPackPath) && !overwriteModpack)
{
var fileNum = 1;
modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}({fileNum}).ttmp2");
while (File.Exists(modPackPath))
{
fileNum++;
modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}({fileNum}).ttmp2");
}
}
else if (File.Exists(modPackPath) && overwriteModpack)
{
File.Delete(modPackPath);
}
using (var zip = ZipFile.Open(modPackPath, ZipArchiveMode.Create))
{
zip.CreateEntryFromFile(_tempMPL, "TTMPL.mpl");
zip.CreateEntryFromFile(_tempMPD, "TTMPD.mpd");
foreach (var image in imageList)
{
zip.CreateEntryFromFile(image.Value, image.Key);
}
}
File.Delete(_tempMPD);
File.Delete(_tempMPL);
return(pageCount);
});
return(processCount);
}
/// <summary> /// Imports a simple mod pack /// </summary> /// <param name="modPackJson">The mod pack json</param> private async Task ImportSimpleModPack(ModPackJson modPackJson, IProgress <(int count, int total)> progress)
/// <summary>
/// Creates a mod pack that uses a wizard for installation
/// </summary>
/// <param name="modPackData">The data that will go into the mod pack</param>
/// <param name="progress">The progress of the mod pack creation</param>
/// <returns>The number of pages created for the mod pack</returns>
public async Task <int> CreateWizardModPack(ModPackData modPackData, IProgress <double> progress, bool overwriteModpack)
{
var processCount = await Task.Run <int>(() =>
{
var guid = Guid.NewGuid();
var dir = Path.Combine(Path.GetTempPath(), guid.ToString());
Directory.CreateDirectory(dir);
_tempMPD = Path.Combine(dir, "TTMPD.mpd");
_tempMPL = Path.Combine(dir, "TTMPL.mpl");
var imageList = new HashSet <string>();
var pageCount = 1;
Version version = modPackData.Version == null ? new Version(1, 0, 0, 0) : modPackData.Version;
var modPackJson = new ModPackJson
{
TTMPVersion = _currentWizardTTMPVersion,
MinimumFrameworkVersion = _minimumAssembly,
Name = modPackData.Name,
Author = modPackData.Author,
Version = version.ToString(),
Description = modPackData.Description,
Url = modPackData.Url,
ModPackPages = new List <ModPackPageJson>()
};
using (var binaryWriter = new BinaryWriter(File.Open(_tempMPD, FileMode.Create)))
{
foreach (var modPackPage in modPackData.ModPackPages)
{
var modPackPageJson = new ModPackPageJson
{
PageIndex = modPackPage.PageIndex,
ModGroups = new List <ModGroupJson>()
};
modPackJson.ModPackPages.Add(modPackPageJson);
foreach (var modGroup in modPackPage.ModGroups)
{
var modGroupJson = new ModGroupJson
{
GroupName = modGroup.GroupName,
SelectionType = modGroup.SelectionType,
OptionList = new List <ModOptionJson>()
};
modPackPageJson.ModGroups.Add(modGroupJson);
foreach (var modOption in modGroup.OptionList)
{
var imageFileName = "";
if (modOption.Image != null)
{
var fname = Path.GetFileName(modOption.ImageFileName);
imageFileName = Path.Combine(dir, fname);
File.Copy(modOption.ImageFileName, imageFileName, true);
imageList.Add(imageFileName);
}
var fn = imageFileName == "" ? "" : "images/" + Path.GetFileName(imageFileName);
var modOptionJson = new ModOptionJson
{
Name = modOption.Name,
Description = modOption.Description,
ImagePath = fn,
GroupName = modOption.GroupName,
SelectionType = modOption.SelectionType,
IsChecked = modOption.IsChecked,
ModsJsons = new List <ModsJson>()
};
modGroupJson.OptionList.Add(modOptionJson);
foreach (var modOptionMod in modOption.Mods)
{
var dataFile = GetDataFileFromPath(modOptionMod.Key);
if (ForbiddenModTypes.Contains(Path.GetExtension(modOptionMod.Key)))
{
continue;
}
var modsJson = new ModsJson
{
Name = modOptionMod.Value.Name,
Category = modOptionMod.Value.Category.GetEnDisplayName(),
FullPath = modOptionMod.Key,
IsDefault = modOptionMod.Value.IsDefault,
ModSize = modOptionMod.Value.ModDataBytes.Length,
ModOffset = binaryWriter.BaseStream.Position,
DatFile = dataFile.GetDataFileName(),
};
binaryWriter.Write(modOptionMod.Value.ModDataBytes);
modOptionJson.ModsJsons.Add(modsJson);
}
}
}
progress?.Report((double)pageCount / modPackData.ModPackPages.Count);
pageCount++;
}
}
File.WriteAllText(_tempMPL, JsonConvert.SerializeObject(modPackJson));
var modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}.ttmp2");
if (File.Exists(modPackPath) && !overwriteModpack)
{
var fileNum = 1;
modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}({fileNum}).ttmp2");
while (File.Exists(modPackPath))
{
fileNum++;
modPackPath = Path.Combine(_modPackDirectory.FullName, $"{modPackData.Name}({fileNum}).ttmp2");
}
}
else if (File.Exists(modPackPath) && overwriteModpack)
{
File.Delete(modPackPath);
}
var zf = new ZipFile();
zf.UseZip64WhenSaving = Zip64Option.AsNecessary;
zf.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
zf.AddFile(_tempMPL, "");
zf.AddFile(_tempMPD, "");
zf.Save(modPackPath);
foreach (var image in imageList)
{
zf.AddFile(image, "images");
}
zf.Save(modPackPath);
File.Delete(_tempMPD);
File.Delete(_tempMPL);
return(pageCount);
});
return(processCount);
}
/// <summary>
/// Adds the given mod entry to the simple mod pack data list
/// </summary>
/// <param name="modsJson">The JSON describing the mod to be added to the list</param>
/// <param name="modding"></param>
/// <param name="modPackJson">The JSON describing the entire modpack</param>
/// <returns>Task</returns>
private async Task AddToList(ModsJson modsJson, Modding modding, ModPackJson modPackJson)
{
var raceTask = GetRace(modsJson.FullPath);
var numberTask = GetNumber(modsJson.FullPath);
var typeTask = GetType(modsJson.FullPath);
var partTask = GetPart(modsJson.FullPath);
var mapTask = GetMap(modsJson.FullPath);
var active = false;
var isActiveTask = modding.IsModEnabled(modsJson.FullPath, false);
var taskList = new List <Task> {
raceTask, numberTask, typeTask, partTask, mapTask, isActiveTask
};
var race = XivRace.All_Races;
string number = string.Empty, type = string.Empty, part = string.Empty, map = string.Empty;
var isActive = XivModStatus.Disabled;
while (taskList.Any())
{
var finished = await Task.WhenAny(taskList);
if (finished == raceTask)
{
taskList.Remove(raceTask);
race = await raceTask;
}
else if (finished == numberTask)
{
taskList.Remove(numberTask);
number = await numberTask;
}
else if (finished == typeTask)
{
taskList.Remove(typeTask);
type = await typeTask;
}
else if (finished == partTask)
{
taskList.Remove(partTask);
part = await partTask;
}
else if (finished == mapTask)
{
taskList.Remove(mapTask);
map = await mapTask;
}
else if (finished == isActiveTask)
{
taskList.Remove(isActiveTask);
isActive = await isActiveTask;
}
}
if (isActive == XivModStatus.Enabled || isActive == XivModStatus.MatAdd)
{
active = true;
}
modsJson.ModPackEntry = new ModPack
{
name = modPackJson.Name, author = modPackJson.Author, version = modPackJson.Version
};
System.Windows.Application.Current.Dispatcher.Invoke(() => _simpleDataList.Add(new SimpleModPackEntries
{
Name = modsJson.Name,
Category = modsJson.Category,
Race = race.ToString(),
Type = type,
Part = part,
Num = number,
Map = map,
Active = active,
JsonEntry = modsJson,
}));
}
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
var backgroundWorker = sender as BackgroundWorker;
var packCount = packList.Count;
var packRemaining = packCount;
var currentPackCount = 0;
long offset = 0;
float i = 0;
List <byte> modPackData = new List <byte>();
tempMPL = Path.GetTempFileName();
tempMPD = Path.GetTempFileName();
using (StreamWriter sw = new StreamWriter(tempMPL))
{
using (BinaryWriter bw = new BinaryWriter(File.Open(tempMPD, FileMode.Open)))
{
while (currentPackCount < packCount)
{
List <ModPackItems> pack;
if (packRemaining > 100)
{
pack = packList.GetRange(currentPackCount, 100);
packRemaining -= 100;
currentPackCount += 100;
}
else
{
pack = packList.GetRange(currentPackCount, packRemaining);
currentPackCount += packRemaining;
}
backgroundWorker.ReportProgress((int)((i / packCount) * 100), "\nReading " + pack.Count + " Entries (" + currentPackCount + "/" + packList.Count + ")\n\n");
foreach (var mpi in pack)
{
List <string> modPackList = new List <string>();
var currentImport = mpi.Name + "....";
backgroundWorker.ReportProgress((int)((i / packCount) * 100), currentImport);
var mOffset = mpi.Entry.modOffset;
var datFile = mpi.Entry.datFile;
int datNum = ((mOffset / 8) & 0x0F) / 2;
var datPath = string.Format(Info.datDir, datFile, datNum);
mOffset = Helper.OffsetCorrection(datNum, mOffset);
offset += modPackData.Count;
var mpj = new ModPackJson()
{
Name = mpi.Name,
Category = mpi.Entry.category,
FullPath = mpi.Entry.fullPath,
ModOffset = offset,
ModSize = mpi.Entry.modSize,
DatFile = mpi.Entry.datFile
};
modPackList.Add(JsonConvert.SerializeObject(mpj));
modPackData.Clear();
using (BinaryReader br = new BinaryReader(File.OpenRead(datPath)))
{
br.BaseStream.Seek(mOffset, SeekOrigin.Begin);
modPackData.AddRange(br.ReadBytes(mpi.Entry.modSize));
}
foreach (var l in modPackList)
{
sw.WriteLine(l);
}
bw.Write(modPackData.ToArray());
i++;
backgroundWorker.ReportProgress((int)((i / packCount) * 100), "Done.");
}
}
}
}
backgroundWorker.ReportProgress(-1, "\nCreating TTMP File, this may take some time...");
using (var zip = ZipFile.Open(mpDir + "\\" + mpName + ".ttmp", ZipArchiveMode.Create))
{
zip.CreateEntryFromFile(tempMPL, "TTMPL.mpl");
zip.CreateEntryFromFile(tempMPD, "TTMPD.mpd");
}
backgroundWorker.ReportProgress(-2, "Done.");
}
/// <summary>
/// Creates a mod pack that uses simple installation
/// </summary>
/// <param name="modPackData">The data that will go into the mod pack</param>
/// <param name="gameDirectory">The game directory</param>
/// <param name="progress">The progress of the mod pack creation</param>
/// <returns>The number of mods processed for the mod pack</returns>
public async Task <int> CreateSimpleModPack(SimpleModPackData modPackData, DirectoryInfo gameDirectory, IProgress <double> progress)
{
var processCount = await Task.Run <int>(() =>
{
var dat = new Dat(gameDirectory);
_tempMPD = Path.GetTempFileName();
_tempMPL = Path.GetTempFileName();
var modCount = 1;
var modPackJson = new ModPackJson
{
TTMPVersion = _currentSimpleTTMPVersion,
Name = modPackData.Name,
Author = modPackData.Author,
Version = modPackData.Version.ToString(),
Description = modPackData.Description,
SimpleModsList = new List <ModsJson>()
};
using (var binaryWriter = new BinaryWriter(File.Open(_tempMPD, FileMode.Open)))
{
foreach (var simpleModData in modPackData.SimpleModDataList)
{
var modsJson = new ModsJson
{
Name = simpleModData.Name,
Category = simpleModData.Category,
FullPath = simpleModData.FullPath,
ModSize = simpleModData.ModSize,
DatFile = simpleModData.DatFile,
ModOffset = binaryWriter.BaseStream.Position
};
var rawData = dat.GetRawData((int)simpleModData.ModOffset, XivDataFiles.GetXivDataFile(simpleModData.DatFile),
simpleModData.ModSize);
binaryWriter.Write(rawData);
modPackJson.SimpleModsList.Add(modsJson);
progress?.Report((double)modCount / modPackData.SimpleModDataList.Count);
modCount++;
}
}
File.WriteAllText(_tempMPL, JsonConvert.SerializeObject(modPackJson));
var modPackPath = $"{_modPackDirectory}\\{modPackData.Name}.ttmp";
if (File.Exists(modPackPath))
{
var fileNum = 1;
modPackPath = $"{_modPackDirectory}\\{modPackData.Name}({fileNum}).ttmp";
while (File.Exists(modPackPath))
{
fileNum++;
modPackPath = $"{_modPackDirectory}\\{modPackData.Name}({fileNum}).ttmp";
}
}
using (var zip = ZipFile.Open(modPackPath, ZipArchiveMode.Create))
{
zip.CreateEntryFromFile(_tempMPL, "TTMPL.mpl");
zip.CreateEntryFromFile(_tempMPD, "TTMPD.mpd");
}
File.Delete(_tempMPD);
File.Delete(_tempMPL);
return(modCount);
});
return(processCount);
}
