public void BypassSort(string fldName)
{
var fs = new Fs17RegWork(false);
var chkName = fldName.GetLastFolderName();
const string BYPASS = "******";
var pth = fs.Read(Fs17RegKeys.FS17_GROUPS) + "\\" + BYPASS;
if (pth.FileExists())
{
var dic = Serializer.DeserializeDictionary(pth);
if (dic.ContainsKey(chkName))
{
MsgBx.Msg("That Mod has already been added to the bypass list.", "Error");
return;
}
dic.Add(fldName, fs.Read(Fs17RegKeys.FS17_GROUPS) + "\\");
Serializer.SerializeDictionary(pth, dic);
}
else
{
var sb = new Dictionary <string, string> {
{ fldName, fs.Read(Fs17RegKeys.FS17_GROUPS) + "\\" }
};
Serializer.SerializeDictionary(pth, sb);
}
}
/// <summary>
/// Changes the silo total amount.
/// </summary>
public void ChangeSiloTotalAmount(string saveGame)
{
if (saveGame.IsNullOrEmpty())
{
MsgBx.Msg("You did not choose a SaveGame to Modify", "Profile Error");
return;
}
var pth = saveGame + "careerSavegame.xml";
if (!pth.FileExists())
{
return;
}
var doc = XDocument.Load(pth);
var q = from node in doc.Descendants()
where node.Name == "totalAmount"
where node.Attributes().Any()
select new { NodeName = node.Name, Attributes = node.Attributes() };
foreach (var node in q)
{
foreach (var attribute in node.Attributes)
{
if (attribute.Name == "value")
{
attribute.SetValue(AMOUNT);
}
}
}
doc.Save(pth);
MsgBx.Msg("Cheat - Change Silo Capacity - has been applied to " + saveGame.GetLastFolderName(), "Cheat");
}
private void copyModsToolStripMenuItem_Click(object sender, EventArgs e)
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var prof = reg.Read(RegKeys.CURRENT_PROFILE);
if (prof.IsNullOrEmpty() || gam.IsNullOrEmpty())
{
MsgBx.Msg("You need to select a Game / Profile to use this Function", "Missing Data");
return;
}
var cm = new CopyMods();
var dic = cm.CopyProfileMods();
if (dic.IsNull())
{
return;
}
lstProfileMods.Items.Clear();
foreach (var v in dic)
{
lstProfileMods.Items.Add(v.Key);
}
}
/// <summary>
/// Deletes the folders / files.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="pop"></param>
public static void DeleteFilesOrFolders(string path, bool pop = true)
{
var del = false;
var attr = new FileAttributes();
if (!path.IsNullOrEmpty())
{
if (IsDirectory(path) || IsFile(path))
{
attr = File.GetAttributes(path);
}
}
//detect whether its a directory or file
if (attr.IsEmpty())
{
return;
}
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
var directory = new DirectoryInfo(path);
try {
foreach (var file in directory.GetFiles())
{
DeleteFile(file.ToString());
}
foreach (var subDirectory in directory.GetDirectories())
{
subDirectory.Delete(true);
}
directory.EmptyThisDirectory();
directory.Delete(true);
}
catch (Exception g) {
MsgBx.Msg(g.ToString(), "Deletion Error");
}
}
else
{
try {
if (!path.FileExists())
{
return;
}
del = DeleteFile(path);
}
catch (Exception d) {
MsgBx.Msg(d.ToString(), "Deletion Error");
}
}
if (!pop)
{
return;
}
if (del)
{
MsgBx.Msg("File(s) have been deleted", "File Deletion");
}
}
/// <summary>
/// Checks the base hash.
/// </summary>
public void CheckBaseHash()
{
var reg = new AtsRegWork(true);
var acGam = reg.Read(RegKeys.CURRENT_GAME);
string tmp;
string hsh;
string newHash;
switch (acGam)
{
case "ATS":
tmp = reg.Read(AtsRegKeys.ATS_BASE_SCS_LOCATION);
if (tmp.IsNullOrEmpty())
{
LocateBase();
tmp = reg.Read(AtsRegKeys.ATS_BASE_SCS_LOCATION);
}
hsh = reg.Read(AtsRegKeys.ATS_BASE_HASH);
newHash = Hasher.HashFile(tmp);
if (!string.Equals(newHash, hsh, StringComparison.OrdinalIgnoreCase))
{
reg.Write(AtsRegKeys.ATS_BASE_HASH, newHash);
ExtractBaseFiles();
ExtractDefFiles();
}
else
{
MsgBx.Msg("No Update Necessary", "Up to Date Base Files");
}
break;
case "ETS":
tmp = reg.Read(EtsRegKeys.ETS_BASE_SCS_LOCATION);
if (tmp.IsNullOrEmpty())
{
LocateBase();
tmp = reg.Read(EtsRegKeys.ETS_BASE_SCS_LOCATION);
}
hsh = reg.Read(EtsRegKeys.ETS_BASE_HASH);
newHash = Hasher.HashFile(tmp);
if (!string.Equals(newHash, hsh, StringComparison.OrdinalIgnoreCase))
{
reg.Write(EtsRegKeys.ETS_BASE_HASH, newHash);
ExtractBaseFiles();
ExtractDefFiles();
}
else
{
MsgBx.Msg("No Update Necessary", "Up to Date Base Files");
}
break;
}
}
private static void DeleteMods()
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
string pth;
IEnumerable <string> lst;
switch (gam)
{
case "ATS":
pth = reg.Read(AtsRegKeys.ATS_GAME_MOD_FOLDER);
if (!pth.FolderExists())
{
return;
}
lst = GetFilesFolders.GetFiles(pth, "*.*");
foreach (var t in lst)
{
try {
DeleteFile(t);
}
catch (Exception g) {
MsgBx.Msg(g.ToString(), "Error");
}
}
FolderCreator.CreatePublicFolders(reg.Read(AtsRegKeys.ATS_GAME_MOD_FOLDER));
break;
case "ETS":
pth = reg.Read(EtsRegKeys.ETS_GAME_MOD_FOLDER);
if (!pth.FolderExists())
{
return;
}
lst = GetFilesFolders.GetFiles(pth, "*.*");
foreach (var s in lst)
{
try {
DeleteFile(s);
}
catch (Exception g) {
MsgBx.Msg(g.ToString(), "Error");
}
}
FolderCreator.CreatePublicFolders(reg.Read(EtsRegKeys.ETS_GAME_MOD_FOLDER));
break;
}
}
/// <summary>
/// Saves a file
/// </summary>
/// <param name="content">Content of the file</param>
/// <param name="fileName">Path of the file</param>
/// <exception cref="System.Exception">Directory must be specified for the file</exception>
/// <exception cref="Exception">Directory must be specified for the file</exception>
internal void SaveFile(string content, string fileName)
{
FileStream writer = null;
try {
var contentBytes = Encoding.UTF8.GetBytes(content);
var index = fileName.LastIndexOf('/');
if (index <= 0)
{
index = fileName.LastIndexOf(Path.DirectorySeparatorChar);
}
if (index <= 0)
{
throw new Exception("Directory must be specified for the file");
}
var directory = fileName.Remove(index) + Path.DirectorySeparatorChar;
if (!directory.FolderExists())
{
Directory.CreateDirectory(directory);
}
var opened = false;
while (!opened)
{
try {
writer = File.Open(fileName, FileMode.Create, FileAccess.Write, FileShare.None);
opened = true;
}
catch (IOException e) {
MsgBx.Msg(e.Message, "File Open Error");
}
}
writer.Write(contentBytes, 0, contentBytes.Length);
writer.Close();
}
catch (Exception a) {
MsgBx.Msg(a.Message, "File Write Error");
}
finally {
if (writer == null)
{
}
else
{
writer.Close();
writer.Dispose();
}
}
}
/// <summary>
/// Creates the sym link.
/// </summary>
/// <param name="symLinkFileName">Name of the file.</param>
/// <param name="targetName">Name of the target.</param>
/// <param name="num">The number.</param>
/// <exception cref="Win32Exception"></exception>
public static void CreateSymLink(string symLinkFileName, string targetName, uint num)
{
if (symLinkFileName.FileExists())
{
return;
}
var success = CreateSymbolicLink(symLinkFileName, targetName, num);
if (success)
{
return;
}
// var error = Marshal.GetLastWin32Error();
MsgBx.Msg("There was a problem with the path creating the link, link creation failure", "Link Creator");
}
/// <summary>
/// Fast file move with big buffers
/// </summary>
/// <param name="source">Source file path</param>
/// <param name="destination">Destination file path</param>
/// <param name="deleteSrc">if set to <c>true</c> [delete source].</param>
public static void FileCopy(string source, string destination, bool deleteSrc = false)
{
if (Equals(source, destination))
{
return;
}
if (!source.FileExists())
{
return;
}
var arrayLength = (int)Math.Pow(2, 19);
var dataArray = new byte[arrayLength];
if (!destination.DirectoryName().FolderExists())
{
try {
Directory.CreateDirectory(destination.DirectoryName());
}
catch (Exception e) {
MsgBx.Msg(e.Message, "File IO ERROR");
}
}
using (var fsread = new FileStream
(source, FileMode.Open, FileAccess.Read, FileShare.None, arrayLength)) {
using (var bwread = new BinaryReader(fsread)) {
using (var fswrite = new FileStream
(destination, FileMode.Create, FileAccess.Write, FileShare.None, arrayLength)) {
using (var bwwrite = new BinaryWriter(fswrite)) {
for (;;)
{
var read = bwread.Read(dataArray, 0, arrayLength);
if (0 == read)
{
break;
}
bwwrite.Write(dataArray, 0, read);
}
}
}
}
}
if (deleteSrc)
{
DeleteFiles.DeleteFilesOrFolders(source, false);
}
}
private static void CreateFolders()
{
var atsw = new Fs17RegWork(true);
var ofd = new FolderBrowserDialog {
Description = @"Navigate to where you want the top folder for FS17",
ShowNewFolderButton = false
};
ofd.ShowDialog();
if (!ofd.SelectedPath.FolderExists())
{
return;
}
var pth = ofd.SelectedPath;
FolderCreator.CreatePublicFolders(pth + "\\FS17Repo");
atsw.Write(Fs17RegKeys.FS17_REPO, pth + "\\FS17Repo\\");
var tmp = pth + "\\FS17Repo\\";
FolderCreator.CreatePublicFolders(tmp + "FS17Extraction");
atsw.Write(Fs17RegKeys.FS17_EXTRACTION, tmp + "FS17Extraction");
FolderCreator.CreatePublicFolders(tmp + "FS17Profiles");
atsw.Write(Fs17RegKeys.FS17_PROFILES, tmp + "Fs17Profiles\\");
FolderCreator.CreatePublicFolders(tmp + "FS17Groups");
atsw.Write(Fs17RegKeys.FS17_GROUPS, tmp + "FS17Groups\\");
FolderCreator.CreatePublicFolders(tmp + "FS17Xml");
atsw.Write(Fs17RegKeys.FS17_XML, tmp + "FS17Xml\\");
FolderCreator.CreatePublicFolders(tmp + "FS17Work");
atsw.Write(Fs17RegKeys.FS17_WORK, tmp + "FS17Work\\");
ofd = new FolderBrowserDialog {
Description = @"Navigate to Farming Simulator 2017 Mod Folder",
ShowNewFolderButton = false
};
ofd.ShowDialog();
if (ofd.SelectedPath.FolderExists())
{
atsw.Write(Fs17RegKeys.FS17_GAME_MOD_FOLDER, ofd.SelectedPath + "\\");
var t = ofd.SelectedPath.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase);
var fix = ofd.SelectedPath.Substring(0, t) + "\\";
atsw.Write(Fs17RegKeys.FS17_GAME_SETTINGS_XML, fix + "gameSettings.xml");
}
MsgBx.Msg("All folders have been created for FS17", "Game Intializer");
}
private void addToNewHollandToolStripMenuItem_Click(object sender, EventArgs e)
{
if (lstAvailableMods.SelectedItem.IsNull())
{
return;
}
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var cProf = reg.Read(RegKeys.CURRENT_PROFILE);
if (gam.IsNullOrEmpty() || cProf.IsNullOrEmpty())
{
MsgBx.Msg("You need to have a Profile / Game active", "Process Error");
return;
}
LoadOuts.CreateLoadouts("NewHolland", lstAvailableMods.SelectedItem.ToString());
}
/// <summary>
/// Extracts the archive.
/// </summary>
/// <param name="arcName">Name of the arc.</param>
public static void ExtractArchive(string arcName)
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var extPath = string.Empty;
var archive = string.Empty;
Dictionary <string, string> dic = null;
switch (gam)
{
case "FS15":
extPath = reg.Read(Fs15RegKeys.FS15_WORK);
dic = Serializer.DeserializeDictionary(
reg.Read(Fs15RegKeys.FS15_XML) + "sortedFileListComplete.xml");
break;
case "FS17":
extPath = reg.Read(Fs17RegKeys.FS17_WORK);
dic = Serializer.DeserializeDictionary(
reg.Read(Fs17RegKeys.FS17_XML) + "sortedFileListComplete.xml");
break;
}
if (dic != null && dic.Any(v => string.Equals(v.Key, arcName, StringComparison.OrdinalIgnoreCase)))
{
dic.TryGetValue(arcName, out archive);
}
var folderName = arcName.GetNameNoExtension();
reg.Write(RegKeys.CURRENT_EXTRACTED_FOLDER_PATH, extPath + folderName + "\\");
archive = archive + arcName;
if (!archive.FileExists())
{
MsgBx.Msg("There was a problem with the path to the Archive", "Process Error");
return;
}
var line = @" x " + Vars.QuoteMark + archive + Vars.QuoteMark + " -o" +
Vars.QuoteMark + extPath + "\\" + folderName + Vars.QuoteMark + @" -r";
ProcessArchive(line);
MsgBx.Msg("Files have been extracted", "Archive Extractor");
}
/// <summary>
/// Removes the mod.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public Dictionary <string, string> ProfileRemoveMod(string key)
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var profile = reg.Read(RegKeys.CURRENT_PROFILE);
var modPath = string.Empty;
switch (gam)
{
case "ATS":
modPath = reg.Read(AtsRegKeys.ATS_PROFILES) + profile + "\\" + profile + XML_EXT;
break;
case "ETS":
modPath = reg.Read(EtsRegKeys.ETS_PROFILES) + profile + "\\" + profile + XML_EXT;
break;
case "FS15":
modPath = reg.Read(Fs15RegKeys.FS15_PROFILES) + profile + "\\" + profile + XML_EXT;
break;
case "FS17":
modPath = reg.Read(Fs17RegKeys.FS17_PROFILES) + profile + "\\" + profile + XML_EXT;
break;
}
var dic = Serializer.DeserializeDictionary(modPath);
if (dic.Any(v => string.Equals(v.Key, key, StringComparison.OrdinalIgnoreCase)))
{
var mod = reg.Read(Fs17RegKeys.FS17_PROFILES) + profile + "\\" + key;
dic.Remove(key);
DeleteFiles.DeleteFilesOrFolders(mod);
var ls = new ListCreator();
ls.CreateSortedLists();
ls.SortedFileListComplete();
MsgBx.Msg("Operation completed successfully", "Mod Remover");
}
Serializer.SerializeDictionary(modPath, dic);
return(dic);
}
private static void CreateFolders()
{
var atsw = new AtsRegWork(true);
var ofd = new FolderBrowserDialog {
Description = @"Navigate to where you want the top folder for ATS",
ShowNewFolderButton = false
};
ofd.ShowDialog();
if (!ofd.SelectedPath.FolderExists())
{
return;
}
var pth = ofd.SelectedPath;
FolderCreator.CreatePublicFolders(pth + "\\ATSRepo");
atsw.Write(AtsRegKeys.ATS_REPO, pth + "\\ATSRepo\\");
var tmp = pth + "\\ATSRepo\\";
FolderCreator.CreatePublicFolders(tmp + "ATSExtraction");
atsw.Write(AtsRegKeys.ATS_EXTRACTION, tmp + "ATSExtraction");
FolderCreator.CreatePublicFolders(tmp + "ATSProfiles");
atsw.Write(AtsRegKeys.ATS_PROFILES, tmp + "ATSProfiles\\");
FolderCreator.CreatePublicFolders(tmp + "ATSGroups");
atsw.Write(AtsRegKeys.ATS_GROUPS, tmp + "ATSGroups\\");
FolderCreator.CreatePublicFolders(tmp + "ATSXml");
atsw.Write(AtsRegKeys.ATS_XML, tmp + "ATSXml\\");
FolderCreator.CreatePublicFolders(tmp + "ATSWork");
atsw.Write(AtsRegKeys.ATS_WORK, tmp + "ATSWork\\");
ofd = new FolderBrowserDialog {
Description = @"Navigate to your ATS Game Mod Folder",
ShowNewFolderButton = false
};
ofd.ShowDialog();
if (ofd.SelectedPath.FolderExists())
{
atsw.Write(AtsRegKeys.ATS_GAME_MOD_FOLDER, ofd.SelectedPath + "\\");
}
MsgBx.Msg("All folders have been created for ATS", "Game Intializer");
}
/// <summary>
/// </summary>
public void MoveMod(string mod)
{
var loc = GetLocation();
if (loc.IsNullOrEmpty())
{
return;
}
if (!mod.FileExists())
{
return;
}
FileCopyMove.FileCopy(mod, loc + mod.GetFileName(), true);
var ls = new ListCreator();
ls.CreateSortedLists();
ls.SortedFileListComplete();
MsgBx.Msg("Operation completed successfully..", "Mod Mover");
}
/// <summary>
/// Creates the zip.
/// </summary>
/// <param name="outPathname">The out pathname.</param>
/// <param name="folderName">Name of the folder.</param>
public static void CreateArchive(string outPathname, string folderName)
{
var fsOut = File.Create(outPathname);
var zipStream = new ZipOutputStream(fsOut);
zipStream.SetLevel(7); //0-9, 9 being the highest level of compression
//zipStream.Password = password; // optional. Null is the same as not setting. Required if using AES.
// This setting will strip the leading part of the folder path in the entries, to
// make the entries relative to the starting folder.
// To include the full path for each entry up to the drive root, assign folderOffset = 0.
var folderOffset = folderName.Length +
(folderName.EndsWith("\\", StringComparison.OrdinalIgnoreCase) ? 0 : 1);
CompressFolder(folderName, zipStream, folderOffset);
zipStream.IsStreamOwner = true; // Makes the Close also Close the underlying stream
zipStream.Close();
MsgBx.Msg("Archive Created: " + outPathname.GetFileName(), "Archive Creator");
}
/// <summary>
/// Makes the sorted list.
/// </summary>
public void SortedFileListComplete()
{
var dic = new Dictionary <string, string>();
var gi = new GameInfo();
var tmp = gi.GetGame();
if (tmp.IsNullOrEmpty())
{
return;
}
IEnumerable <string> lst = null;
var path = string.Empty;
switch (tmp)
{
case "ATS":
var atsP = new AtsRegWork(true);
path = atsP.Read(AtsRegKeys.ATS_XML) + "sortedFileListComplete.xml";
FolderPath = atsP.Read(AtsRegKeys.ATS_GROUPS);
lst = GetFilesFolders.GetFilesRecursive(FolderPath, "*.scs");
break;
case "ETS":
var etsP = new EtsRegWork(true);
path = etsP.Read(EtsRegKeys.ETS_XML) + "sortedFileListComplete.xml";
FolderPath = etsP.Read(EtsRegKeys.ETS_GROUPS);
lst = GetFilesFolders.GetFilesRecursive(FolderPath, "*.scs");
break;
case "FS15":
var fs15 = new Fs15RegWork(true);
path = fs15.Read(Fs15RegKeys.FS15_XML) + "sortedFileListComplete.xml";
FolderPath = fs15.Read(Fs15RegKeys.FS15_GROUPS);
lst = GetFilesFolders.GetFilesRecursive(FolderPath, "*.zip");
break;
case "FS17":
var fs17 = new Fs17RegWork(true);
path = fs17.Read(Fs17RegKeys.FS17_XML) + "sortedFileListComplete.xml";
FolderPath = fs17.Read(Fs17RegKeys.FS17_GROUPS);
lst = GetFilesFolders.GetFilesRecursive(FolderPath, "*.zip");
break;
}
if (lst.IsNull())
{
return;
}
Debug.Assert(lst != null, nameof(lst) + " != null");
foreach (var v in lst)
{
var file = v.GetFileName();
var pth = Path.GetDirectoryName(v);
if (dic.ContainsKey(file))
{
continue;
}
dic.Add(file, pth + "\\");
}
Serializer.SerializeDictionary(path, dic);
MsgBx.Msg("List Creation Completed", "List Creator");
}
private void toolStripMenuItem1_Click(object sender, EventArgs e)
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var cProf = reg.Read(RegKeys.CURRENT_PROFILE);
if (gam.IsNullOrEmpty() || cProf.IsNullOrEmpty())
{
MsgBx.Msg("You need to have a Profile / Game active", "Process Error");
return;
}
string tmp;
string profPath;
Dictionary <string, string> lst = null;
lstProfileMods.Items.Clear();
switch (gam)
{
case "ATS":
var ats = new AtsLoader();
var atsp = new AtsRegWork(true);
var prof = new ProfileWorker();
tmp = ats.LoadAtsModChoice(lstAvailableMods.SelectedItem.ToString());
profPath = atsp.Read(AtsRegKeys.ATS_GAME_MOD_FOLDER) + tmp.GetFileName();
prof.BuildProfileList(lstAvailableMods.SelectedItem.ToString());
SymLinks.CreateSymLink(profPath, tmp, 0);
lst = ats.LoadAtsProfileMods(reg.Read(RegKeys.CURRENT_PROFILE));
break;
case "ETS":
var ets = new EtsLoader();
var etsp = new EtsRegWork(true);
prof = new ProfileWorker();
tmp = ets.LoadEtsModChoice(lstAvailableMods.SelectedItem.ToString());
profPath = etsp.Read(EtsRegKeys.ETS_GAME_MOD_FOLDER) + tmp.GetFileName();
prof.BuildProfileList(lstAvailableMods.SelectedItem.ToString());
SymLinks.CreateSymLink(profPath, tmp, 0);
lst = ets.LoadEtsProfileMods(reg.Read(RegKeys.CURRENT_PROFILE));
break;
case "FS15":
var fs15 = new Fs15Loader();
var fs15P = new Fs15RegWork(true);
tmp = fs15.LoadFs15ModChoice(lstAvailableMods.SelectedItem.ToString());
profPath = fs15P.Read(Fs15RegKeys.FS15_PROFILES) + reg.Read(RegKeys.CURRENT_PROFILE) + "\\" +
tmp.GetFileName();
prof = new ProfileWorker();
prof.BuildProfileList(lstAvailableMods.SelectedItem.ToString());
SymLinks.CreateSymLink(profPath, tmp, 0);
lst = fs15.LoadFs15ProfileMods(reg.Read(RegKeys.CURRENT_PROFILE));
break;
case "FS17":
var fs17 = new Fs17Loader();
var fs17P = new Fs17RegWork(true);
tmp = fs17.LoadFs17ModChoice(lstAvailableMods.SelectedItem.ToString());
profPath = fs17P.Read(Fs17RegKeys.FS17_PROFILES) + reg.Read(RegKeys.CURRENT_PROFILE) + "\\" +
tmp.GetFileName();
prof = new ProfileWorker();
prof.BuildProfileList(lstAvailableMods.SelectedItem.ToString());
SymLinks.CreateSymLink(profPath, tmp, 0);
lst = fs17.LoadFs17ProfileMods(reg.Read(RegKeys.CURRENT_PROFILE));
break;
}
if (lst == null)
{
return;
}
foreach (var v in lst)
{
lstProfileMods.Items.Add(v.Key);
}
CheckModCount();
label2.Text = @"Active Mods: " + lstProfileMods.Items.Count;
// MsgBx.Msg("Profile Link Created", "Linker");
}
/// <summary>
/// Extracts the definition files.
/// </summary>
public void ExtractDefFiles()
{
var reg = new AtsRegWork(true);
var acGam = reg.Read(RegKeys.CURRENT_GAME);
string tmp;
string hsh;
string newHash;
switch (acGam)
{
case "ATS":
tmp = reg.Read(AtsRegKeys.ATS_DEF_SCS_LOCATION);
if (tmp.IsNullOrEmpty())
{
LocateDef();
tmp = reg.Read(AtsRegKeys.ATS_DEF_SCS_LOCATION);
}
hsh = reg.Read(AtsRegKeys.ATS_DEF_HASH);
newHash = Hasher.HashFile(tmp);
if (!string.Equals(newHash, hsh, StringComparison.OrdinalIgnoreCase))
{
reg.Write(AtsRegKeys.ATS_DEF_HASH, newHash);
FileCopy.Source = ScsExtractor;
FileCopy.Destination = reg.Read(AtsRegKeys.ATS_EXTRACTION) + ScsExtractor.GetFileName();
FileCopy.DoCopy();
FileCopy.Source = tmp;
FileCopy.Destination = reg.Read(AtsRegKeys.ATS_EXTRACTION) + "def.scs";
FileCopy.DoCopy();
ExtractScs(reg.Read(AtsRegKeys.ATS_EXTRACTION), tmp);
}
break;
case "ETS":
tmp = reg.Read(EtsRegKeys.ETS_DEF_SCS_LOCATION);
if (tmp.IsNullOrEmpty())
{
LocateDef();
tmp = reg.Read(EtsRegKeys.ETS_DEF_SCS_LOCATION);
}
hsh = reg.Read(EtsRegKeys.ETS_DEF_HASH);
newHash = Hasher.HashFile(tmp);
var fld = reg.Read(EtsRegKeys.ETS_EXTRACTION);
if (!string.Equals(newHash, hsh, StringComparison.OrdinalIgnoreCase))
{
reg.Write(EtsRegKeys.ETS_DEF_HASH, newHash);
FileCopy.Source = ScsExtractor;
FileCopy.Destination = fld + ScsExtractor;
FileCopy.DoCopy();
FileCopy.Source = tmp;
FileCopy.Destination = fld + "def.scs";
FileCopy.DoCopy();
ExtractScs(fld, tmp);
}
break;
}
MsgBx.Msg("All base files have been updated", "Base File Extraction");
}
/// <summary>
/// Sets the cheat values.
/// </summary>
public void SetCheatValues(string saveGame)
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
switch (gam)
{
case "FS15":
var pth = saveGame;
if (!pth.FileExists())
{
return;
}
var xmlFile = XDocument.Load(pth + "\\careerSavegame.xml");
var query = from c in xmlFile.Elements("careerSavegame")
select c;
foreach (var element in query)
{
var xAttribute = element.Attribute("money");
if (xAttribute != null)
{
xAttribute.Value = MONEY;
}
var attribute = element.Attribute("isPlantWitheringEnabled");
if (attribute != null)
{
attribute.Value = WITHER;
}
}
xmlFile.Save(pth + "\\careerSavegame.xml");
MsgBx.Msg("Money / Wither Cheat Applied to " + saveGame.GetLastFolderName(), "Cheat");
break;
case "FS17":
var xdoc = new XmlDocument();
xdoc.Load(saveGame + "\\careerSavegame.xml");
var nodes = xdoc.SelectNodes("careerSavegame/statistics/money");
if (nodes == null)
{
return;
}
foreach (XmlNode node in nodes)
{
if (node.Name != "money")
{
continue;
}
var amt = node.InnerText;
var cash = Convert.ToInt32(amt);
var done = cash + Convert.ToInt32(MONEY);
node.InnerText = done.ToString();
break;
}
xdoc.Save(saveGame + "\\careerSavegame.xml");
MsgBx.Msg("Money Cheat Applied to " + saveGame.GetLastFolderName(), "Money Cheat");
break;
}
}
public void OrganizeMaps()
{
var mapLst = new List <string> {
"map",
"Map"
};
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
if (gam.IsNullOrEmpty())
{
MsgBx.Msg("Mod Sorting is Game specific, you need to choose a game", "Game Error");
return;
}
SetSearchLists();
string tmp;
IEnumerable <string> lst;
switch (gam)
{
case "ATS":
tmp = reg.Read(AtsRegKeys.ATS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstTs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(reg.Read(AtsRegKeys.ATS_GROUPS) + t);
FileCopyMove.FileCopy(v, reg.Read(AtsRegKeys.ATS_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "ETS":
var ets = new EtsRegWork(true);
tmp = ets.Read(EtsRegKeys.ETS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstTs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(ets.Read(EtsRegKeys.ETS_GROUPS) + t);
FileCopyMove.FileCopy(v, ets.Read(EtsRegKeys.ETS_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "FS15":
var fs15 = new Fs15RegWork(true);
tmp = fs15.Read(Fs15RegKeys.FS15_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.zip");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstFs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(fs15.Read(Fs15RegKeys.FS15_GROUPS) + t);
FileCopyMove.FileCopy(v, fs15.Read(Fs15RegKeys.FS15_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "FS17":
var fs17 = new Fs17RegWork(true);
var bypass = new SortingBypass();
var byPassDat = bypass.GetBypassList();
tmp = fs17.Read(Fs17RegKeys.FS17_GROUPS);
var fldLst = GetFilesFolders.GetFolders(tmp, "*.*");
var chkList = new List <string>();
var enu = fldLst.ToList();
foreach (var v in enu)
{
var chk = v.GetLastFolderName();
if (byPassDat.ContainsKey(chk))
{
continue;
}
chkList.Add(v);
}
if (chkList.IsNull())
{
return;
}
foreach (var v in chkList)
{
lst = GetFilesFolders.GetFiles(v + "\\", "*.zip");
foreach (var f in lst)
{
foreach (var t in mapLst)
{
if (!f.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var src = tmp + "\\" + "Map" + "\\" + f.GetFileName();
if (src.FileExists())
{
continue;
}
FileCopyMove.FileCopy(f, src, true);
}
}
}
break;
}
var lstCreate = new ListCreator();
lstCreate.CreateSortedLists();
lstCreate.SortedFileListComplete();
MsgBx.Msg("Map Sorting Complete", "Map Sorter");
}
/// <summary>
/// Sorts the mods.
/// </summary>
public void SortMods()
{
SetSearchLists();
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
if (gam.IsNullOrEmpty())
{
MsgBx.Msg("Mod Sorting is Game specific, you need to choose a game", "Game Error");
return;
}
string tmp;
IEnumerable <string> lst;
switch (gam)
{
case "ATS":
tmp = reg.Read(AtsRegKeys.ATS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstTs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(reg.Read(AtsRegKeys.ATS_GROUPS) + t);
FileCopyMove.FileCopy(v, reg.Read(AtsRegKeys.ATS_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "ETS":
var ets = new EtsRegWork(true);
tmp = ets.Read(EtsRegKeys.ETS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstTs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(ets.Read(EtsRegKeys.ETS_GROUPS) + t);
FileCopyMove.FileCopy(v, ets.Read(EtsRegKeys.ETS_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "FS15":
var fs15 = new Fs15RegWork(true);
tmp = fs15.Read(Fs15RegKeys.FS15_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.zip");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstFs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(fs15.Read(Fs15RegKeys.FS15_GROUPS) + t);
FileCopyMove.FileCopy(v, fs15.Read(Fs15RegKeys.FS15_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
case "FS17":
var fs17 = new Fs17RegWork(true);
tmp = fs17.Read(Fs17RegKeys.FS17_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.zip");
if (lst.IsNull())
{
return;
}
foreach (var v in lst)
{
foreach (var t in _srchLstFs)
{
if (!v.Contains(t, StringComparison.OrdinalIgnoreCase))
{
continue;
}
FolderCreator.CreatePublicFolders(fs17.Read(Fs17RegKeys.FS17_GROUPS) + t);
FileCopyMove.FileCopy(v, fs17.Read(Fs17RegKeys.FS17_GROUPS) + t + "\\" + v.GetFileName(),
true);
}
}
break;
}
DoCleanUp();
}
private static void DoCleanUp()
{
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
string tmp;
IEnumerable <string> lst;
switch (gam)
{
case "ATS":
tmp = reg.Read(AtsRegKeys.ATS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
FolderCreator.CreatePublicFolders(reg.Read(AtsRegKeys.ATS_GROUPS) + "misc");
foreach (var v in lst)
{
FileCopyMove.FileCopy(v, reg.Read(AtsRegKeys.ATS_GROUPS) + "misc" + "\\" + v.GetFileName(),
true);
}
break;
case "ETS":
var ets = new EtsRegWork(true);
tmp = ets.Read(EtsRegKeys.ETS_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.scs");
FolderCreator.CreatePublicFolders(ets.Read(EtsRegKeys.ETS_GROUPS) + "misc");
foreach (var t in lst)
{
FileCopyMove.FileCopy(t, ets.Read(EtsRegKeys.ETS_GROUPS) + "misc" + "\\" + t.GetFileName(),
true);
}
break;
case "FS15":
var fs15 = new Fs15RegWork(true);
tmp = fs15.Read(Fs15RegKeys.FS15_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.zip");
FolderCreator.CreatePublicFolders(fs15.Read(Fs15RegKeys.FS15_GROUPS) + "misc");
foreach (var v in lst)
{
FileCopyMove.FileCopy(v, fs15.Read(Fs15RegKeys.FS15_GROUPS) + "misc" + "\\" + v.GetFileName(),
true);
}
break;
case "FS17":
var fs17 = new Fs17RegWork(true);
tmp = fs17.Read(Fs17RegKeys.FS17_REPO);
lst = GetFilesFolders.GetFiles(tmp, "*.zip");
FolderCreator.CreatePublicFolders(fs17.Read(Fs17RegKeys.FS17_GROUPS) + "misc");
foreach (var v in lst)
{
FileCopyMove.FileCopy(v, fs17.Read(Fs17RegKeys.FS17_GROUPS) + "misc" + "\\" + v.GetFileName(),
true);
}
break;
}
var lstCreate = new ListCreator();
lstCreate.CreateSortedLists();
lstCreate.SortedFileListComplete();
MsgBx.Msg("Mod Sorting Complete", "Mod Sorter");
}
/// <summary>
/// Extracts the mod SCS.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>System.String.</returns>
public static string ExtractModScs(string path)
{
SevenZipBase.SetLibraryPath(LibraryFilePath);
var reg = new AtsRegWork(true);
var acGam = reg.Read(RegKeys.CURRENT_GAME);
var extractionPath = string.Empty;
switch (acGam)
{
case "ATS":
extractionPath = reg.Read(AtsRegKeys.ATS_WORK);
break;
case "ETS":
extractionPath = reg.Read(EtsRegKeys.ETS_WORK);
break;
}
var folderName = path.GetNameNoExtension();
reg.Write(RegKeys.CURRENT_EXTRACTED_FOLDER_PATH, extractionPath + folderName + "\\");
var sbePath = new StringBuilder();
sbePath.Append(extractionPath);
sbePath.Append(Path.DirectorySeparatorChar);
sbePath.Append(folderName);
sbePath.Append(Path.DirectorySeparatorChar);
if (folderName.IsNullOrEmpty() || extractionPath.IsNullOrEmpty())
{
return("There was a problem with the archive / " +
"extraction path, please try again");
}
SevenZipExtractor svChecker = null;
bool chk;
try {
svChecker = new SevenZipExtractor(path);
chk = svChecker.Check();
}
catch (Exception) {
svChecker?.Dispose();
return("This archive cannot be extracted, possible encryption or a damaged archive");
}
if (chk)
{
using (var extract = new SevenZipExtractor(path)) {
extract.ExtractArchive(sbePath.ToString());
extract.Dispose();
}
}
else
{
MsgBx.Msg(@"This archive appears to be password protected, please enter password now",
@"Password Error");
var input = Interaction.InputBox("Enter Password", "Enter Password");
using (var pswdExtract = new SevenZipExtractor(path, input)) {
try {
pswdExtract.ExtractArchive(sbePath.ToString());
pswdExtract.Dispose();
}
catch (Exception) {
pswdExtract.Dispose();
MsgBx.Msg(@"That password seems to be invalid, I cannot continue", "Invalid Password");
return("Invalid password attempt");
}
}
}
return("All files have been extracted from " + path.GetFileName());
}
/// <summary>
/// Loads the favorites.
/// </summary>
public static Dictionary <string, string> LoadFavorites(string mke)
{
var fs17 = new Fs17Loader();
var reg = new AtsRegWork(true);
var gam = reg.Read(RegKeys.CURRENT_GAME);
var cProf = reg.Read(RegKeys.CURRENT_PROFILE);
if (gam.IsNullOrEmpty() || cProf.IsNullOrEmpty())
{
MsgBx.Msg("You need to have a Profile / Game active", "Process Error");
return(null);
}
var dic = new Dictionary <string, string>()
;
switch (mke)
{
case "Claas":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\claas.xml");
break;
case "Krone":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\krone.xml");
break;
case "NewHolland":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\newholland.xml");
break;
case "JohnDeere":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\johndeere.xml");
break;
case "MasseyFerguson":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\masseyferguson.xml");
break;
case "Fendt":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\fendt.xml");
break;
case "Case":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\case.xml");
break;
case "Plows":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\plows.xml");
break;
case "Cultivators":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\cultivators.xml");
break;
case "Placeables":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\placeables.xml");
break;
case "Specials":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\specials.xml");
break;
case "TractorsOther":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\tractorsOther.xml");
break;
case "Balers":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\balers.xml");
break;
case "Trailers":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\trailers.xml");
break;
case "Tools":
dic = Serializer.DeserializeDictionary(reg.Read(Fs17RegKeys.FS17_GROUPS) + @"\tools.xml");
break;
}
var lnkPth = reg.Read(Fs17RegKeys.FS17_PROFILES) + cProf + "\\";
foreach (var v in dic)
{
var tmp = lnkPth + v.Key;
if (tmp.FileExists())
{
continue;
}
var org = v.Value + v.Key;
if (!org.FileExists())
{
continue;
}
//CreateSymbolicLink(tmp, org, SymbolicLink.File);
//SymLinks.CreateSymLink(tmp, org, 0);
// FileCopyMove.FileCopy(org, tmp);
CreateHardLink(tmp, org, IntPtr.Zero);
}
var lc = new ListCreator();
lc.CreateSortedLists();
var lst = fs17.LoadFs17ProfileMods(reg.Read(RegKeys.CURRENT_PROFILE));
return(lst);
}
