internal static void LoadRecipes() { try { XmlDocument document = new XmlDocument(); document.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "HunterPie.Resources/Data/CraftingData.xml")); XmlNodeList items = document.SelectNodes("//Crafting/Item"); IEnumerable <Recipe> recipes = items.Cast <XmlNode>() .Select(node => XmlNodeToRecipe(node)); foreach (Recipe recipe in recipes) { AddNewRecipe(recipe.OutputId, recipe); } Debugger.Warn($"Loaded {recipes.Count()} different item crafting recipes!"); document = null; } catch (Exception err) { Debugger.Error($"Failed to load crafting data.\n{err}"); } }
public void LoadPlugins() { Stopwatch benchmark = Stopwatch.StartNew(); if (packages.Count > 0) { // Quick load foreach (PluginPackage package in packages) { if (!package.settings.IsEnabled) { continue; } try { package.plugin.Initialize(ctx); } catch (Exception err) { Debugger.Error(err); } } } benchmark.Stop(); Debugger.Module($"Loaded {packages.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); }
public static async Task <bool> DownloadFileAsync(string URL, string output, string relFilepath) { try { using (HttpClient client = new HttpClient()) { byte[] data = await client.GetByteArrayAsync(new Uri(URL)); if (Path.GetDirectoryName(relFilepath).Length > 0) { string dirs = Path.GetDirectoryName(output); if (!Directory.Exists(dirs)) { Directory.CreateDirectory(dirs); } } File.WriteAllBytes(output, data); return(true); } } catch (Exception err) { Debugger.Error(err); return(false); } }
public void createConfig(string uniqueID, string uri = Constants.FALLBACK_URI, string retry = Constants.FALLBACK_HOTKEY) { Debugger.Error("Config.json for DiscordHelper not found!"); Debugger.Module("Creating Config.json.", Name); File.WriteAllText( configPath, "{\n\t\"uri\": \"" + uri + "\",\n\t\"id\": \"" + uniqueID + "\",\n\t\"retry\": \"" + retry + "\"\n}"); }
public void PreloadPlugins() { Stopwatch benchmark = Stopwatch.StartNew(); Debugger.Module("Pre loading modules"); string[] modules = Directory.GetDirectories(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules")); foreach (string module in modules) { // Skip modules without Module.json if (!File.Exists(Path.Combine(module, "module.json"))) { continue; } try { string serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); PluginInformation modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); PluginSettings modSettings = GetPluginSettings(module); if (File.Exists(Path.Combine(module, modInformation.EntryPoint))) { Debugger.Module($"Compiling plugin: {modInformation.Name}"); if (CompilePlugin(module, modInformation)) { Debugger.Module($"{modInformation.Name} compiled successfully."); } else { continue; } } Stopwatch s = Stopwatch.StartNew(); foreach (string required in modInformation.Dependencies) { AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, required))); } Assembly plugin = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, $"{modInformation.Name}.dll"))); IEnumerable <Type> entries = plugin.ExportedTypes.Where(exp => exp.GetMethod("Initialize") != null); if (entries.Count() > 0) { dynamic mod = plugin.CreateInstance(entries.First().ToString()); packages.Add(new PluginPackage { plugin = mod, information = modInformation, settings = modSettings, path = module }); } } catch (Exception err) { Debugger.Error(err); continue; } } IsReady = true; benchmark.Stop(); Debugger.Module($"Pre loaded {packages.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); if (QueueLoad) { LoadPlugins(); } }
/// <summary> /// Loads a specific plugin /// </summary> /// <param name="plugin">Plugin to be loaded</param> /// <returns>True if it was loaded successfully, false if not</returns> public static bool LoadPlugin(IPlugin plugin) { if (ctx == null) { return(false); } var name = packages.FirstOrDefault(p => p.plugin == plugin).information?.Name; try { plugin.Initialize(ctx); if (!string.IsNullOrEmpty(name)) { failedPlugins.Remove(name); } } catch (Exception ex) { Debugger.Error($"Error on initializing plugin {plugin.Name}: {ex}"); if (!string.IsNullOrEmpty(name)) { failedPlugins.Add(name); } return(false); } return(true); }
public bool CompilePlugin(string pluginPath, PluginInformation information) { var compiler = CSharpCompilation.Create($"{nameof(HunterPie)}{information.Name}", options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithOptimizationLevel(OptimizationLevel.Release)); var types = new[] { typeof(Hunterpie), // HunterPie typeof(JObject), // Newtonsoft.Json.dll typeof(Object), // mscorlib.dll typeof(UIElement), // PresentationCore.dll typeof(Window), // PresentationFramework.dll typeof(Uri), // System.dll typeof(Enumerable), // System.Core.dll typeof(DataSet), // System.Data.dll typeof(DataTableExtensions), // System.Data.DataSetExtensions.dll typeof(Bitmap), // System.Drawing.dll typeof(HttpClient), // System.Net.Http.dll typeof(BigInteger), // System.Numerics.dll typeof(Form), // System.Windows.Forms.dll typeof(XamlType), // System.Xaml.dll typeof(XmlNode), // System.Xml.dll typeof(XNode), // System.Xml.Linq.dll typeof(Rect), // WindowsBase.dll }; // Load all basic dependencies List <MetadataReference> references = types.Select(type => MetadataReference.CreateFromFile(type.Assembly.Location)).ToList <MetadataReference>(); if (information.Dependencies != null) { foreach (string extDependency in information.Dependencies) { references.Add(MetadataReference.CreateFromFile(Path.Combine(pluginPath, extDependency))); } } compiler = compiler.AddReferences(references); var code = File.ReadAllText(Path.Combine(pluginPath, information.EntryPoint)); var options = CSharpParseOptions.Default.WithLanguageVersion( LanguageVersion.CSharp7_3); var syntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From(code, Encoding.UTF8), options, Path.Combine(pluginPath, information.EntryPoint)); compiler = compiler.AddSyntaxTrees(syntaxTree); var result = compiler.Emit(Path.Combine(pluginPath, information.Name) + ".dll"); if (result.Success) { return(true); } else { Debugger.Error($"Failed to compile plugin: {information.Name}"); foreach (var exception in result.Diagnostics) { Debugger.Error(exception); } return(false); } }
public void LoadPlugins(Game ctx) { Stopwatch benchmark = Stopwatch.StartNew(); if (plugins.Count > 0) { // Quick load foreach (IPlugin plugin in plugins) { plugin.Initialize(ctx); } } else { string[] modules = Directory.GetDirectories(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules")); foreach (string module in modules) { try { string serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); PluginInformation modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); if (File.Exists(Path.Combine(module, modInformation.EntryPoint))) { Debugger.Module($"Compiling plugin: {modInformation.Name}"); if (CompilePlugin(module, modInformation)) { Debugger.Module($"{modInformation.Name} compiled successfully."); } else { continue; } } foreach (string required in modInformation.Dependencies) { AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, required))); } var plugin = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, $"{modInformation.Name}.dll"))); IEnumerable <Type> entries = plugin.ExportedTypes.Where(exp => exp.GetMethod("Initialize") != null); if (entries.Count() > 0) { dynamic mod = plugin.CreateInstance(entries.First().ToString()); mod.Initialize(ctx); plugins.Add(mod); } } catch (Exception err) { Debugger.Error(err); continue; } } } benchmark.Stop(); Debugger.Module($"Loaded {plugins.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); }
/// <summary> /// Unloads a specific plugin /// </summary> /// <param name="plugin">The plugin to be unloaded</param> /// <returns>True if the plugin was unloaded successfully, false otherwise</returns> public static bool UnloadPlugin(IPlugin plugin) { if (ctx == null) { return(true); } try { plugin.Unload(); return(true); } catch (Exception err) { Debugger.Error(err); return(false); } }
static string BuildCustomPartsStructure(int WeaponType, GameStructs.CustomAugment[] CustomAugments, bool ShowError) { StringBuilder[] Structure = new StringBuilder[5]; for (int cAugmentIndex = 0; cAugmentIndex < CustomAugments.Length; cAugmentIndex++) { GameStructs.CustomAugment cAugment = CustomAugments[cAugmentIndex]; // Skip empty slots if (cAugment.ID == byte.MaxValue) { continue; } string AugmentType = HoneyGearData.SelectSingleNode($"//Honey/Weapons/Custom").ChildNodes[WeaponType].SelectSingleNode($"Part[@Level='{cAugment.Level + 1}' and @ID='{cAugment.ID}']/@Type")?.Value; // If we dont find the augment id, then we try the wildcard ones, since there are some // missing IDs if (AugmentType == null) { AugmentType = HoneyGearData.SelectSingleNode($"//Honey/Weapons/Custom").ChildNodes[WeaponType].SelectSingleNode($"Part[@Level='{cAugment.Level + 1}' and @ID='?']/@Type")?.Value; } // If the augment is still null, then it isn't supported yet. In this case we display an error // with the augment ID, so it's easier to map it. if (AugmentType == null && ShowError) { Debugger.Error($"Unsupported custom augment (ID = {cAugment.ID}, Level = {cAugment.Level})"); continue; } // Initializes StringBuilder if it isn't initialized yet int.TryParse(AugmentType, out int parsed); if (Structure[parsed] == null) { Structure[parsed] = new StringBuilder(); } Structure[parsed].Append((cAugment.Level + 1).ToString()); } StringBuilder JoinedResult = new StringBuilder(); foreach (StringBuilder SubBuilder in Structure) { JoinedResult.Append(SubBuilder?.ToString() + ";"); } JoinedResult.Remove(JoinedResult.Length - 1, 1); return(JoinedResult.ToString()); }
static string GetWeaponHoneyID(int WeaponType, int WeaponID) { XmlNodeList nl = HoneyGearData.SelectSingleNode($"//Honey/Weapons").ChildNodes; if (WeaponType > nl.Count) { return("0"); } XmlNode WeaponNode = nl[WeaponType]; string wID = WeaponNode.SelectSingleNode($"Weapon[@ID='{WeaponID}']/@HoneyID")?.Value ?? "0"; if (wID == "0") { Debugger.Error($"Unsupported weapon ID: {WeaponID}"); } return(wID); }
internal static void LoadRecipes() { try { XmlDocument document = new XmlDocument(); document.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "HunterPie.Resources/Data/CraftingData.xml")); XmlNodeList items = document.SelectNodes("//Crafting/Item"); list = items.Cast <XmlNode>() .Select(node => XmlNodeToRecipe(node)) .ToDictionary(m => m.OutputId); Debugger.Warn("Loaded crafting data!"); document = null; } catch (Exception err) { Debugger.Error($"Failed to load crafting data.\n{err}"); } }
internal static async Task <string> ReadOnlineModuleJson(string URL) { string url = URL; if (!URL.EndsWith("module.json")) { url = $"{URL}/module.json"; } try { using (HttpClient client = new HttpClient()) { return(await client.GetStringAsync(new Uri(url))); } } catch (Exception err) { Debugger.Error(err); return(null); } }
/// <summary> /// Unloads a specific plugin /// </summary> /// <param name="plugin">The plugin to be unloaded</param> /// <returns>True if the plugin was unloaded successfully, false otherwise</returns> public static bool UnloadPlugin(IPlugin plugin) { if (ctx == null) { return(true); } try { // This means this plugin is not loaded, so we skip it if (plugin.Context == null) { return(true); } plugin.Unload(); return(true); } catch (Exception err) { Debugger.Error(err); return(false); } }
public async Task <bool> PreloadPlugins() { Stopwatch benchmark = Stopwatch.StartNew(); Debugger.Module("Pre loading modules"); foreach (string module in IterateModules()) { try { string serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); PluginInformation modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); try { await PreloadPlugin(module, modInformation); failedPlugins.Remove(modInformation.Name); } catch { failedPlugins.Add(modInformation.Name); throw; } } catch (Exception err) { Debugger.Error(err); } } benchmark.Stop(); Debugger.Module($"Pre loaded {packages.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); if (!tsc.Task.IsCompleted) { tsc.SetResult(null); } return(true); }
public async Task LoadPlugins() { await PreloadTask; Stopwatch benchmark = Stopwatch.StartNew(); if (packages.Count > 0) { // Quick load foreach (PluginPackage package in packages.Where(p => p.settings.IsEnabled)) { try { package.plugin.Initialize(ctx); } catch (Exception err) { Debugger.Error(err); } } } benchmark.Stop(); Debugger.Module($"Loaded {packages.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); }
public async Task <bool> PreloadPlugins() { Stopwatch benchmark = Stopwatch.StartNew(); Debugger.Module("Pre loading modules"); string[] modules = Directory.GetDirectories(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules")); foreach (string module in modules) { // Skip modules without Module.json if (!File.Exists(Path.Combine(module, "module.json"))) { continue; } try { string serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); PluginInformation modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); if (modInformation.Update.MinimumVersion is null) { Debugger.Error($"{modInformation.Name.ToUpper()} MIGHT BE OUTDATED! CONSIDER UPDATING IT."); } if (PluginUpdate.PluginSupportsUpdate(modInformation)) { switch (await PluginUpdate.UpdateAllFiles(modInformation, module)) { case UpdateResult.Updated: serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); Debugger.Module($"Updated plugin: {modInformation.Name} (ver {modInformation.Version})"); break; case UpdateResult.Skipped: break; case UpdateResult.Failed: Debugger.Error($"Failed to update plugin: {modInformation.Name}"); continue; case UpdateResult.UpToDate: Debugger.Module($"Plugin {modInformation.Name} is up-to-date (ver {modInformation.Version})"); break; } } PluginSettings modSettings = GetPluginSettings(module); if (!string.IsNullOrEmpty(modInformation.EntryPoint) && File.Exists(Path.Combine(module, modInformation.EntryPoint))) { Debugger.Module($"Compiling plugin: {modInformation.Name}"); if (CompilePlugin(module, modInformation)) { Debugger.Module($"{modInformation.Name} compiled successfully."); } else { continue; } } Stopwatch s = Stopwatch.StartNew(); foreach (string required in modInformation.Dependencies) { AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, required))); } Assembly plugin = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, $"{modInformation.Name}.dll"))); IEnumerable <Type> entries = plugin.ExportedTypes.Where(exp => exp.GetMethod("Initialize") != null); if (entries.Count() > 0) { dynamic mod = plugin.CreateInstance(entries.First().ToString()); packages.Add(new PluginPackage { plugin = mod, information = modInformation, settings = modSettings, path = module }); } } catch (Exception err) { Debugger.Error(err); continue; } } IsReady = true; benchmark.Stop(); Debugger.Module($"Pre loaded {packages.Count} module(s) in {benchmark.ElapsedMilliseconds}ms"); if (QueueLoad) { LoadPlugins(); } return(true); }
private async Task PreloadPlugin(string module, PluginInformation modInformation) { if (File.Exists(Path.Combine(module, ".remove"))) { Directory.Delete(module, true); Debugger.Module($"Plugin {modInformation.Name} removed."); return; } if (modInformation.Update.MinimumVersion is null) { Debugger.Error($"{modInformation.Name.ToUpper()} MIGHT BE OUTDATED! CONSIDER UPDATING IT."); } if (PluginUpdate.PluginSupportsUpdate(modInformation)) { switch (await PluginUpdate.UpdateAllFiles(modInformation, module)) { case UpdateResult.Updated: var serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); Debugger.Module($"Updated plugin: {modInformation.Name} (ver {modInformation.Version})"); break; case UpdateResult.Skipped: break; case UpdateResult.Failed: Debugger.Error($"Failed to update plugin: {modInformation.Name}"); break; case UpdateResult.UpToDate: Debugger.Module($"Plugin {modInformation.Name} is up-to-date (ver {modInformation.Version})"); break; } } PluginSettings modSettings = GetPluginSettings(module); if (!string.IsNullOrEmpty(modInformation.EntryPoint) && File.Exists(Path.Combine(module, modInformation.EntryPoint))) { Debugger.Module($"Compiling plugin: {modInformation.Name}"); if (CompilePlugin(module, modInformation)) { Debugger.Module($"{modInformation.Name} compiled successfully."); } else { return; } } foreach (string required in modInformation.Dependencies) { AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, required))); } Assembly plugin = AppDomain.CurrentDomain.Load( AssemblyName.GetAssemblyName(Path.Combine(module, $"{modInformation.Name}.dll"))); IEnumerable <Type> entries = plugin.ExportedTypes.Where(exp => exp.GetMethod("Initialize") != null); if (entries.Any()) { dynamic mod = plugin.CreateInstance(entries.First().ToString()); packages.Add(new PluginPackage { plugin = mod, information = modInformation, settings = modSettings, path = module }); } }
private async Task PreloadPlugin(string module, PluginInformation modInformation) { if (File.Exists(Path.Combine(module, ".remove"))) { Directory.Delete(module, true); Debugger.Module($"Plugin {modInformation.Name} removed."); return; } if (modInformation.Update.MinimumVersion is null) { Debugger.Error($"{modInformation.Name.ToUpper()} MIGHT BE OUTDATED! CONSIDER UPDATING IT."); } if (PluginUpdate.PluginSupportsUpdate(modInformation)) { switch (await PluginUpdate.UpdateAllFiles(modInformation, module)) { case UpdateResult.Updated: var serializedModule = File.ReadAllText(Path.Combine(module, "module.json")); modInformation = JsonConvert.DeserializeObject <PluginInformation>(serializedModule); Debugger.Module($"Updated plugin: {modInformation.Name} (ver {modInformation.Version})"); break; case UpdateResult.Skipped: break; case UpdateResult.Failed: Debugger.Error($"Failed to update plugin: {modInformation.Name}"); break; case UpdateResult.UpToDate: Debugger.Module($"Plugin {modInformation.Name} is up-to-date (ver {modInformation.Version})"); break; } } PluginSettings modSettings = GetPluginSettings(module); if (!string.IsNullOrEmpty(modInformation.EntryPoint) && File.Exists(Path.Combine(module, modInformation.EntryPoint))) { Debugger.Module($"Compiling plugin: {modInformation.Name}"); if (CompilePlugin(module, modInformation)) { Debugger.Module($"{modInformation.Name} compiled successfully."); } else { return; } } foreach (string required in modInformation.Dependencies) { AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(Path.Combine(module, required))); } var moduleAssembly = AppDomain.CurrentDomain.Load( AssemblyName.GetAssemblyName(Path.Combine(module, $"{modInformation.Name}.dll")) ); var pluginType = moduleAssembly.ExportedTypes.FirstOrDefault(exp => exp.GetMethod("Initialize") != null); if (pluginType != null) { var plugin = (IPlugin)moduleAssembly.CreateInstance(pluginType.FullName); // making sure that name is matching modInformation, e.g. if plugin dev forgot to populate this value plugin.Name = modInformation.Name; var package = new PluginPackage { plugin = plugin, information = modInformation, settings = modSettings, path = module }; packages.Add(package); // if plugin is enabled, adding it's settings if (modSettings.IsEnabled) { AddPackageSettings(package); } } }