Release v1.0.2

generator/schema_generator/templates/class_fixed_string_field_template.cs

@@ -1,9 +1,9 @@
-  private static readonly Lazy<nint> _$NAME$Offset = new(() => Schema.GetOffset($HASH$), LazyThreadSafetyMode.None);
+  private static readonly nint _$NAME$Offset = Schema.GetOffset($HASH$);
 
   public string $NAME$ {
     get {
-      var ptr = _Handle + _$NAME$Offset.Value;
+      var ptr = _Handle + _$NAME$Offset;
       return Schema.GetString(ptr);
     }
-    set => Schema.SetFixedString(_Handle, _$NAME$Offset.Value, value, $ELEMENT_COUNT$);
+    set => Schema.SetFixedString(_Handle, _$NAME$Offset, value, $ELEMENT_COUNT$);
   } 

generator/schema_generator/templates/class_ptr_field_template.cs

@@ -1,8 +1,8 @@
-  private static readonly Lazy<nint> _$NAME$Offset = new(() => Schema.GetOffset($HASH$), LazyThreadSafetyMode.None);
+  private static readonly nint _$NAME$Offset = Schema.GetOffset($HASH$);
 
   public $INTERFACE_TYPE$? $NAME$ {
     get {
-      var ptr = _Handle.Read<nint>(_$NAME$Offset.Value);
+      var ptr = _Handle.Read<nint>(_$NAME$Offset);
       return ptr.IsValidPtr() ? new $IMPL_TYPE$(ptr) : null;
     }
   }

generator/schema_generator/templates/class_ref_field_template.cs

@@ -1,5 +1,5 @@
-  private static readonly Lazy<nint> _$NAME$Offset = new(() => Schema.GetOffset($HASH$), LazyThreadSafetyMode.None);
+  private static readonly nint _$NAME$Offset = Schema.GetOffset($HASH$);
 
   public $INTERFACE_TYPE$ $NAME$ {
-    get => new $IMPL_TYPE$(_Handle + _$NAME$Offset.Value);
+    get => new $IMPL_TYPE$(_Handle + _$NAME$Offset);
   }

generator/schema_generator/templates/class_string_field_template.cs

@@ -1,9 +1,9 @@
-  private static readonly Lazy<nint> _$NAME$Offset = new(() => Schema.GetOffset($HASH$), LazyThreadSafetyMode.None);
+  private static readonly nint _$NAME$Offset = Schema.GetOffset($HASH$);
 
   public string $NAME$ {
     get {
-      var ptr = _Handle.Read<nint>(_$NAME$Offset.Value);
+      var ptr = _Handle.Read<nint>(_$NAME$Offset);
       return Schema.GetString(ptr);
     }
-    set => Schema.SetString(_Handle, _$NAME$Offset.Value, value);
+    set => Schema.SetString(_Handle, _$NAME$Offset, value);
   } 

generator/schema_generator/templates/class_value_field_template.cs

@@ -1,5 +1,5 @@
-  private static readonly Lazy<nint> _$NAME$Offset = new(() => Schema.GetOffset($HASH$), LazyThreadSafetyMode.None);
+  private static readonly nint _$NAME$Offset = Schema.GetOffset($HASH$);
 
   public ref $IMPL_TYPE$ $NAME$ {
-    get => ref _Handle.$REF_METHOD$<$IMPL_TYPE$>(_$NAME$Offset.Value);
+    get => ref _Handle.$REF_METHOD$<$IMPL_TYPE$>(_$NAME$Offset);
   }

managed/src/Entrypoint.cs

@@ -9,11 +9,11 @@ internal class Entrypoint
 {
     [UnmanagedCallersOnly]
     [SecurityCritical]
-    public unsafe static void Start( IntPtr nativeTable, int nativeTableSize, IntPtr basePath )
+    public unsafe static void Start( IntPtr nativeTable, int nativeTableSize, IntPtr basePath, IntPtr logsPath )
     {
         try
         {
-            Bootstrap.Start(nativeTable, nativeTableSize, Marshal.PtrToStringUTF8(basePath)!);
+            Bootstrap.Start(nativeTable, nativeTableSize, Marshal.PtrToStringUTF8(basePath)!, Marshal.PtrToStringUTF8(logsPath)!);
         }
         catch (Exception e)
         {

managed/src/SwiftlyS2.Core/Bootstrap.cs

@@ -1,102 +1,97 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Spectre.Console;
+using SwiftlyS2.Core.Misc;
+using SwiftlyS2.Core.Events;
 using SwiftlyS2.Core.Hosting;
 using SwiftlyS2.Core.Natives;
 using SwiftlyS2.Core.Services;
-using SwiftlyS2.Shared;
-using SwiftlyS2.Core.Events;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Hosting;
-using SwiftlyS2.Core.Misc;
-using Microsoft.Extensions.Configuration;
-using SwiftlyS2.Shared.Memory;
-using SwiftlyS2.Shared.Services;
-using System.Runtime.InteropServices;
 using SwiftlyS2.Shared.SteamAPI;
-using System.Reflection;
+
 namespace SwiftlyS2.Core;
 
 internal static class Bootstrap
 {
+    // how tf i forgot services can be collected hahahahahahahhaahhahaa FUCK
+    private static IHost? sw2Host;
 
-  // how tf i forgot services can be collected hahahahahahahhaahhahaa FUCK
-  private static IHost? _host;
-
-  private static IntPtr SteamAPIDLLResolver( string libraryName, Assembly assembly, DllImportSearchPath? searchPath )
-  {
-    if (libraryName == "steam_api" || libraryName == "sdkencryptedappticket")
+    private static IntPtr SteamAPIDLLResolver( string libraryName, Assembly assembly, DllImportSearchPath? searchPath )
     {
-      if (OperatingSystem.IsWindows())
-      {
-        libraryName += "64";
-      }
-
-      if (NativeLibrary.TryLoad(libraryName, out var handle))
-      {
-        return handle;
-      }
-    }
+        if (libraryName == "steam_api" || libraryName == "sdkencryptedappticket")
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                libraryName += "64";
+            }
 
-    return IntPtr.Zero;
-  }
+            if (NativeLibrary.TryLoad(libraryName, out var handle))
+            {
+                return handle;
+            }
+        }
 
-  public static void Start( IntPtr nativeTable, int nativeTableSize, string basePath )
-  {
-    Environment.SetEnvironmentVariable("SWIFTLY_MANAGED_ROOT", basePath);
-
-    NativeBinding.BindNatives(nativeTable, nativeTableSize);
-
-    NativeLibrary.SetDllImportResolver(typeof(NativeMethods).Assembly, SteamAPIDLLResolver);
-
-    EventPublisher.Register();
-    GameFunctions.Initialize();
-    FileLogger.Initialize(basePath);
+        return IntPtr.Zero;
+    }
 
-    AnsiConsole.Write(new FigletText("SwiftlyS2").LeftJustified().Color(Spectre.Console.Color.LightSteelBlue1));
+    public static void Start( IntPtr nativeTable, int nativeTableSize, string basePath, string logPath )
+    {
+        Environment.SetEnvironmentVariable("SWIFTLY_MANAGED_ROOT", basePath);
+        NativeBinding.BindNatives(nativeTable, nativeTableSize);
+        NativeLibrary.SetDllImportResolver(typeof(NativeMethods).Assembly, SteamAPIDLLResolver);
 
-    _host = Host.CreateDefaultBuilder()
-      .UseConsoleLifetime(options =>
-      {
-        options.SuppressStatusMessages = true;
-      })
-      .ConfigureServices(( context, services ) =>
-      {
-        services.AddHostedService<StartupService>();
-      })
-      .ConfigureLogging(( context, logging ) =>
-      {
-        logging.ClearProviders();
-        logging.AddProvider(new SwiftlyLoggerProvider("SwiftlyS2"));
-      })
-      .ConfigureAppConfiguration(( context, config ) =>
-      {
-        config.SetBasePath(Path.Combine(Environment.GetEnvironmentVariable("SWIFTLY_MANAGED_ROOT")!, "configs"));
-        config.AddJsonFile("permissions.jsonc", optional: false, reloadOnChange: true);
-      })
-      .ConfigureServices(( context, services ) =>
-      {
-        services
-          .AddProfileService()
-          .AddConfigurationService()
-          .AddTestService()
-          .AddRootDirService()
-          .AddDataDirectoryService()
-          .AddPlayerManagerService()
-          .AddPluginManager()
-          .AddHookManager()
-          .AddTraceManagerService()
-          .AddPermissionManager()
-          .AddCoreHookService()
-          .AddCoreCommandService()
-          .AddCommandTrackerManager()
-          .AddCommandTrackerService()
-          .AddSwiftlyCore(basePath);
-      })
-      .Build();
+        EventPublisher.Register();
+        GameFunctions.Initialize();
+        FileLogger.Initialize(logPath);
 
-    _host.Start();
+        AnsiConsole.Write(new FigletText("SwiftlyS2").LeftJustified().Color(Color.LightSteelBlue1));
 
-    // provider.UseTestService();
+        sw2Host = Host.CreateDefaultBuilder()
+            .UseConsoleLifetime(options =>
+            {
+                options.SuppressStatusMessages = true;
+            })
+            .ConfigureServices(( context, services ) =>
+            {
+                _ = services.AddHostedService<StartupService>();
+            })
+            .ConfigureLogging(( context, logging ) =>
+            {
+                _ = logging.ClearProviders();
+                _ = logging.AddProvider(new SwiftlyLoggerProvider("SwiftlyS2"));
+            })
+            .ConfigureAppConfiguration(( context, config ) =>
+            {
+                _ = config.SetBasePath(Path.Combine(Environment.GetEnvironmentVariable("SWIFTLY_MANAGED_ROOT")!, "configs"));
+                _ = config.AddJsonFile("permissions.jsonc", optional: false, reloadOnChange: true);
+            })
+            .ConfigureServices(( context, services ) =>
+            {
+                _ = services
+                    .AddProfileService()
+                    .AddConfigurationService()
+                    .AddTestService()
+                    .AddRootDirService()
+                    .AddDataDirectoryService()
+                    .AddPlayerManagerService()
+                    .AddPluginManager()
+                    .AddHookManager()
+                    .AddTraceManagerService()
+                    .AddPermissionManager()
+                    .AddCoreHookService()
+                    .AddCoreCommandService()
+                    .AddCommandTrackerManager()
+                    .AddCommandTrackerService()
+                    .AddMenuManagerAPI()
+                    .AddMenuManagerAPIService()
+                    .AddSwiftlyCore(basePath);
+            })
+            .Build();
 
-  }
+        sw2Host.Start();
+        // provider.UseTestService();
+    }
 }

managed/src/SwiftlyS2.Core/Hosting/MenuManagerAPIInjection.cs

@@ -0,0 +1,12 @@
+using Microsoft.Extensions.DependencyInjection;
+using SwiftlyS2.Core.Menus;
+
+namespace SwiftlyS2.Core.Hosting;
+
+internal static class MenuManagerAPIInjection
+{
+    public static IServiceCollection AddMenuManagerAPI( this IServiceCollection self )
+    {
+        return self.AddSingleton<MenuManagerAPI>();
+    }
+}

managed/src/SwiftlyS2.Core/Hosting/MenuManagerAPIServiceInjection.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.DependencyInjection;
+using SwiftlyS2.Core.Services;
+
+namespace SwiftlyS2.Core.Hosting;
+
+internal static class MenuManagerAPIServiceInjection
+{
+    public static IServiceCollection AddMenuManagerAPIService( this IServiceCollection self )
+    {
+        return self.AddSingleton<MenuManagerAPIService>();
+    }
+
+    public static void UseMenuManagerAPIService( this IServiceProvider self )
+    {
+        self.GetRequiredService<MenuManagerAPIService>();
+    }
+}

managed/src/SwiftlyS2.Core/Misc/FileLogger.cs

@@ -11,7 +11,7 @@ internal static class FileLogger
 
   public static void Initialize( string basePath )
   {
-    var directory = Path.Combine(basePath, "logs");
+    var directory = basePath;
 
     if (!Directory.Exists(directory))
     {

managed/src/SwiftlyS2.Core/Modules/Events/EventParams/OnEntityTakeDamageEvent.cs

@@ -6,10 +6,13 @@
 
 namespace SwiftlyS2.Core.Events;
 
-internal class OnEntityTakeDamageEvent : IOnEntityTakeDamageEvent {
+internal class OnEntityTakeDamageEvent : IOnEntityTakeDamageEvent
+{
   public required CEntityInstance Entity { get; set; }
   public unsafe nint _infoPtr;
+  public unsafe nint _resultPtr;
   public ref CTakeDamageInfo Info => ref _infoPtr.AsRef<CTakeDamageInfo>();
+  public ref CTakeDamageResult DamageResult => ref _resultPtr.AsRef<CTakeDamageResult>();
 
   public HookResult Result { get; set; } = HookResult.Continue;
 

managed/src/SwiftlyS2.Core/Modules/Events/EventPublisher.cs

@@ -48,7 +48,7 @@ public static void Register()
             NativeEvents.RegisterOnMapLoadCallback((nint)(delegate* unmanaged< nint, void >)&OnMapLoad);
             NativeEvents.RegisterOnMapUnloadCallback((nint)(delegate* unmanaged< nint, void >)&OnMapUnload);
             NativeEvents.RegisterOnClientProcessUsercmdsCallback((nint)(delegate* unmanaged< int, nint, int, byte, float, void >)&OnClientProcessUsercmds);
-            NativeEvents.RegisterOnEntityTakeDamageCallback((nint)(delegate* unmanaged< nint, nint, byte >)&OnEntityTakeDamage);
+            NativeEvents.RegisterOnEntityTakeDamageCallback((nint)(delegate* unmanaged< nint, nint, nint, byte >)&OnEntityTakeDamage);
             NativeEvents.RegisterOnPrecacheResourceCallback((nint)(delegate* unmanaged< nint, void >)&OnPrecacheResource);
             NativeConvars.AddConvarCreatedListener((nint)(delegate* unmanaged< nint, void >)&OnConVarCreated);
             NativeConvars.AddConCommandCreatedListener((nint)(delegate* unmanaged< nint, void >)&OnConCommandCreated);
@@ -475,7 +475,7 @@ public static void OnClientProcessUsercmds( int playerId, nint usercmdsPtr, int
     }
 
     [UnmanagedCallersOnly]
-    public static byte OnEntityTakeDamage( nint entityPtr, nint takeDamageInfoPtr )
+    public static byte OnEntityTakeDamage( nint entityPtr, nint takeDamageInfoPtr, nint takeDamageResultPtr )
     {
         if (_subscribers.Count == 0) return 1;
         try
@@ -485,7 +485,8 @@ public static byte OnEntityTakeDamage( nint entityPtr, nint takeDamageInfoPtr )
                 var entity = new CEntityInstanceImpl(entityPtr);
                 OnEntityTakeDamageEvent @event = new() {
                     Entity = entity,
-                    _infoPtr = takeDamageInfoPtr
+                    _infoPtr = takeDamageInfoPtr,
+                    _resultPtr = takeDamageResultPtr
                 };
                 foreach (var subscriber in _subscribers)
                 {

managed/src/SwiftlyS2.Core/Modules/FileSystem/GameFileSystem.cs

@@ -1,5 +1,7 @@
+using System.Runtime.CompilerServices;
 using SwiftlyS2.Core.Natives;
 using SwiftlyS2.Shared.FileSystem;
+using SwiftlyS2.Shared.Natives;
 
 namespace SwiftlyS2.Core.FileSystem;
 
@@ -64,4 +66,19 @@ public bool WriteFile( string filePath, string pathId, string content )
     {
         return NativeFileSystem.WriteFile(filePath, pathId, content);
     }
+
+    public List<string> FindFileAbsoluteList( string wildcard, string pathId )
+    {
+        List<string> results = new();
+        ManagedCUtlVector<CUtlString> files = new();
+        unsafe {
+            fixed (void* filesPtr = &files.Value) {
+                NativeFileSystem.FindFileAbsoluteList(new IntPtr(filesPtr), wildcard, pathId);
+            }
+
+            files.Value.ToList().ForEach(file => results.Add(file.Value));
+        }
+        files.Dispose();
+        return results;
+    }
 }