public void Serialization()
{
IModSource src = new InstalledMods(new MockFileSystem());
IModDatabase db = new ModDatabase(src, modlinks_xml, api_xml);
Assert.Equal
(
new ModItem
(
new NotInstalledState(),
new Version(3, 0, 0, 0),
new[] { "Vasi" },
"https://github.com/fifty-six/HollowKnight.QoL/releases/download/v3/QoL.zip",
"QoL",
"A collection of various quality of life improvements."
),
db.Items.First(x => x.Name == "QoL")
);
Assert.Equal(
63,
db.Api.Version
);
}
public MainWindow()
{
InitializeComponent();
eventHistory = new List <string>();
settings = new Settings();
btnDisableCrashReports.DataContext = settings;
btnEnableDeveloperMode.DataContext = settings;
CrashReporting.CrashReporter.StartWatching();
CrashReporting.CrashReporter.OnCrashDumpProcessed += CrashReporter_OnDumpProcessed;
Api.ApiQueue.OnApiRequestIssued += ApiQueue_OnApiRequestIssued;
Api.ApiQueue.OnApiRequestResult += ApiQueue_OnApiRequestResult;
TitanfallMod.OnStatusUpdateException += TitanfallMod_OnStatusUpdateException;
SDKInjector.OnLaunchingProcess += SDKInjector_OnLaunchingProcess;
SDKInjector.OnInjectingIntoProcess += SDKInjector_OnInjectingIntoProcess;
SDKInjector.OnInjectionComplete += SDKInjector_OnInjectionComplete;
SDKInjector.OnInjectionException += SDKInjector_OnInjectionException;
ModDatabase.OnStartedLoadingMods += ModDatabase_OnStartedLoadingMods;
ModDatabase.OnFinishedLoadingMods += ModDatabase_OnFinishedLoadingMods;
ModDatabase.OnModLoaded += ModDatabase_OnModLoaded;
ModDatabase.OnFinishedImportingMod += ModDatabase_OnFinishedImportingMod;
ModDatabase.LoadAll();
UpdateLauncherSelection();
}
public void RefreshMods()
{
Mods = ModDatabase.Get(SelectedGame)
.OrderBy(x => GameConfig.GetModPriority(x.Id))
.Select(x => new ModViewModel(x))
.ToList();
}
public MainWindow()
{
InitializeComponent();
eventHistory = new List <string>();
settings = new Settings();
btnDisableCrashReports.DataContext = settings;
btnEnableDeveloperMode.DataContext = settings;
CrashReporting.CrashReporter.StartWatching();
CrashReporting.CrashReporter.OnCrashDumpProcessed += CrashReporter_OnDumpProcessed;
SDKInjector.OnLaunchingProcess += SDKInjector_OnLaunchingProcess;
SDKInjector.OnInjectingIntoProcess += SDKInjector_OnInjectingIntoProcess;
SDKInjector.OnInjectionComplete += SDKInjector_OnInjectionComplete;
SDKInjector.OnInjectionException += SDKInjector_OnInjectionException;
ModDatabase.OnStartedLoadingMods += ModDatabase_OnStartedLoadingMods;
ModDatabase.OnFinishedLoadingMods += ModDatabase_OnFinishedLoadingMods;
ModDatabase.OnModLoaded += ModDatabase_OnModLoaded;
ModDatabase.OnFinishedImportingMod += ModDatabase_OnFinishedImportingMod;
ModDatabase.OnModsChanged += ModDatabase_OnModsChanged;
ModDatabase.LoadAll();
ModDatabase.WatchModsFolder();
UpdateLauncherSelection();
}
private void InitializeFolderComboBox()
{
FolderComboBox.SelectedIndex = 0;
List <string> sModFolders = new List <string> {
"All Folders"
};
var allModConfigs = GameConfig.ModConfigs.ToList();
Mods = ModDatabase.Get(SelectedGame)
.OrderBy(x => GameConfig.GetModPriority(x.Id))
.Select(x => new ModViewModel(x, SelectedGame))
.ToList();
foreach (ModViewModel modViewModel in Mods)
{
Mod mod = (Mod)modViewModel;
string modFolder = Path.GetFileName(Path.GetDirectoryName(mod.BaseDirectory));
if (modFolder != "Mods" && !Regex.IsMatch(modFolder, "Persona[^ ]*") && !sModFolders.Contains(modFolder)) //Any folder containing mod that isn't for sorting mods by game
{
sModFolders.Add(modFolder);
}
}
FolderComboBox.ItemsSource = sModFolders.ToArray();
}
public static async Task InitializeAsync()
{
_mods = await DataUtils.LoadRePoEAsync <Dictionary <string, JsonMod> >("mods");
_benchOptions = await DataUtils.LoadRePoEAsync <JsonCraftingBenchOption[]>("crafting_bench_options");
_modDatabase = new ModDatabase(_mods, _benchOptions);
}
public void ReadEmptyState()
{
IModSource src = new InstalledMods(new MockFileSystem());
IModDatabase db = new ModDatabase(src, modlinks_xml, api_xml);
Assert.True(db.Items.All(x => x.State is NotInstalledState));
}
/// <summary>
/// Refreshes the mods.
/// Clears the nodestore,
/// Sets up the modviewmodels from the moddatabase
/// adds them to a list and the nodestore
/// </summary>
private void RefreshMods()
{
ModGrid.NodeStore.Clear();
Mods = ModDatabase.Get(SelectedGame)
.OrderBy(x => GameConfig.GetModPriority(x.Id))
.Select(x => new ModViewModel(x))
.ToList();
Mods.ForEach(x => ModGrid.NodeStore.AddNode(x));
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="environment">The web hosting environment.</param>
/// <param name="wikiCache">The cache in which to store wiki data.</param>
/// <param name="modCache">The cache in which to store mod metadata.</param>
/// <param name="config">The config settings for mod update checks.</param>
/// <param name="chucklefish">The Chucklefish API client.</param>
/// <param name="curseForge">The CurseForge API client.</param>
/// <param name="github">The GitHub API client.</param>
/// <param name="modDrop">The ModDrop API client.</param>
/// <param name="nexus">The Nexus API client.</param>
public ModsApiController(IWebHostEnvironment environment, IWikiCacheRepository wikiCache, IModCacheRepository modCache, IOptions <ModUpdateCheckConfig> config, IChucklefishClient chucklefish, ICurseForgeClient curseForge, IGitHubClient github, IModDropClient modDrop, INexusClient nexus)
{
this.ModDatabase = new ModToolkit().GetModDatabase(Path.Combine(environment.WebRootPath, "SMAPI.metadata.json"));
this.WikiCache = wikiCache;
this.ModCache = modCache;
this.Config = config;
this.ModSites = new ModSiteManager(new IModSiteClient[] { chucklefish, curseForge, github, modDrop, nexus });
}
private void RefreshMods()
{
Mods = ModDatabase.Get(SelectedGame)
.OrderBy(x => GameConfig.GetModPriority(x.Id))
.Select(x => new ModViewModel(x, SelectedGame))
.ToList();
ModGrid.ItemsSource = Mods;
}
private async Task InitializeAsync()
{
_mods = await RePoEUtils.LoadAsync <Dictionary <string, JsonMod> >("mods");
_benchOptions = await RePoEUtils.LoadAsync <JsonCraftingBenchOption[]>("crafting_bench_options");
_npcMasters = await RePoEUtils.LoadAsync <Dictionary <string, JsonNpcMaster> >("npc_master");
_modDatabase = new ModDatabase(_mods, _benchOptions, _npcMasters);
}
public CommandHandler(DiscordSocketClient client)
{
this.client = client;
_service = new CommandService();
_service.AddModulesAsync(Assembly.GetEntryAssembly(), null);
client.MessageReceived += HandleCommand;
ModDatabase.Start(client.GetGuild(Global.GuildID), client).GetAwaiter().GetResult();
}
private void Icepick_Drop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string file in files)
{
AddEvent($"Attempting to import potential mod: {file}");
ModDatabase.AttemptImportMod(file);
}
}
}
private void DeserializeEnabledModsLegacy(XElement element)
{
foreach (var xModId in element.Elements())
{
if (Guid.TryParse(xModId.Value, out var modId) &&
modId != Guid.Empty &&
ModDatabase.Exists(modId))
{
mModConfigs[modId] = new ModConfig(modId, GetNextAvailableModPriority(), true);
}
}
}
public BrowseTabViewModel()
{
Mods = new ObservableCollection <ModDatabaseModViewModel>();
modDatabase = new ModDatabase();
PropertyChanged += (o, e) =>
{
if (e.PropertyName == "BrowseModsIsSelected" && BrowseModsIsSelected)
{
LazyLoadMods();
}
};
}
private void DeserializeEnabledMods(XElement element)
{
foreach (var xModConfig in element.Elements())
{
var modConfig = ModConfig.Deserialize(xModConfig);
if (modConfig.ModId != Guid.Empty &&
ModDatabase.Exists(modConfig.ModId))
{
mModConfigs[modConfig.ModId] = modConfig;
}
}
}
protected GameConfig()
{
OutputDirectoryPath = Path.Combine("Output", $"{Game}");
mModConfigs = new Dictionary <Guid, ModConfig>();
// Initialize default mod configs for game mods in the database
int priority = 0;
foreach (var mod in ModDatabase.Get(Game))
{
AddModConfig(mod.Id, priority++, false);
}
}
public void ReadState()
{
var src = new InstalledMods(new MockFileSystem())
{
Mods =
{
["QoL"] = new InstalledState(true, new Version(1, 0), false)
}
};
IModDatabase db = new ModDatabase(src, modlinks_xml, api_xml);
Assert.True(db.Items.First(x => x.Name == "QoL").State is InstalledState {
Updated: false, Enabled: true
});
/// <summary>
/// Resolves a dependency and returns all DLL files that the dependency uses
/// </summary>
/// <param name="name"></param>
/// <param name="verMajor"></param>
/// <param name="verMinor"></param>
/// <param name="canBeNewer"></param>
/// <param name="searchDirs"></param>
/// <param name="dllDir"></param>
/// <param name="imageDir"></param>
/// <param name="soundDir"></param>
/// <param name="caller"></param>
/// <returns></returns>
public static IEnumerable <string> LoadDependency(string name, int verMajor, int verMinor,
string dllDir, string mapDir, string assetDir, string caller, bool overwriteExisting)
{
List <string> _dependencyDlls = new List <string>();
if (!ModDatabase.Contains(name, verMajor))
{
return(Enumerable.Empty <string>());
}
var dbItem = ModDatabase.Get(name, verMajor);
bool versionOk = true;
if (verMajor > dbItem.Major)
{
versionOk = false;
}
else if (verMajor == dbItem.Major && verMinor < dbItem.Minor)
{
versionOk = false;
}
if (!versionOk)
{
throw new Exception("Could not resolve to an appropriate version of a dependency. All versions are too old.");
}
if (IsCircular(dbItem.File, caller))
{
throw new Exception($"{name} and {caller} reference each other circularly. Cannot load either.");
}
//Resolve and load the dependency
string errors;
var module = ModLoader.LoadCompressedModFile(dbItem.File, dllDir, mapDir, assetDir, out errors,
dbItem.UsesWhitelist, overwriteExisting);
if (errors != null)
{
throw new Exception(errors);
}
//And then add all the dependencies
_dependencyDlls.AddRange(module.Assemblies.Select(a => a.Location));
_dependencyDlls.AddRange(module.Dependencies.Select(a => a.Location));
return(_dependencyDlls.Distinct());
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="environment">The web hosting environment.</param>
/// <param name="wikiCache">The cache in which to store wiki data.</param>
/// <param name="modCache">The cache in which to store mod metadata.</param>
/// <param name="config">The config settings for mod update checks.</param>
/// <param name="chucklefish">The Chucklefish API client.</param>
/// <param name="curseForge">The CurseForge API client.</param>
/// <param name="github">The GitHub API client.</param>
/// <param name="modDrop">The ModDrop API client.</param>
/// <param name="nexus">The Nexus API client.</param>
public ModsApiController(IWebHostEnvironment environment, IWikiCacheRepository wikiCache, IModCacheRepository modCache, IOptions <ModUpdateCheckConfig> config, IChucklefishClient chucklefish, ICurseForgeClient curseForge, IGitHubClient github, IModDropClient modDrop, INexusClient nexus)
{
this.ModDatabase = new ModToolkit().GetModDatabase(Path.Combine(environment.WebRootPath, "SMAPI.metadata.json"));
this.WikiCache = wikiCache;
this.ModCache = modCache;
this.Config = config;
this.Repositories =
new IModRepository[]
{
new ChucklefishRepository(chucklefish),
new CurseForgeRepository(curseForge),
new GitHubRepository(github),
new ModDropRepository(modDrop),
new NexusRepository(nexus)
}
.ToDictionary(p => p.VendorKey);
}
private async Task InitializeAsync()
{
var modsTask = DataUtils.LoadRePoEAsync <Dictionary <string, JsonMod> >("mods");
var benchOptionsTask = DataUtils.LoadRePoEAsync <JsonCraftingBenchOption[]>("crafting_bench_options");
var npcMastersTask = DataUtils.LoadRePoEAsync <Dictionary <string, JsonNpcMaster> >("npc_master");
var statTranslationsTask = DataUtils.LoadRePoEAsync <List <JsonStatTranslation> >("stat_translations");
ModDatabase = new ModDatabase(await modsTask, await benchOptionsTask, await npcMastersTask);
StatTranslator = new StatTranslator(await statTranslationsTask);
ItemBases = (await LoadBases()).ToList();
UniqueBases = (await LoadUniques()).ToList();
ItemBaseDictionary = ItemBases.DistinctBy(b => b.Name).ToDictionary(b => b.Name);
UniqueBaseDictionary = UniqueBases.DistinctBy(b => b.UniqueName).ToDictionary(b => b.UniqueName);
_root = new WordSetTreeNode(ItemBases.Select(m => m.Name));
}
public ModDatabaseModViewModel(ModDatabaseMod mod, ModDatabase database)
{
this.mod = mod;
this.timer = new Timer();
this.database = database;
this.saver = new DownloadedModSaver();
this.extractor = new ModExtracter();
DownloadModCommand = new Command(DownloadMod, x => !IsDownloading);
timer.AutoReset = false;
timer.Elapsed += (o, e) =>
{
ModHasBeenDownloaded = false;
timer.Stop();
};
timer.Interval = TimeSpan.FromSeconds(5).TotalMilliseconds;
}
private async Task InitializeAsync()
{
var modsTask = DataUtils.LoadRePoEAsync <Dictionary <string, JsonMod> >("mods", true);
var benchOptionsTask = DataUtils.LoadRePoEAsync <JsonCraftingBenchOption[]>("crafting_bench_options", true);
var statTranslatorTask = StatTranslators.CreateFromMainFileAsync(true);
ModDatabase = new ModDatabase(await modsTask, await benchOptionsTask);
ItemBases = await LoadBases();
UniqueBases = await LoadUniques();
StatTranslator = await statTranslatorTask;
ItemBaseDictionary = ItemBases.DistinctBy(b => b.Name).ToDictionary(b => b.Name);
UniqueBaseDictionary = UniqueBases.DistinctBy(b => b.UniqueName).ToDictionary(b => b.UniqueName);
_root = new WordSetTreeNode(ItemBases.Select(m => m.Name));
}
public ItemParser()
{
var modDefinitionsFile = File.ReadAllText(Path.Combine(Environment.CurrentDirectory, @"Data\ModDefinitions.json"));
var modDefinitions = JsonConvert.DeserializeObject<IEnumerable<ModDefinition>>(modDefinitionsFile);
var modDatabase = new ModDatabase(modDefinitions);
parsers = new IParser<PoeItem>[]
{
new PhysicalDamagaParser(),
new ElementalDamageParser(),
new AttackSpeedParser(),
new ItemLevelParser(),
//new IncreasedDamageModParser(modDatabase),
new IncreasedDamageWithWeaponsModParser(modDatabase),
new IncreasedPropertyModParser(modDatabase),
new IncreasedPercentagePropertyModParser(modDatabase),
new AddedPropertyModParser(modDatabase),
};
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="environment">The web hosting environment.</param>
/// <param name="cache">The cache in which to store mod metadata.</param>
/// <param name="configProvider">The config settings for mod update checks.</param>
/// <param name="chucklefish">The Chucklefish API client.</param>
/// <param name="github">The GitHub API client.</param>
/// <param name="nexus">The Nexus API client.</param>
public ModsApiController(IHostingEnvironment environment, IMemoryCache cache, IOptions <ModUpdateCheckConfig> configProvider, IChucklefishClient chucklefish, IGitHubClient github, INexusClient nexus)
{
this.ModDatabase = new ModToolkit().GetModDatabase(Path.Combine(environment.WebRootPath, "StardewModdingAPI.metadata.json"));
ModUpdateCheckConfig config = configProvider.Value;
this.WikiCompatibilityPageUrl = config.WikiCompatibilityPageUrl;
this.Cache = cache;
this.SuccessCacheMinutes = config.SuccessCacheMinutes;
this.ErrorCacheMinutes = config.ErrorCacheMinutes;
this.VersionRegex = config.SemanticVersionRegex;
this.Repositories =
new IModRepository[]
{
new ChucklefishRepository(config.ChucklefishKey, chucklefish),
new GitHubRepository(config.GitHubKey, github),
new NexusRepository(config.NexusKey, nexus)
}
.ToDictionary(p => p.VendorKey, StringComparer.CurrentCultureIgnoreCase);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="environment">The web hosting environment.</param>
/// <param name="wikiCache">The cache in which to store wiki data.</param>
/// <param name="modCache">The cache in which to store mod metadata.</param>
/// <param name="configProvider">The config settings for mod update checks.</param>
/// <param name="chucklefish">The Chucklefish API client.</param>
/// <param name="github">The GitHub API client.</param>
/// <param name="modDrop">The ModDrop API client.</param>
/// <param name="nexus">The Nexus API client.</param>
public ModsApiController(IHostingEnvironment environment, IWikiCacheRepository wikiCache, IModCacheRepository modCache, IOptions <ModUpdateCheckConfig> configProvider, IChucklefishClient chucklefish, IGitHubClient github, IModDropClient modDrop, INexusClient nexus)
{
this.ModDatabase = new ModToolkit().GetModDatabase(Path.Combine(environment.WebRootPath, "SMAPI.metadata.json"));
ModUpdateCheckConfig config = configProvider.Value;
this.CompatibilityPageUrl = config.CompatibilityPageUrl;
this.WikiCache = wikiCache;
this.ModCache = modCache;
this.SuccessCacheMinutes = config.SuccessCacheMinutes;
this.ErrorCacheMinutes = config.ErrorCacheMinutes;
this.Repositories =
new IModRepository[]
{
new ChucklefishRepository(chucklefish),
new GitHubRepository(github),
new ModDropRepository(modDrop),
new NexusRepository(nexus)
}
.ToDictionary(p => p.VendorKey);
}
public static async Task WhyReadThisLol(HttpListenerContext c)
{
var r = await QuinsCryptoLol.IsValidRequest(c);
if (!r.result)
{
c.Response.StatusCode = 401;
c.Response.Close();
return;
}
string cont = r.payload;
ModlogBody body;
try
{
body = JsonConvert.DeserializeObject <ModlogBody>(cont);
}
catch
{
c.Response.StatusCode = 400;
c.Response.Close();
return;
}
try
{
await ModDatabase.AddModlogs(body.userId, body.type, body.moderatorId, body.reason, body.username);
c.Response.StatusCode = 200;
c.Response.Close();
}
catch (Exception x)
{
Global.ConsoleLog(x.ToString());
c.Response.StatusCode = 500;
c.Response.Close();
}
}
public ItemBase(ItemImageService itemImageService, ModDatabase modDatabase, ItemBaseDto xmlBase)
{
Level = xmlBase.Level;
RequiredStrength = xmlBase.Strength;
RequiredDexterity = xmlBase.Dexterity;
RequiredIntelligence = xmlBase.Intelligence;
DropDisabled = xmlBase.DropDisabled;
InventoryHeight = xmlBase.InventoryHeight;
InventoryWidth = xmlBase.InventoryWidth;
Name = xmlBase.Name;
ItemClass = xmlBase.ItemClass;
Tags = xmlBase.Tags;
MetadataId = xmlBase.MetadataId;
ImplicitMods = xmlBase.Implicit.Select(id => modDatabase.Mods[id]).ToList();
_properties = xmlBase.Properties;
CanHaveQuality = Tags.HasFlag(Tags.Weapon) || Tags.HasFlag(Tags.Armour);
Image = new ItemImage(itemImageService, Name, ItemClass);
MaximumNumberOfSockets = GetMaximumNumberOfSockets();
}
public UniqueBase(ItemImageService itemImageService, ModDatabase modDatabase, ItemBase itemBase,
XmlUnique xmlUnique)
{
UniqueName = xmlUnique.Name;
Level = xmlUnique.Level;
DropDisabled = xmlUnique.DropDisabled;
_base = itemBase;
_properties = xmlUnique.Properties;
var explicits = new List <IMod>();
foreach (var id in xmlUnique.Explicit)
{
if (!modDatabase.Mods.TryGetValue(id, out var mod))
{
Log.Error($"Unknown mod id {id} on unique {UniqueName}");
continue;
}
explicits.Add(mod);
}
ExplicitMods = explicits;
Image = itemBase.Image.AsDefaultForUniqueImage(itemImageService, UniqueName);
}
private void BuildButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(GameConfig.OutputDirectoryPath))
{
MessageBox.Show(this, "Please specify an output directory in the settings.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (Mods.Count == 0)
{
MessageBox.Show(this, "No mods are available.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (!UpdateGameConfigEnabledMods())
{
MessageBox.Show(this, "No mods are enabled.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var task = Task.Factory.StartNew(() =>
{
gEnabledMods = GameConfig.ModConfigs.Where(x => x.Enabled)
.OrderBy(x => x.Priority)
.Select(x => x.ModId)
.Select(x => ModDatabase.Get(x))
.ToList();
Log.General.Info("Building mods:");
foreach (var enabledMod in gEnabledMods)
{
Log.General.Info($"\t{enabledMod.Title}");
}
// Run prebuild scripts
RunModScripts(gEnabledMods, "prebuild.bat");
var merger = new TopToBottomModMerger();
var merged = merger.Merge(gEnabledMods);
// Todo
var builder = ModBuilderManager.GetCompatibleModBuilders(SelectedGame).First().Create();
if (UltraISOUtility.Available)
{
if (SelectedGame == Game.Persona3)
{
builder = new Persona3IsoModBuilder();
}
else if (SelectedGame == Game.Persona4)
{
builder = new Persona4IsoModBuilder();
}
}
Log.General.Info($"Output path: {GameConfig.OutputDirectoryPath}");
#if !DEBUG
try
#endif
{
builder.Build(merged, gEnabledMods, GameConfig.OutputDirectoryPath);
}
#if !DEBUG
catch (InvalidConfigException exception)
{
InvokeOnUIThread(
() => MessageBox.Show(this, $"SelectedGame configuration is invalid.\n{exception.Message}", "Error",
MessageBoxButton.OK, MessageBoxImage.Error));
return(false);
}
catch (MissingFileException exception)
{
InvokeOnUIThread(
() => MessageBox.Show(this, $"A file is missing:\n{exception.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error));
return(false);
}
catch (Exception exception)
{
InvokeOnUIThread(
() =>
MessageBox.Show(
this, $"Unhandled exception occured while building:\n{exception.Message}\n{exception.StackTrace}", "Error",
MessageBoxButton.OK, MessageBoxImage.Error));
#if DEBUG
throw;
#endif
#pragma warning disable 162
return(false);
#pragma warning restore 162
}
#endif
return(true);
}, TaskCreationOptions.AttachedToParent);
task.ContinueWith((t) =>
{
InvokeOnUIThread(() =>
{
if (t.Result)
{
MessageBox.Show(this, "Done building!", "Done", MessageBoxButton.OK, MessageBoxImage.None);
RunModScripts(gEnabledMods, "postbuild.bat");
}
});
});
}
private void RefreshModDatabase()
{
ModDatabase.Initialize();
RefreshMods();
}
