- add: script abilities

Nebula.Runner/Nebula.Runner.csproj

@@ -14,6 +14,7 @@
     <ItemGroup>
         <PackageReference Include="Lib.Harmony" Version="2.3.6" />
         <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0"/>
+        <PackageReference Include="NLua" Version="1.7.5" />
         <PackageReference Include="SharpZstd.Interop" Version="1.5.6"/>
     </ItemGroup>
 </Project>

Nebula.Runner/Services/HarmonyService.cs

@@ -1,11 +1,10 @@
-using System.Data;
 using HarmonyLib;
 using Nebula.Shared;
 
 namespace Nebula.Runner.Services;
 
 [ServiceRegister]
-public class HarmonyService(ReflectionService reflectionService)
+public class HarmonyService
 {
     private HarmonyInstance? _instance;
 
@@ -25,21 +24,6 @@ public class HarmonyService(ReflectionService reflectionService)
             throw new Exception();
         
         _instance = new HarmonyInstance();
-        UnShittyWizard();
-    }
-
-    /// <summary>
-    /// Я помню пенис большой,Я помню пенис большой, Я помню пенис большой, я помню....
-    /// </summary>
-    private void UnShittyWizard()
-    {
-        var method = reflectionService.GetType("Robust.Client.GameController").TypeInitializer;
-        _instance!.Harmony.Patch(method, new HarmonyMethod(Prefix));
-    }
-    
-    static bool Prefix()
-    {
-        return false;
     }
 }
 

Nebula.Runner/Services/ReflectionService.cs

@@ -1,33 +1,29 @@
 using System.Reflection;
 using Nebula.Shared;
-using Nebula.Shared.FileApis;
 using Nebula.Shared.Services;
 
 namespace Nebula.Runner.Services;
 
 [ServiceRegister]
-public class ReflectionService(AssemblyService assemblyService)
+public class ReflectionService
 {
-    private Dictionary<string, Assembly> _typeCache = new();
+    private readonly Dictionary<string, Assembly> _typeCache = new();
+
+    public ReflectionService(AssemblyService assemblyService)
+    {
+        assemblyService.OnAssemblyLoaded += OnAssemblyLoaded;
+    }
+
+    private void OnAssemblyLoaded(Assembly obj)
+    {
+        RegisterAssembly(obj);
+    }
 
     public void RegisterAssembly(Assembly robustAssembly)
     {
         _typeCache.Add(robustAssembly.GetName().Name!, robustAssembly);
     }
-
-    public void RegisterRobustAssemblies(AssemblyApi engine)
-    {
-        RegisterAssembly(GetRobustAssembly("Robust.Shared", engine));
-        RegisterAssembly(GetRobustAssembly("Robust.Client", engine));
-    }
-
-    private Assembly GetRobustAssembly(string assemblyName, AssemblyApi engine)
-    {
-        if(!assemblyService.TryOpenAssembly(assemblyName, engine, out var assembly))
-            throw new Exception($"Unable to locate {assemblyName}.dll in engine build!");
-        return assembly;
-    }
-
+    
     public Type? GetTypeImp(string name)
     {
         foreach (var (prefix,assembly) in _typeCache)
@@ -51,7 +47,7 @@ public class ReflectionService(AssemblyService assemblyService)
             : assembly.GetType(name)!;
     }
 
-    private string ExtrackPrefix(string path)
+    public string ExtrackPrefix(string path)
     {
         var sp = path.Split(".");
         return sp[0] + "." + sp[1];

Nebula.Runner/Services/RunnerService.cs

@@ -1,6 +1,5 @@
 using System.Globalization;
 using System.Reflection;
-using System.Reflection.Emit;
 using HarmonyLib;
 using Nebula.Shared;
 using Nebula.Shared.Models;
@@ -18,9 +17,10 @@ public sealed class RunnerService(
     EngineService engineService,
     AssemblyService assemblyService, 
     ReflectionService reflectionService, 
-    HarmonyService harmonyService)
+    HarmonyService harmonyService, 
+    ScriptService scriptService)
 {
-    private ILogger _logger = debugService.GetLogger("RunnerService");
+    private readonly ILogger _logger = debugService.GetLogger("RunnerService");
     private bool MetricEnabled = false; //TODO: ADD METRIC THINKS LATER
 
     public async Task Run(string[] runArgs, RobustBuildInfo buildInfo, IRedialApi redialApi,
@@ -58,6 +58,24 @@ public sealed class RunnerService(
         
         var args = new MainArgs(runArgs, engine, redialApi, extraMounts);
 
+
+        var assemblyManifest = hashApi.Manifest.Where(p => 
+                p.Key.StartsWith("Assemblies/"))
+            .Select(p =>
+            {
+                return p.Value with { Path = Path.GetFileNameWithoutExtension(p.Key) };
+            }).ToList();
+        
+        var assembliesHash = contentService.CreateHashApi(assemblyManifest);
+        
+        var contentAssemblyApi = assemblyService.Mount(assembliesHash);
+
+        foreach (var file in contentAssemblyApi.AllFiles.Where(p => Path.GetExtension(p) == ".dll"))
+        {
+            var newExt = Path.GetFileNameWithoutExtension(file);
+            if(!assemblyService.TryOpenAssembly(newExt, contentAssemblyApi, out _)) throw new Exception("Assembly not found: " + newExt);
+        }
+
         if (!assemblyService.TryOpenAssembly(varService.GetConfigValue(CurrentConVar.RobustAssemblyName)!, engine,
                 out var clientAssembly))
             throw new Exception("Unable to locate Robust.Client.dll in engine build!");
@@ -68,7 +86,6 @@ public sealed class RunnerService(
         if(!assemblyService.TryOpenAssembly("Prometheus.NetStandard", engine, out var prometheusAssembly))
             return;
         
-        reflectionService.RegisterRobustAssemblies(engine);
         harmonyService.CreateInstance();
         
         IDisposable? metricServer = null;
@@ -78,12 +95,18 @@ public sealed class RunnerService(
             MetricsEnabledPatcher.ApplyPatch(reflectionService, harmonyService);
             metricServer = RunHelper.RunMetric(prometheusAssembly);
         }
-       
+        
+        scriptService.LoadScripts();
         
         await Task.Run(() => loader.Main(args), cancellationToken);
         
         metricServer?.Dispose();
     }
+
+    private void CacheAssembly()
+    {
+        
+    }
 }
 
 public static class MetricsEnabledPatcher

Nebula.Runner/Services/ScriptService.cs

@@ -0,0 +1,181 @@
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using HarmonyLib;
+using Nebula.Shared;
+using Nebula.Shared.FileApis;
+using Nebula.Shared.Services;
+using NLua;
+
+namespace Nebula.Runner.Services;
+
+[ServiceRegister]
+public class ScriptService
+{
+    private readonly HarmonyService _harmonyService;
+    private readonly ReflectionService _reflectionService;
+    private readonly AssemblyService _assemblyService;
+
+    private readonly FileApi _scriptFileApi;
+    
+    private static Dictionary<MethodBase, ScriptManifestDict> _scriptCache = [];
+    private static Dictionary<string, Action> _assemblyLoadingQuery = [];
+
+    public ScriptService(HarmonyService harmonyService, ReflectionService reflectionService, FileService fileService, AssemblyService assemblyService)
+    {
+        _harmonyService = harmonyService;
+        _reflectionService = reflectionService;
+        _assemblyService = assemblyService;
+
+        _scriptFileApi = fileService.CreateFileApi("scripts");
+        _assemblyService.OnAssemblyLoaded += OnAssemblyLoaded;
+    }
+
+    private void OnAssemblyLoaded(Assembly obj)
+    {
+        var objName = obj.GetName().Name ?? string.Empty;
+        if (!_assemblyLoadingQuery.TryGetValue(objName, out var a)) return;
+        Console.WriteLine("Inject assembly: " + objName);
+        a();
+        _assemblyLoadingQuery.Remove(objName);
+    }
+
+    public void LoadScripts()
+    {
+        Console.WriteLine("Loading scripts... " + _scriptFileApi.EnumerateDirectories("").Count());
+        foreach (var dir in _scriptFileApi.EnumerateDirectories(""))
+        {
+            LoadScript(dir);
+        }
+    }
+    
+    public void LoadScript(string name)
+    {
+        Console.WriteLine($"Reading script {name}");
+        var manifests = ReadManifest(name);
+        
+        foreach (var entry in manifests)
+        {
+            if (entry.TypeInitializer.HasValue) LoadTypeInitializer(entry.TypeInitializer.Value, name);
+            if (entry.Method.HasValue) LoadMethod(entry.Method.Value, name);
+        }
+    }
+
+    private void LoadTypeInitializer(ScriptMethodInjectItem item, string name)
+    {
+        Console.WriteLine($"Loading Initializer injection {name}...");
+        var assemblyName = _reflectionService.ExtrackPrefix(item.Method.Class);
+        
+        if (!_assemblyService.Assemblies.Select(a => a.GetName().Name).Contains(assemblyName))
+        {
+            _assemblyLoadingQuery.Add(assemblyName, () => LoadTypeInitializer(item, name));
+            return;
+        }
+        
+        var targetType = _reflectionService.GetType(item.Method.Class);
+        var method = targetType.TypeInitializer;
+        InitialiseShared(method!, name, item);
+    }
+
+    private void LoadMethod(ScriptMethodInjectItem item, string name)
+    {
+        Console.WriteLine($"Loading method injection {name}...");
+        var assemblyName = _reflectionService.ExtrackPrefix(item.Method.Class);
+        
+        if (!_assemblyService.Assemblies.Select(a => a.GetName().Name).Contains(assemblyName))
+        {
+            _assemblyLoadingQuery.Add(assemblyName, () => LoadMethod(item, name));
+            return;
+        }
+        
+        var targetType = _reflectionService.GetType(item.Method.Class);
+        var method = targetType.GetMethod(item.Method.Method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
+        InitialiseShared(method!, name, item);
+    }
+
+    private void InitialiseShared(MethodBase method, string scriptName, ScriptMethodInjectItem item)
+    {
+        var scriptCode = File.ReadAllText(Path.Combine(_scriptFileApi.RootPath, scriptName, item.Script.LuaFile));
+        
+        var methodInfo = method as MethodInfo;
+        HarmonyMethod dynamicPatch;
+        
+        if (methodInfo == null || methodInfo.ReturnType == typeof(void))
+            dynamicPatch = new HarmonyMethod(typeof(ScriptService).GetMethod(nameof(LuaPrefix), BindingFlags.Static | BindingFlags.NonPublic));
+        else
+            dynamicPatch = new HarmonyMethod(typeof(ScriptService).GetMethod(nameof(LuaPrefixResult), BindingFlags.Static | BindingFlags.NonPublic));
+        
+        _scriptCache[method] = new ScriptManifestDict(scriptCode, item);
+
+        _harmonyService.Instance.Harmony.Patch(method, prefix: dynamicPatch);
+        Console.WriteLine($"Injected {scriptName}");
+    }
+
+    private ScriptEntry[] ReadManifest(string scriptName)
+    {
+        if(!_scriptFileApi.TryOpen(Path.Join(scriptName, "MANIFEST.json"), out var stream)) 
+            throw new FileNotFoundException(Path.Join(scriptName, "MANIFEST.json") + " not found manifest!");
+        
+        return JsonSerializer.Deserialize<ScriptEntry[]>(stream) ?? [];
+    }
+    
+    private static bool LuaPrefix(MethodBase __originalMethod, object __instance)
+    {
+        if (!_scriptCache.TryGetValue(__originalMethod, out var luaCode))
+            return true;
+
+        using var lua = new Lua();
+
+        lua["this"] = __instance;
+
+        var results = lua.DoString(luaCode.Code);
+        
+        if (results is { Length: > 0 } && results[0] is bool b)
+            return b;
+        
+        return luaCode.ScriptMethodInjectItem.ContinueAfterInject;
+    }
+    
+    private static bool LuaPrefixResult(MethodBase __originalMethod, object __instance, ref object __result)
+    {
+        if (!_scriptCache.TryGetValue(__originalMethod, out var luaCode))
+            return true;
+
+        using var lua = new Lua();
+
+        lua["this"] = __instance;
+        lua["result"] = __result;
+
+        var results = lua.DoString(luaCode.Code);
+
+        if (lua["result"] != null)
+            __result = lua["result"];
+        
+        if (results is { Length: > 0 } && results[0] is bool b)
+            return b;
+        
+        return luaCode.ScriptMethodInjectItem.ContinueAfterInject;
+    }
+}
+
+public record struct ScriptManifestDict(string Code, ScriptMethodInjectItem ScriptMethodInjectItem);
+
+public record struct ScriptEntry(
+    [property: JsonPropertyName("method")] ScriptMethodInjectItem? Method,
+    [property: JsonPropertyName("type_initializer")] ScriptMethodInjectItem? TypeInitializer
+    );
+
+public record struct ScriptMethodInjectItem(
+    [property: JsonPropertyName("method")] ScriptMethodInfo Method,
+    [property: JsonPropertyName("continue")] bool ContinueAfterInject, 
+    [property: JsonPropertyName("script")] LuaMethodEntry Script
+    );
+
+public record struct ScriptMethodInfo(
+    [property: JsonPropertyName("class")] string Class, 
+    [property: JsonPropertyName("method")] string Method
+    );
+
+public record struct LuaMethodEntry(
+    [property: JsonPropertyName("lua_file")] string LuaFile
+    );