diff --git a/README.md b/README.md
index ac40813..2f08e97 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ It makes use of Assembly Load Contexts to ensure mod dependencies are managed se
## Mod location
-Mods should be installed in the mods folder in the KSA installation, any KSA mod that has a dll with the same name as the mod that impelements the IStarMapMod interface will be loaded.
+Mods should be installed in the contents folder in the KSA installation, StarMap makes use of the
## Mod creation
diff --git a/StarMap.API/BaseAttributes.cs b/StarMap.API/BaseAttributes.cs
index d5ecb5a..1134976 100644
--- a/StarMap.API/BaseAttributes.cs
+++ b/StarMap.API/BaseAttributes.cs
@@ -81,7 +81,6 @@ public override bool IsValidSignature(MethodInfo method)
///
/// Methods marked with this attribute will be called when all mods are loaded.
- /// This is to be used for when the mod has dependencies on other mods.
///
///
/// Methods using this attribute must follow this signature:
diff --git a/StarMap.API/OnFrameAttributes.cs b/StarMap.API/OnFrameAttributes.cs
new file mode 100644
index 0000000..5844277
--- /dev/null
+++ b/StarMap.API/OnFrameAttributes.cs
@@ -0,0 +1,46 @@
+using System.Reflection;
+
+namespace StarMap.API
+{
+ ///
+ /// Methods marked with this attribute will be called after KSA Program.OnFrame is called.
+ ///
+ ///
+ /// Methods using this attribute must match the following signature:
+ ///
+ ///
+ /// public void MethodName(double currentPlayerTime, double dtPlayer);
+ ///
+ ///
+ /// Parameter requirements:
+ ///
+ /// -
+ ///
+ ///
+ ///
+ ///
+ /// -
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// Requirements:
+ ///
+ /// - Return type must be .
+ /// - Method must be an instance method (non-static).
+ ///
+ ///
+ public sealed class StarMapAfterOnFrameAttribute : StarMapMethodAttribute
+ {
+ public override bool IsValidSignature(MethodInfo method)
+ {
+ return method.ReturnType == typeof(void) &&
+ method.GetParameters().Length == 2 &&
+ method.GetParameters()[0].ParameterType == typeof(double) &&
+ method.GetParameters()[1].ParameterType == typeof(double);
+
+ }
+ }
+}
diff --git a/StarMap.API/README.md b/StarMap.API/README.md
index 0ee0184..0a90ade 100644
--- a/StarMap.API/README.md
+++ b/StarMap.API/README.md
@@ -1,16 +1,222 @@
# StarMap API
This package provides the API for mods to interface with the [StarMap](https://github.com/StarMapLoader/StarMap) modloader.
-The main class of the mod should be marked by the StarMapMod attribute.
-Then methods within this class can be marked with any of the StarMapMethod attributes.
-At the initialization of the mod within KSA, an instance of the StarMapMod is created, only the first class that has this attribute will be considered.
-Any method within this class that has any of the attributes will used, so if two methods use StarMapImmediateLoad, both will be called.
-
-## Attributes
-
-- StarMapMod: Main attribute to mark the mod class.
-- StarMapImmediateLoad: Called immediatly when the mod is loaded in KSA.
-- StarMapAllModsLoaded: Called once all mods are loaded, can be used when this mod has a dependency on another mod.
-- StarMapUnload: Called when KSA is unloaded.
-- StarMapBeforeGui: Called just before KSA starts drawing its Ui.
-- StarMapAfterGui: Called after KSA has drawn its Ui.
+
+## How to create mods
+
+### General architecture
+
+A StarMap mod is in essence an extension of KSA mods.
+Every mod will at minimum contain a mod.toml (which is also the case for KSA mods) as well as an entry assembly.
+
+#### mod.toml
+
+While it is not stricly neccesary, it is advised to add StarMap info to the mod.toml, at its most basic, a mod.toml should like like this:
+
+```toml
+name = "MyAmazingMod"
+
+[StarMap]
+EntryAssembly = "MyAmazingMod"
+```
+
+The name will be the modid of your mod, this should be the same name as the folder in which this lives in the Content folder.
+The "StarMap" section is optional, if it is provided, at mimimum, it should provide the name of the assembly which StarMap will initially load (without the dll extension).
+If it is not provided, StarMap will search for a [modid].dll in the mod folder.
+
+#### Entry assembly
+
+The above mentioned entry assembly will be the first thing that StarMap will load.
+Within this assembly, StarMap will search for a class that has the [StarMapMod](#starmapmod) attribute. It will use the first that it finds.
+This class will be the core part of the mod, any entry from StarMap will be done through this class.
+To add functionality to the mod, methods with attributes can be added, which attributes are available and what their functionality is, can be found in the [Attributes API reference](#attributes).
+These methods will be called as instance methods on the mod class, throughout the runtime of KSA, StarMap will create once instance of this class and reuse it.
+The implemenation should follow the signatures shown in the example code.
+
+### Dependencies
+
+In many cases, mods will have dependencies on other mods, or will want to overwrite functionality of other mods.
+To achieve this, some extra configuration is required, this configuration is confined to the mod.toml within the StarMap section.
+
+#### Exported assemblies
+
+First of all, mods can configure what assemblies should be exposed to other mods, by default all assemblies that are provided with the mod can be accessed from other mods, this can be changed with the ExportedAssemblies.
+In below example, only the StarMap.SimpleMod.Dependency(.dll) assembly will be accessable from other mods (more info in [imported and exported assemblies](#imported-and-exported-assemblies)).
+
+```toml
+name = "MyOtherAmazingMod"
+
+[StarMap]
+EntryAssembly = "MyOtherAmazingMod"
+ExportedAssemblies = [
+ "MyDependency"
+]
+```
+
+#### Mod dependency
+
+Then, mods can define what mods they want to depend on, they can do this by adding a new ModDependencies list entry in the mod.toml
+
+```toml
+name = "MyAmazingMod"
+
+[StarMap]
+EntryAssembly = "MyAmazingMod"
+
+[[StarMap.ModDependencies]]
+ModId = "MyOtherAmazingMod"
+Optional = false
+ImportedAssemblies = [
+ "MyDependency"
+]
+```
+
+In above example, it is provided that StarMap.SimpleMod wants to depend on StarMap.SimpleMod2, this dependency is not optional and the mod wants to access the StarMap.SimpleMod.Dependency assembly.
+Following fields can be used
+
+- The `ModId` should be the same as is provided as the name field in the mod.toml of the dependency mod.
+- The `Optional` field (default false) defines if this dependency is optional, more info in the [loading strategy](#dependency-loading-strategy)
+- The `ImportedAssemblies` field contains a list of assemblies that this mod intends to use from the dependency (more info in [imported and exported assemblies](#imported-and-exported-assemblies)).
+
+#### Imported and exported assemblies
+
+The goal of the imported and exported assembly fields is to compile a list of assemblies that will be provided to a mod from a dependency, below is the behaviour depending on the content of both fields:
+
+- If both fields are not filled in, the list will contain the entry assembly of the dependency.
+- If only 1 of the lists is filled in, it will use this list to provide the assemblies.
+- If both lists are defined, the intersection of the two will be used.
+
+## Mod loading strategy
+
+When StarMap is started, it will start with loading the manifest.toml (in the same way KSA does it, only sooner), it will then start loading mods from top to bottom.
+It will first load the mod.toml, if the file does not exists, mod loading will not work, if there is no StarMap section, it will use a default configuration.
+Using the config, if there are dependencies, it will first check if these dependencies are already loaded. If they are all loaded, mod loading continues,
+otherwise, it stores what dependencies are still needed and continues to the next mod.
+It will then search for the entry assembly, if it does not exists, loading will be stopped, otherwise, it will load the assembly. Then will search for a class with the StarMapMod attribute and create an instance. With the instance, it goes over the known attributes and stores a reference to the methods, allowing for quick quering, it stores the StarMapBeforeMain and StarMapImmediateLoad methods seperatly because they are mod specific.
+Once the mod is fully loaded, it will call the StarMapBeforeMain method, if there is any.
+
+Now that the mod has been loaded, it checks the list of mods that are waiting for dependencies, and if there are any that are waiting for this mod. If so, it removes itself from the waiting dependencies and checks if the mod can now be loaded, if so, the mod is loaded and the StarMapBeforeMain of that mod is called.
+
+It does this for all the mods in the manifest.
+Once it has tried loading all the mods, it gets the mods that are still waiting and checks them again.
+If for a waiting mod, all its dependencies are optional, it will now load this mod. The implementation of the mod should ensure it can handle the optional dependency can be absent.
+It keeps looping over the list of waiting mods until it has gone through the list once without being able to load a new mod, this indicates there are no more mods that can load with the provided mods, and gives up on loading these mods.
+
+Now StarMap will start KSA, which in turn will call StarMapImmediateLoad for each mod, if implemented.
+
+## Examples
+
+Some examples can be found in the [example mods repository](https://github.com/StarMapLoader/StarMap-ExampleMods)
+
+## API reference
+
+### Attributes
+
+#### StarMapMod
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Class
+
+Marks the main class for a StarMap mod.
+Only attributes on methods within classes marked with this attribute will be considered.
+
+```csharp
+[StarMapMod]
+public class ModClass
+```
+
+#### StarMapBeforeMain
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called before KSA is started.
+
+```csharp
+[StarMapBeforeMain]
+public void ModMethod()
+```
+
+#### StarMapImmediateLoad
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called immediately when the mod is loaded by KSA.
+It is called before the `KSA.Mod.PrepareSystems` method for each mod
+
+```csharp
+[StarMapBeforeMain]
+public void ModMethod(KSA.Mod mod)
+```
+
+#### StarMapAllModsLoaded
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called when all mods are loaded.
+It is called after the `KSA.ModLibrary.LoadAll` method.
+
+```csharp
+[StarMapAllModsLoaded]
+public void ModMethod()
+```
+
+#### StarMapUnload
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called when KSA is unloaded
+
+```csharp
+[StarMapUnload]
+public void ModMethod()
+```
+
+#### StarMapBeforeGui
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called before KSA starts creating its ImGui interface.
+It is called just before the `KSA.Program.OnDrawUi` method.
+
+```csharp
+[StarMapBeforeGui]
+public void ModMethod(double dt)
+```
+
+#### StarMapAfterGui
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called when KSA has finished creating its ImGui interface.
+It is called just after the `KSA.Program.OnDrawUi` method.
+
+```csharp
+[StarMapAfterGui]
+public void ModMethod(double dt)
+```
+
+#### StarMapAfterOnFrame
+
+Namespace: `StarMap.API`
+Assembly: `StarMap.API`
+Target: Method
+
+Methods marked with this attribute will be called after `KSA.Program.OnFrame` is called.
+
+```csharp
+[StarMapAfterOnFrame]
+public void ModMethod(double currentPlayerTime, double dtPlayer);
+```
diff --git a/StarMap.API/StarMap.API.csproj b/StarMap.API/StarMap.API.csproj
index 209a1cd..ff44d0d 100644
--- a/StarMap.API/StarMap.API.csproj
+++ b/StarMap.API/StarMap.API.csproj
@@ -1,19 +1,26 @@
-
- net10.0
- enable
- enable
-
+
+ net10.0
+ enable
+ enable
+ true
+ 1591
+ README.md
+
-
-
-
+
+
+
-
-
- compile; build; analyzers
- all
-
-
-
+
+
+
+
+
+
+ compile; build; analyzers
+ all
+
+
+
\ No newline at end of file
diff --git a/StarMap.Core/Config/StarMapConfig.cs b/StarMap.Core/Config/StarMapConfig.cs
new file mode 100644
index 0000000..57efc81
--- /dev/null
+++ b/StarMap.Core/Config/StarMapConfig.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StarMap.Core.Config
+{
+ internal class RootConfig
+ {
+ public required StarMapConfig StarMap { get; set; }
+ }
+
+
+ internal class StarMapConfig
+ {
+ public required string EntryAssembly { get; set; }
+ public List ExportedAssemblies { get; set; } = [];
+ public List ModDependencies { get; set; } = [];
+ }
+
+ internal class StarMapModDependency
+ {
+ public required string ModId { get; set; }
+ public bool Optional { get; set; } = false;
+ public List ImportedAssemblies { get; set; } = [];
+ }
+}
diff --git a/StarMap.Core/ModRepository/LoadedModRepository.cs b/StarMap.Core/ModRepository/LoadedModRepository.cs
deleted file mode 100644
index b1177d1..0000000
--- a/StarMap.Core/ModRepository/LoadedModRepository.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-using KSA;
-using StarMap.API;
-using System.Reflection;
-using System.Runtime.Loader;
-
-namespace StarMap.Core.ModRepository
-{
- internal class LoadedModRepository : IDisposable
- {
- private readonly AssemblyLoadContext _coreAssemblyLoadContext;
-
- private readonly Dictionary _registeredMethodAttributes = [];
- private readonly Dictionary _attemptedMods = [];
- private readonly Dictionary _modLoadContexts = [];
-
- private readonly ModRegistry _mods = new();
- public ModRegistry Mods => _mods;
-
- private (string attributeName, StarMapMethodAttribute attribute)? ConvertAttributeType(Type attrType)
- {
- if ((Activator.CreateInstance(attrType) as StarMapMethodAttribute) is not StarMapMethodAttribute attrObject) return null;
- return (attrType.Name, attrObject);
- }
-
- public LoadedModRepository(AssemblyLoadContext coreAssemblyLoadContext)
- {
- _coreAssemblyLoadContext = coreAssemblyLoadContext;
-
- Assembly coreAssembly = typeof(StarMapModAttribute).Assembly;
-
- _registeredMethodAttributes = coreAssembly
- .GetTypes()
- .Where(t =>
- typeof(StarMapMethodAttribute).IsAssignableFrom(t) &&
- t.IsClass &&
- !t.IsAbstract &&
- t.GetCustomAttribute()?.ValidOn.HasFlag(AttributeTargets.Method) == true
- )
- .Select(ConvertAttributeType)
- .OfType<(string attributeName, StarMapMethodAttribute attribute)>()
- .ToDictionary();
- }
-
- public void Init()
- {
- PrepareMods();
- }
-
- private void PrepareMods()
- {
- var loadedManifest = ModLibrary.PrepareManifest();
-
- if (!loadedManifest) return;
-
- var mods = ModLibrary.Manifest.Mods;
- if (mods is null) return;
-
- string rootPath = "Content";
- string path = Path.Combine(new ReadOnlySpan(in rootPath));
-
- foreach (var mod in mods)
- {
- var modPath = Path.Combine(path, mod.Id);
-
- if (!LoadMod(mod.Id, modPath))
- {
- _attemptedMods[mod.Id] = false;
- continue;
- }
-
- if (_mods.GetBeforeMainAction(mod.Id) is (object @object, MethodInfo method))
- {
- method.Invoke(@object, []);
- }
- _attemptedMods[mod.Id] = true;
- }
- }
-
- public void ModPrepareSystems(Mod mod)
- {
- if (!_attemptedMods.TryGetValue(mod.Id, out var succeeded))
- {
- succeeded = LoadMod(mod.Id, mod.DirectoryPath);
- }
-
- if (!succeeded) return;
-
- if (_mods.GetPrepareSystemsAction(mod.Id) is (object @object, MethodInfo method))
- {
- method.Invoke(@object, [mod]);
- }
- }
-
- private bool LoadMod(string modId, string modDirectory)
- {
- var fullPath = Path.GetFullPath(modDirectory);
- var modAssemblyFile = Path.Combine(fullPath, $"{modId}.dll");
- var assemblyExists = File.Exists(modAssemblyFile);
-
- if (!assemblyExists) return false;
-
- var modLoadContext = new ModAssemblyLoadContext(modId, modDirectory, _coreAssemblyLoadContext);
- var modAssembly = modLoadContext.LoadFromAssemblyName(new AssemblyName() { Name = modId });
-
- var modClass = modAssembly.GetTypes().FirstOrDefault(type => type.GetCustomAttributes().Any(attr => attr.GetType().Name == typeof(StarMapModAttribute).Name));
- if (modClass is null) return false;
-
- var modObject = Activator.CreateInstance(modClass);
- if (modObject is null) return false;
-
- _modLoadContexts.Add(modId, modLoadContext);
-
- var classMethods = modClass.GetMethods();
- var immediateLoadMethods = new List();
-
- foreach (var classMethod in classMethods)
- {
- var stringAttrs = classMethod.GetCustomAttributes().Select((attr) => attr.GetType().Name).Where(_registeredMethodAttributes.Keys.Contains);
- foreach (var stringAttr in stringAttrs)
- {
- var attr = _registeredMethodAttributes[stringAttr];
-
- if (!attr.IsValidSignature(classMethod)) continue;
-
- if (attr.GetType() == typeof(StarMapImmediateLoadAttribute))
- {
- immediateLoadMethods.Add(classMethod);
- }
-
- _mods.Add(modId, attr, modObject, classMethod);
- }
- }
-
- Console.WriteLine($"StarMap - Loaded mod: {modId} from {modAssemblyFile}");
- return true;
- }
-
- public void OnAllModsLoaded()
- {
- foreach (var (_, @object, method) in _mods.Get())
- {
- method.Invoke(@object, []);
- }
- }
-
- public void Dispose()
- {
- foreach (var (_, @object, method) in _mods.Get())
- {
- method.Invoke(@object, []);
- }
-
- _mods.Dispose();
- }
- }
-}
diff --git a/StarMap.Core/ModRepository/ModAssemblyLoadContext.cs b/StarMap.Core/ModRepository/ModAssemblyLoadContext.cs
index d6dbd6f..ccfb44b 100644
--- a/StarMap.Core/ModRepository/ModAssemblyLoadContext.cs
+++ b/StarMap.Core/ModRepository/ModAssemblyLoadContext.cs
@@ -9,19 +9,21 @@ internal class ModAssemblyLoadContext : AssemblyLoadContext
private readonly AssemblyLoadContext _coreAssemblyLoadContext;
private readonly AssemblyDependencyResolver _modDependencyResolver;
- public ModAssemblyLoadContext(string modId, string modDirectory, AssemblyLoadContext coreAssemblyContext)
+ public RuntimeMod? RuntimeMod { get; set; }
+
+ public ModAssemblyLoadContext(string modId, string entryAssemblyLocation, AssemblyLoadContext coreAssemblyContext)
: base()
{
_coreAssemblyLoadContext = coreAssemblyContext;
_modDependencyResolver = new AssemblyDependencyResolver(
- Path.GetFullPath(Path.Combine(modDirectory, modId + ".dll"))
+ Path.GetFullPath(entryAssemblyLocation)
);
}
protected override Assembly? Load(AssemblyName assemblyName)
{
- var existingInDefault = AssemblyLoadContext.Default.Assemblies
+ var existingInDefault = Default.Assemblies
.FirstOrDefault(a => string.Equals(a.GetName().Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase));
if (existingInDefault != null)
return existingInDefault;
@@ -44,6 +46,25 @@ public ModAssemblyLoadContext(string modId, string modDirectory, AssemblyLoadCon
}
}
+ if (RuntimeMod is RuntimeMod modInfo && modInfo.Dependencies.Count > 0)
+ {
+ foreach (var (dependency, importedAssemblies) in modInfo.Dependencies)
+ {
+ if (importedAssemblies.Contains(assemblyName.Name ?? string.Empty))
+ {
+ try
+ {
+ var asm = dependency.ModAssemblyLoadContext.LoadFromAssemblyName(assemblyName);
+ if (asm != null)
+ return asm;
+ }
+ catch (FileNotFoundException)
+ {
+ }
+ }
+ }
+ }
+
var foundPath = _modDependencyResolver.ResolveAssemblyToPath(assemblyName);
if (foundPath is null)
return null;
diff --git a/StarMap.Core/ModRepository/ModLoader.cs b/StarMap.Core/ModRepository/ModLoader.cs
new file mode 100644
index 0000000..c0a8754
--- /dev/null
+++ b/StarMap.Core/ModRepository/ModLoader.cs
@@ -0,0 +1,156 @@
+using KSA;
+using StarMap.API;
+using StarMap.Core.Config;
+using System.Reflection;
+using System.Runtime.Loader;
+using Tomlet;
+
+namespace StarMap.Core.ModRepository
+{
+ internal sealed class ModLoader : IDisposable
+ {
+ private readonly AssemblyLoadContext _coreAssemblyLoadContext;
+
+ public static Dictionary RegisteredMethodAttributes = [];
+
+
+ private readonly ModRegistry _modRegistry = new();
+ public ModRegistry ModRegistry => _modRegistry;
+
+ private (string attributeName, StarMapMethodAttribute attribute)? ConvertAttributeType(Type attrType)
+ {
+ if ((Activator.CreateInstance(attrType) as StarMapMethodAttribute) is not StarMapMethodAttribute attrObject) return null;
+ return (attrType.Name, attrObject);
+ }
+
+ public ModLoader(AssemblyLoadContext coreAssemblyLoadContext)
+ {
+ _coreAssemblyLoadContext = coreAssemblyLoadContext;
+
+ Assembly coreAssembly = typeof(StarMapModAttribute).Assembly;
+
+ RegisteredMethodAttributes = coreAssembly
+ .GetTypes()
+ .Where(t =>
+ typeof(StarMapMethodAttribute).IsAssignableFrom(t) &&
+ t.IsClass &&
+ !t.IsAbstract &&
+ t.GetCustomAttribute()?.ValidOn.HasFlag(AttributeTargets.Method) == true
+ )
+ .Select(ConvertAttributeType)
+ .OfType<(string attributeName, StarMapMethodAttribute attribute)>()
+ .ToDictionary();
+ }
+
+ public void Init()
+ {
+ PrepareMods();
+ }
+
+ private void PrepareMods()
+ {
+ var loadedManifest = ModLibrary.PrepareManifest();
+
+ if (!loadedManifest) return;
+
+ var mods = ModLibrary.Manifest.Mods;
+ if (mods is null) return;
+
+ string rootPath = "Content";
+ string path = Path.Combine(new ReadOnlySpan(in rootPath));
+
+ foreach (var mod in mods)
+ {
+ if (!mod.Enabled)
+ {
+ Console.WriteLine($"StarMap - Nod loading mod: {mod.Id} because it is disable in manifest");
+ continue;
+ }
+
+ var modPath = Path.Combine(path, mod.Id);
+
+ if (!RuntimeMod.TryCreateMod(mod, _coreAssemblyLoadContext, out var runtimeMod))
+ continue;
+
+ ModRegistry.Add(runtimeMod);
+
+ if (!runtimeMod.AllDependenciesLoaded(ModRegistry))
+ {
+ Console.WriteLine($"StarMap - Delaying load of mod: {runtimeMod.ModId} due to missing dependencies: {string.Join(", ", runtimeMod.NotLoadedModDependencies.Keys)}");
+ continue;
+ }
+
+ if (!runtimeMod.InitializeMod(ModRegistry))
+ {
+ Console.WriteLine($"StarMap - Failed to initialize mod: {runtimeMod.ModId} from manifest");
+ continue;
+ }
+
+ Console.WriteLine($"StarMap - Loaded mod: {runtimeMod.ModId} from manifest");
+
+ var dependentMods = runtimeMod.CheckForDependentMods(ModRegistry);
+
+ foreach (var dependentMod in dependentMods)
+ {
+ if (dependentMod.InitializeMod(ModRegistry))
+ {
+ Console.WriteLine($"StarMap - Loaded mod: {dependentMod.ModId} after loading {runtimeMod.ModId}");
+ }
+ else
+ {
+ Console.WriteLine($"StarMap - Failed to load mod: {dependentMod.ModId} after loading {runtimeMod.ModId}");
+ }
+ }
+ }
+
+ TryLoadWaitingMods();
+ }
+
+ private void TryLoadWaitingMods()
+ {
+ var loadedMod = true;
+
+ while (ModRegistry.WaitingModsDependencyGraph.Count > 0 && loadedMod)
+ {
+ loadedMod = false;
+ foreach (var waitingMod in ModRegistry.WaitingMods)
+ {
+ if (waitingMod.NotLoadedModDependencies.Count == 0 || waitingMod.NotLoadedModDependencies.Values.All(dependencyInfo => dependencyInfo.Optional))
+ {
+ loadedMod = true;
+ ModRegistry.WaitingMods.Remove(waitingMod);
+
+ if (waitingMod.InitializeMod(ModRegistry))
+ {
+ Console.WriteLine($"StarMap - Loaded mod: {waitingMod.ModId} after all mods were loaded, not loaded optional mods: {string.Join(",", waitingMod.NotLoadedModDependencies.Values.Select(mod => mod.ModId))}");
+ }
+ else
+ {
+ Console.WriteLine($"StarMap - Failed to load mod:{waitingMod.ModId} after all mods were loaded, not loaded optional mods: {string.Join(",", waitingMod.NotLoadedModDependencies.Values.Select(mod => mod.ModId))}");
+ }
+ waitingMod.NotLoadedModDependencies.Clear();
+ }
+ }
+ }
+
+ if (ModRegistry.WaitingMods.Count > 0)
+ {
+ foreach (var waitingMod in ModRegistry.WaitingMods)
+ {
+ Console.WriteLine($"StarMap - Failed to load mod:{waitingMod.ModId} after all mods were loaded, missing mods (some may be optional): {string.Join(",", waitingMod.NotLoadedModDependencies.Values.Select(mod => mod.ModId))}");
+ }
+ ModRegistry.WaitingMods.Clear();
+ }
+ }
+
+ public void Dispose()
+ {
+ foreach (var (_, @object, method) in _modRegistry.Get())
+ {
+ method.Invoke(@object, []);
+ }
+
+ _modRegistry.Dispose();
+ }
+ }
+}
diff --git a/StarMap.Core/ModRepository/ModRegistry.cs b/StarMap.Core/ModRepository/ModRegistry.cs
index 40e1b3b..04ae34f 100644
--- a/StarMap.Core/ModRepository/ModRegistry.cs
+++ b/StarMap.Core/ModRepository/ModRegistry.cs
@@ -1,38 +1,61 @@
using KSA;
using StarMap.API;
+using StarMap.Core.Config;
+using System.Diagnostics.CodeAnalysis;
using System.Reflection;
namespace StarMap.Core.ModRepository
{
internal sealed class ModRegistry : IDisposable
{
- private readonly Dictionary> _map = [];
- private readonly Dictionary _beforeMainActions = [];
- private readonly Dictionary _prepareSystemsActions = [];
+ public Dictionary> WaitingModsDependencyGraph { get; } = [];
+ public HashSet WaitingMods { get; } = [];
- public void Add(string modId, StarMapMethodAttribute attribute, object @object, MethodInfo method)
+ private readonly Dictionary _mods = [];
+ private readonly Dictionary> _modMethods = [];
+
+ public bool ModLoaded(string modId) => _mods.ContainsKey(modId);
+
+ public bool TryGetMod(string modId, [NotNullWhen(true)] out RuntimeMod? modInfo)
+ {
+ return _mods.TryGetValue(modId, out modInfo);
+ }
+
+ public void Add(RuntimeMod modInfo)
+ {
+ _mods.Add(modInfo.ModId, modInfo);
+ }
+
+ public IEnumerable GetMods()
+ {
+ return _mods.Values;
+ }
+
+ public void AddModMethod(string modId, StarMapMethodAttribute methodAttribute, object @object, MethodInfo method)
{
- var attributeType = attribute.GetType();
+ if (!_mods.TryGetValue(modId, out var modInfo)) return;
+
+ var attributeType = methodAttribute.GetType();
- if (!_map.TryGetValue(attributeType, out var list))
+ if (!_modMethods.TryGetValue(attributeType, out var list))
{
list = [];
- _map[attributeType] = list;
+ _modMethods[attributeType] = list;
}
- if (attribute.GetType() == typeof(StarMapBeforeMainAttribute))
- _beforeMainActions[modId] = (@object, method);
+ if (methodAttribute.GetType() == typeof(StarMapBeforeMainAttribute))
+ modInfo.BeforeMainAction = method;
- if (attribute.GetType() == typeof(StarMapImmediateLoadAttribute))
- _prepareSystemsActions[modId] = (@object, method);
+ if (methodAttribute.GetType() == typeof(StarMapImmediateLoadAttribute))
+ modInfo.PrepareSystemsAction = method;
- list.Add((attribute, @object, method));
+ list.Add((methodAttribute, @object, method));
}
public IReadOnlyList<(StarMapMethodAttribute attribute, object @object, MethodInfo method)> Get()
where TAttribute : Attribute
{
- if (_map.TryGetValue(typeof(TAttribute), out var list))
+ if (_modMethods.TryGetValue(typeof(TAttribute), out var list))
{
return list.Cast<(StarMapMethodAttribute attribute, object @object, MethodInfo method)>().ToList();
}
@@ -42,24 +65,14 @@ public void Add(string modId, StarMapMethodAttribute attribute, object @object,
public IReadOnlyList<(StarMapMethodAttribute attribute, object @object, MethodInfo method)> Get(Type iface)
{
- return _map.TryGetValue(iface, out var list)
+ return _modMethods.TryGetValue(iface, out var list)
? list
: Array.Empty<(StarMapMethodAttribute attribute, object @object, MethodInfo method)>();
}
- public (object @object, MethodInfo method)? GetBeforeMainAction(string modId)
- {
- return _beforeMainActions.TryGetValue(modId, out var action) ? action : null;
- }
-
- public (object @object, MethodInfo method)? GetPrepareSystemsAction(string modId)
- {
- return _prepareSystemsActions.TryGetValue(modId, out var action) ? action : null;
- }
-
public void Dispose()
{
- _map.Clear();
+ _modMethods.Clear();
}
}
}
diff --git a/StarMap.Core/ModRepository/RuntimeMod.cs b/StarMap.Core/ModRepository/RuntimeMod.cs
new file mode 100644
index 0000000..25bea2e
--- /dev/null
+++ b/StarMap.Core/ModRepository/RuntimeMod.cs
@@ -0,0 +1,176 @@
+using KSA;
+using StarMap.API;
+using StarMap.Core.Config;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Loader;
+using System.Text;
+using Tomlet;
+
+namespace StarMap.Core.ModRepository
+{
+ internal class RuntimeMod
+ {
+ private static readonly string _rootContentPath = Path.Combine(["Content"]);
+
+ public required string ModId { get; init; }
+ public required ModAssemblyLoadContext ModAssemblyLoadContext { get; init; }
+ public required Type ModType { get; init; }
+ public required StarMapConfig Config { get; init; }
+
+ public bool Initialized { get; set; } = false;
+ public object? ModInstance { get; set; } = null;
+
+ public HashSet ExportedAssemblies { get; set; } = [];
+ public Dictionary> Dependencies { get; set; } = [];
+ public Dictionary NotLoadedModDependencies { get; set; } = [];
+
+ public MethodInfo? BeforeMainAction { get; set; } = null;
+ public MethodInfo? PrepareSystemsAction { get; set; } = null;
+
+
+ public static bool TryCreateMod(ModEntry manifestEntry, AssemblyLoadContext coreALC, [NotNullWhen(true)] out RuntimeMod? runtimeMod)
+ {
+ runtimeMod = null;
+
+ var modPath = Path.Combine(_rootContentPath, manifestEntry.Id);
+ var modTomlPath = Path.Combine(modPath, "mod.toml");
+ if (!File.Exists(modTomlPath)) return false;
+ var tomlConfig = TomletMain.To(File.ReadAllText(modTomlPath));
+ if (tomlConfig?.StarMap is not StarMapConfig starMapConfig)
+ {
+ starMapConfig = new StarMapConfig
+ {
+ EntryAssembly = manifestEntry.Id,
+ };
+ }
+
+ var modAssemblyFile = Path.Combine(modPath, $"{starMapConfig.EntryAssembly}.dll");
+ var assemblyExists = File.Exists(modAssemblyFile);
+
+ if (!assemblyExists) return false;
+
+ var modLoadContext = new ModAssemblyLoadContext(manifestEntry.Id, modAssemblyFile, coreALC);
+ var modAssembly = modLoadContext.LoadFromAssemblyName(new AssemblyName() { Name = starMapConfig.EntryAssembly });
+
+ var modClass = modAssembly.GetTypes().FirstOrDefault(type => type.GetCustomAttributes().Any(attr => attr.GetType().Name == typeof(StarMapModAttribute).Name));
+ if (modClass is null) return false;
+
+ runtimeMod = new RuntimeMod
+ {
+ ModId = manifestEntry.Id,
+ ModAssemblyLoadContext = modLoadContext,
+ ModType = modClass,
+ Config = starMapConfig,
+ };
+
+ modLoadContext.RuntimeMod = runtimeMod;
+
+ return true;
+ }
+
+ public bool AllDependenciesLoaded(ModRegistry modRegistry)
+ {
+ foreach (var dependency in Config.ModDependencies)
+ {
+ if (!modRegistry.TryGetMod(dependency.ModId, out var modDependency))
+ {
+ NotLoadedModDependencies.Add(dependency.ModId, dependency);
+
+ if (!modRegistry.WaitingModsDependencyGraph.TryGetValue(dependency.ModId, out var dependents))
+ {
+ dependents = [];
+ modRegistry.WaitingModsDependencyGraph[dependency.ModId] = dependents;
+ }
+ dependents.Add(this);
+ }
+ else
+ {
+ Dependencies.Add(modDependency, [.. CalculateUseableAssemblies(modDependency, dependency)]);
+ }
+ }
+
+ if (NotLoadedModDependencies.Count > 0)
+ {
+
+ modRegistry.WaitingMods.Add(this);
+ return false;
+ }
+
+ return true;
+ }
+
+ private static IEnumerable CalculateUseableAssemblies(RuntimeMod dependency, StarMapModDependency dependencyInfo)
+ {
+
+ var hasImportedAssemblies = dependencyInfo.ImportedAssemblies.Count > 0;
+ var hasExportedAssemblies = dependency.ExportedAssemblies.Count > 0;
+
+ if (!hasImportedAssemblies && !hasExportedAssemblies)
+ {
+ return [dependency.Config.EntryAssembly];
+ }
+
+ if (hasImportedAssemblies && !hasExportedAssemblies)
+ return dependencyInfo.ImportedAssemblies;
+
+ if (!hasImportedAssemblies && hasExportedAssemblies)
+ return dependency.ExportedAssemblies;
+
+ return dependency.ExportedAssemblies.Intersect(dependencyInfo.ImportedAssemblies);
+ }
+
+ public bool InitializeMod(ModRegistry modRegistry)
+ {
+ var modObject = Activator.CreateInstance(ModType);
+ if (modObject is null) return false;
+ ModInstance = modObject;
+ Initialized = true;
+
+ var classMethods = ModType.GetMethods();
+
+ foreach (var classMethod in classMethods)
+ {
+ var stringAttrs = classMethod.GetCustomAttributes().Select((attr) => attr.GetType().Name).Where(ModLoader.RegisteredMethodAttributes.Keys.Contains);
+ foreach (var stringAttr in stringAttrs)
+ {
+ var attr = ModLoader.RegisteredMethodAttributes[stringAttr];
+
+ if (!attr.IsValidSignature(classMethod)) continue;
+
+ modRegistry.AddModMethod(ModId, attr, modObject, classMethod);
+ }
+ }
+
+ if (modRegistry.TryGetMod(ModId, out var modInfo) && modInfo.BeforeMainAction is MethodInfo action)
+ {
+ action.Invoke(modInfo.ModInstance, []);
+ }
+
+ return true;
+ }
+
+ public List CheckForDependentMods(ModRegistry modRegistry)
+ {
+ List loadableMods = [];
+ if (modRegistry.WaitingModsDependencyGraph.TryGetValue(ModId, out var modDependents))
+ {
+ foreach (var modDependent in modDependents)
+ {
+ var dependencyInfo = modDependent.NotLoadedModDependencies[ModId];
+ modDependent.Dependencies.Add(this, [.. dependencyInfo.ImportedAssemblies]);
+ if (modDependent.NotLoadedModDependencies.Remove(ModId) && modDependent.NotLoadedModDependencies.Count == 0)
+ {
+ modRegistry.WaitingMods.Remove(modDependent);
+ loadableMods.Add(modDependent);
+ }
+ }
+ modRegistry.WaitingModsDependencyGraph.Remove(ModId);
+ }
+ return loadableMods;
+ }
+ }
+}
diff --git a/StarMap.Core/Patches/ModLibraryPatches.cs b/StarMap.Core/Patches/ModLibraryPatches.cs
index cb87311..ab5fcea 100644
--- a/StarMap.Core/Patches/ModLibraryPatches.cs
+++ b/StarMap.Core/Patches/ModLibraryPatches.cs
@@ -1,5 +1,7 @@
using HarmonyLib;
using KSA;
+using StarMap.API;
+using StarMap.Core.ModRepository;
namespace StarMap.Core.Patches
{
@@ -10,7 +12,13 @@ internal class ModLibraryPatches
[HarmonyPostfix]
public static void AfterLoad()
{
- StarMapCore.Instance?.LoadedMods.OnAllModsLoaded();
+ var modRegistry = StarMapCore.Instance?.Loader.ModRegistry;
+ if (modRegistry is not ModRegistry registry) return;
+
+ foreach (var (_, @object, method) in registry.Get())
+ {
+ method.Invoke(@object, []);
+ }
}
}
}
diff --git a/StarMap.Core/Patches/ModPatches.cs b/StarMap.Core/Patches/ModPatches.cs
index 69ce5b0..8829746 100644
--- a/StarMap.Core/Patches/ModPatches.cs
+++ b/StarMap.Core/Patches/ModPatches.cs
@@ -1,5 +1,7 @@
using HarmonyLib;
using KSA;
+using StarMap.Core.ModRepository;
+using System.Reflection;
namespace StarMap.Core.Patches
{
@@ -10,7 +12,13 @@ internal static class ModPatches
[HarmonyPrefix]
public static void OnLoadMod(this Mod __instance)
{
- StarMapCore.Instance?.LoadedMods.ModPrepareSystems(__instance);
+ var modRegistry = StarMapCore.Instance?.Loader.ModRegistry;
+ if (modRegistry is not ModRegistry registry) return;
+
+ if (registry.TryGetMod(__instance.Id, out var modInfo) && modInfo.PrepareSystemsAction is MethodInfo action)
+ {
+ action.Invoke(modInfo.ModInstance, [__instance]);
+ }
}
}
}
diff --git a/StarMap.Core/Patches/ProgramPatcher.cs b/StarMap.Core/Patches/ProgramPatcher.cs
index 69b79ca..5c819d7 100644
--- a/StarMap.Core/Patches/ProgramPatcher.cs
+++ b/StarMap.Core/Patches/ProgramPatcher.cs
@@ -8,12 +8,13 @@ namespace StarMap.Core.Patches
internal static class ProgramPatcher
{
private const string OnDrawUiMethodName = "OnDrawUi";
+ private const string OnFrameMethodName = "OnFrame";
[HarmonyPatch(OnDrawUiMethodName)]
[HarmonyPrefix]
public static void BeforeOnDrawUi(double dt)
{
- var methods = StarMapCore.Instance?.LoadedMods.Mods.Get() ?? [];
+ var methods = StarMapCore.Instance?.Loader.ModRegistry.Get() ?? [];
foreach (var (_, @object, method) in methods)
{
@@ -25,12 +26,24 @@ public static void BeforeOnDrawUi(double dt)
[HarmonyPostfix]
public static void AfterOnDrawUi(double dt)
{
- var methods = StarMapCore.Instance?.LoadedMods.Mods.Get() ?? [];
+ var methods = StarMapCore.Instance?.Loader.ModRegistry.Get() ?? [];
foreach (var (_, @object, method) in methods)
{
method.Invoke(@object, [dt]);
}
}
+
+ [HarmonyPatch(OnFrameMethodName)]
+ [HarmonyPostfix]
+ public static void AfterOnFrame(double currentPlayerTime, double dtPlayer)
+ {
+ var methods = StarMapCore.Instance?.Loader.ModRegistry.Get() ?? [];
+
+ foreach (var (_, @object, method) in methods)
+ {
+ method.Invoke(@object, new object[] { currentPlayerTime, dtPlayer });
+ }
+ }
}
}
diff --git a/StarMap.Core/StarMap.Core.csproj b/StarMap.Core/StarMap.Core.csproj
index cf2929a..2d06ac0 100644
--- a/StarMap.Core/StarMap.Core.csproj
+++ b/StarMap.Core/StarMap.Core.csproj
@@ -8,6 +8,9 @@
+
+ runtime
+
@@ -20,7 +23,7 @@
-
+
runtime
diff --git a/StarMap.Core/StarMapCore.cs b/StarMap.Core/StarMapCore.cs
index 4f54870..828dbfd 100644
--- a/StarMap.Core/StarMapCore.cs
+++ b/StarMap.Core/StarMapCore.cs
@@ -12,26 +12,26 @@ internal class StarMapCore : IStarMapCore
private readonly Harmony _harmony = new("StarMap.Core");
private readonly AssemblyLoadContext _coreAssemblyLoadContext;
- private readonly LoadedModRepository _loadedMods;
- public LoadedModRepository LoadedMods => _loadedMods;
+ private readonly ModLoader _loader;
+ public ModLoader Loader => _loader;
public StarMapCore(AssemblyLoadContext coreAssemblyLoadContext)
{
Instance = this;
_coreAssemblyLoadContext = coreAssemblyLoadContext;
- _loadedMods = new(_coreAssemblyLoadContext);
+ _loader = new(_coreAssemblyLoadContext);
}
public void Init()
{
- _loadedMods.Init();
+ _loader.Init();
_harmony.PatchAll(typeof(StarMapCore).Assembly);
}
public void DeInit()
{
_harmony.UnpatchAll();
- _loadedMods.Dispose();
+ _loader.Dispose();
}
}
}