Loading non-static event functions

[nurbat]

It is possible to run not static methods but methods in a class inherited from an interface, for example IUnrealCore

public class GameLogic : IUnrealCore
{
OnWorldBegin();
etc..
}

I tried to make what would cling and other builds using this method, but when I try to call the Debug function that goes UnrealEngine hangs. If you need I can attach the bootloader files.

            var managedPath = Environment.CurrentDirectory + @"\Managed";
            var managedFiles = Directory.EnumerateFiles(managedPath, "*.dll", new EnumerationOptions { RecurseSubdirectories = true });

            foreach (var managedFile in managedFiles)
            {
                try
                {
                    var uLoader = new ULoader(managedFile);
                    if (!uLoader.IsValidGame)
                    {
                        uLoader.Dispose();
                        continue;
                    }

                    ULoader.AddInStore(uLoader);
                }
                catch (BadImageFormatException) { }
                catch (Exception e)
                {
                    Debug.AddOnScreenMessage(-1, float.MaxValue, Color.Red, e.ToString());
                }
            }

public sealed class ULoader : AssemblyLoadContext, IDisposable
    {
        public void InvokeOnAwake()
        {
            foreach (var item in _uGameInstances.Values)
            {
                item.GetType().GetMethod("OnAwake").Invoke(item, default);
            } 
        }

        #region ULoader

        public AssemblyName GetGameName() => _implementationAssembly.GetName();
        public IEnumerable<object> GetGameInstances() => _uGameInstances.Values;
        public Assembly GetGameAssembly() => _implementationAssembly;
        public IEnumerable<Type> GetGameTypes() => _uGameTypes;

        public readonly bool IsValidGame;

        ~ULoader() => Dispose(false);
        internal ULoader(string entryMain) : base(isCollectible: true)
        {
            _assemblyDependencyResolver = new(entryMain);
            try
            {
                _implementationAssembly = LoadFromAssemblyPath(entryMain);
                var implementationTypes = _implementationAssembly.ExportedTypes.Where(u => u.IsAbstract == false);

                if (_interfaceAssembly is not null)
                {
                    var interfaceType = _interfaceAssembly.GetType(typeof(UGame).FullName);
                    _uGameTypes = implementationTypes.Where(u => interfaceType.IsAssignableFrom(u));
                    if (IsValidGame = _uGameTypes.Any())
                    {
                        _uGameInstances = _uGameTypes.ToDictionary(uType => uType, uType => Activator.CreateInstance(uType));
                        Debug.AddOnScreenMessage(-1, float.MaxValue, Color.White, entryMain);
                        InvokeOnAwake();
                    }
                }
            }
            catch (BadImageFormatException) { }
            catch (Exception ex)
            {
                Debug.AddOnScreenMessage(-1, float.MaxValue, Color.White, entryMain + ex.ToString());
            }
        }

        protected override Assembly Load(AssemblyName assemblyName)
        {
            string assemblyPath = _assemblyDependencyResolver.ResolveAssemblyToPath(assemblyName);
            if (assemblyPath != null)
            {
                var isInterfaceAssembly = assemblyName.Name.Equals(FRAMEWORK_NAME, StringComparison.OrdinalIgnoreCase);
                return isInterfaceAssembly ? _interfaceAssembly = LoadFromAssemblyPath(assemblyPath) : LoadFromAssemblyPath(assemblyPath);
            }

            return null;
        }

        public void Dispose(bool dispose)
        {
            Unload();
            RemoveInStore(this);
            _uGameTypes = default;
            _uGameInstances = default;
            //_uTypeGamesList = default;
            _interfaceAssembly = default;
            _implementationAssembly = default;
            _assemblyDependencyResolver = default;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private Assembly _interfaceAssembly;
        private IEnumerable<Type> _uGameTypes;
        private IDictionary<Type, object> _uGameInstances;
        private Assembly _implementationAssembly;
        private AssemblyDependencyResolver _assemblyDependencyResolver;

        private const string FRAMEWORK_NAME = "Vodji.UnrealEngine";
        #endregion

        #region ULoader_Static
        public static void AddInStore(ULoader uLoader) => s_uLoaders.Add(uLoader);
        public static void RemoveInStore(ULoader uLoader) => s_uLoaders.Remove(uLoader);

        public static IEnumerable<ULoader> GetFromStoreLoaders() => s_uLoaders.ToArray();
        public static IEnumerable<UGame> GetFromStoreGameInstances()
        {
            if (s_uGameInstance is not null) return s_uGameInstance;

            List<UGame> uGameList = new();
            foreach (var uLoader in GetFromStoreLoaders())
            {
                Debug.AddOnScreenMessage(-1, float.MaxValue, Color.Red, string.Join(' ', uLoader.GetGameInstances().Select(u => u.GetType().Name)));
                //uGameList.AddRange(uLoader.GetGameInstances());
            }

            return s_uGameInstance = uGameList.ToArray();
        }

        private static IEnumerable<UGame> s_uGameInstance;
        private readonly static List<ULoader> s_uLoaders = new();
        #endregion
    }

[nxrighthere]

Is the GameLogic class instantiated properly?

[nurbat]

I will describe my steps in detail.
There is an assembly: Vodji.UnrealEngine

• Reference UnrealEngine.Framework.
• Game.Main static functions

There is another assembly: GameLogic

• Reference Vodji.UnrealEngine
• Reference UnrealEngine.Framework
• GameLogicClass : UGame
• GameLogicClassTwo : UGame

How the assembly works: Vodji.UnrealEngine
When loading the world

1. We look for all Managed libraries in the Managed folder
2. We search all found Managed libraries for the classes which derive from the abstract UGame class (GameLogicClass, GameLogicClassTwo)
3. we create for each Managed Library -> AssemblyLoadContext
4. We write everything in a thread-safe array
5. We create instances of classes from UGame and write to the same array
6. When we have collected all the classes from all Managed libraries that we need to load and run.
7. We already call through createdInstance.GetType().GetMethod("OnWorldBegin").Invoke(createdInstance, default) for all instances...

Everything works, but when I try to call any method from UnrealEngine.Framework library UnrealEditor itself hangs, and it can't even be closed via Task Manager, I have to log out of the hung application.

Translated with www.DeepL.com/Translator (free version)

[nxrighthere]

Have you tried to attach a debugger to the engine and check if any exceptions occur?

[nurbat]

No, I have not tried, if you give instructions on how to do it right I can try.

[nxrighthere]

You can use Visual Studio or dnSpy debugger for that. Just attach it to the process after running the editor before entering play mode.

[nurbat]

System.AccessViolationException: 'Attempted to read or write protected memory. This is often an indication that other memory is corrupt.'

I create a UDebug class under Vodji.UnrealEngine and use it to call Debug

namespace Vodji.UnrealEngine
{
    public class UDebug
    {
        public static void ScreenMessage(object message, Color color = default, float timeout = 15)
        {
            Debug.AddOnScreenMessage(-1, timeout, Color.White, message.ToString());
        }
    }
}

namespace GameLogic
{
    public class Class1 : UGame
    {
        public override void OnWorldBegin()
        {
            UDebug.ScreenMessage("TEST"); // System.AccessViolationException
        }
    }
}

[nxrighthere]

You have to trace bug in your loading logic. Make sure that the plugin framework loaded properly.

[nurbat]

plugin.userFunctions = (Dictionary<int, IntPtr>)sharedClass.GetMethod("Load", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, new object[] { sharedEvents, sharedFunctions, plugin.assembly });

But how do I initiate UnrealEngine.Framework.Shared from my libraries without affecting yours, if I'm going to do everything without changing your library. That's where I came in, that you could tell me how to do multiple dll loading and class initiation. Without changing your library.

If i don't understand something, tell me.

[nxrighthere]

Only one plugin framework assembly can be loaded at a time. You have to refactor the loading of the framework to suit your needs.

[nurbat]

Tell me how you can debug the file Runtime.cs and another file that is in the folder Plugins, because vs does not see the characters.

[nxrighthere]

You can launch and attach a debugger from code.

[nurbat]

I apologize for the stupid debugging questions.
But how can I debug a plugin in c++ In the editor ?

[nxrighthere]

You have to build and run the C++ project from Visual Studio in order to debug plugins.