update(managed): Various Fixes

skuzzis · skuzzis · commit 121ee19f1e8e · 2025-08-11T10:36:10.000Z
diff --git a/src/managed/API/Plugin.cs b/src/managed/API/Plugin.cs
@@ -27,7 +27,7 @@ public void Initialize(IntPtr ctx)
             PluginContext = ctx;
             Cacher.PrepareCache();
             Console.SetOut(new Scripting.ConsoleWriter(Console.Out));
-            Events.Listener.StartListening();
+            EventsListener.StartListening();
 
             RegisterEventAttribute();
             RegisterCommandAttribute();
diff --git a/src/managed/API/SDK/CS2/Classes.cs b/src/managed/API/SDK/CS2/Classes.cs
diff --git a/src/managed/API/Scripting/Configuration.cs b/src/managed/API/Scripting/Configuration.cs
@@ -21,10 +21,14 @@ public static bool Exists(string key)
             InitializeContext();
             return Internal_API.Invoker.CallNative<bool>("Configuration", "Exists", Internal_API.CallKind.CoreClassFunction, _ctx, key);
         }
-        public static T? Fetch<T>(string key)
+        public static unsafe T? Fetch<T>(string key)
         {
             InitializeContext();
-            return Internal_API.Invoker.CallNative<T>("Configuration", "Fetch", Internal_API.CallKind.CoreClassFunction, _ctx, key);
+            IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Configuration", "Fetch", Internal_API.CallKind.CoreClassFunction, _ctx, key);
+            byte* p = (byte*)val;
+            byte* tp = (byte*)&p;
+            Type t = typeof(T);
+            return (T?)CallContext.ReadValue(ref t, ref tp);
         }
         public static int FetchArraySize(string key)
         {
diff --git a/src/managed/API/Scripting/Convars.cs b/src/managed/API/Scripting/Convars.cs
@@ -46,10 +46,14 @@ public static bool ExistsFake(string name)
             InitializeContext();
             return Internal_API.Invoker.CallNative<bool>("Convars", "ExistsFake", Internal_API.CallKind.CoreClassFunction, _ctx, name);
         }
-        public static T? Get<T>(string name)
+        public static unsafe T? Get<T>(string name)
         {
             InitializeContext();
-            return Internal_API.Invoker.CallNative<T>("Convars", "Get", Internal_API.CallKind.CoreClassFunction, _ctx, name);
+            IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Convars", "Get", Internal_API.CallKind.CoreClassFunction, _ctx, name);
+            byte* p = (byte*)val;
+            byte* tp = (byte*)&p;
+            Type t = typeof(T);
+            return (T?)CallContext.ReadValue(ref t, ref tp);
         }
         public static long GetFlags(string name)
         {
diff --git a/src/managed/API/Scripting/Database.cs b/src/managed/API/Scripting/Database.cs
@@ -30,7 +30,7 @@ private static void InitializeContext()
 
         public class DB : ClassData
         {
-            public DB(string connection_name): base(Internal_API.Invoker.CallNative<IntPtr>("DB", "DB", CallKind.ClassFunction, connection_name))
+            public DB(string connection_name, bool? skip_default_connection): base(Internal_API.Invoker.CallNative<IntPtr>("DB", "DB", CallKind.ClassFunction, connection_name, skip_default_connection))
             {
                 InitializeContext();
             }
diff --git a/src/managed/API/Scripting/Events.cs b/src/managed/API/Scripting/Events.cs
@@ -81,11 +81,12 @@ public static List<EventHandler> GetEventCallbacks(string event_name)
 
         public static unsafe (EventResult, Event) TriggerEvent(string event_name, params object[] args)
         {
-            IntPtr[] a = Invoker.CallNative<IntPtr[]>("_G", "TriggerEventInternal", CallKind.Function, event_name, JsonSerializer.Serialize(args));
+            IntPtr[] a = Invoker.CallNative<IntPtr[]>("_G", "TriggerEventInternal", CallKind.Function, event_name, JsonSerializer.Serialize(args)) ?? [IntPtr.Zero, IntPtr.Zero];
 
             byte* p = (byte*)a[0];
+            byte* pptr = (byte*)&p;
             Type evResult = typeof(EventResult);
-            EventResult res = (EventResult)CallContext.ReadValue(ref evResult, ref p);
+            EventResult res = (EventResult)CallContext.ReadValue(ref evResult, ref pptr);
             Event ev = new(a[1]);
 
             return (res, ev);
@@ -154,9 +155,13 @@ public string GetString(string key)
             {
                 return Internal_API.Invoker.CallNative<string>("Event", "GetString", Internal_API.CallKind.ClassFunction, m_classData, key) ?? "";
             }
-            public T? GetReturn<T>()
+            public unsafe T? GetReturn<T>()
             {
-                return Internal_API.Invoker.CallNative<T>("Event", "GetReturn", Internal_API.CallKind.ClassFunction, m_classData);
+                IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Event", "GetReturn", Internal_API.CallKind.ClassFunction, m_classData);
+                byte* p = (byte*)val;
+                byte* tp = (byte*)&p;
+                Type t = typeof(T);
+                return (T?)CallContext.ReadValue(ref t, ref tp);
             }
             public void SetReturn(object value)
             {
@@ -242,9 +247,13 @@ public Memory GetHookPointer(uint index)
             {
                 return Internal_API.Invoker.CallNative<Memory>("Event", "GetHookPointer", Internal_API.CallKind.ClassFunction, m_classData, index) ?? new();
             }
-            public T? GetHookReturn<T>()
+            public unsafe T? GetHookReturn<T>()
             {
-                return Internal_API.Invoker.CallNative<T>("Event", "GetHookReturn", Internal_API.CallKind.ClassFunction, m_classData);
+                IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Event", "GetHookReturn", Internal_API.CallKind.ClassFunction, m_classData);
+                byte* p = (byte*)val;
+                byte* tp = (byte*)&p;
+                Type t = typeof(T);
+                return (T?)CallContext.ReadValue(ref t, ref tp);
             }
             public void SetHookReturn(object value)
             {
diff --git a/src/managed/API/Scripting/Exports.cs b/src/managed/API/Scripting/Exports.cs
@@ -18,7 +18,7 @@ public static void Call(string plugin_name, string name, params object[] args)
             var output = Events.TriggerEvent($"export:{plugin_name}:{name}", args);
             if (output.Item1 != EventResult.Stop)
             {
-                Console.WriteLine($"Export '{name}' is '{plugin_name}' doesn't exists.");
+                Console.WriteLine($"Export '{name}' in '{plugin_name}' doesn't exists.");
             }
         }
 
@@ -27,7 +27,7 @@ public static void Call(string plugin_name, string name, params object[] args)
             var output = Events.TriggerEvent($"export:{plugin_name}:{name}", args);
             if (output.Item1 != EventResult.Stop)
             {
-                Console.WriteLine($"Export '{name}' is '{plugin_name}' doesn't exists.");
+                Console.WriteLine($"Export '{name}' in '{plugin_name}' doesn't exists.");
             }
             return output.Item2.GetReturn<T>();
         }
diff --git a/src/managed/API/Scripting/Hooks.cs b/src/managed/API/Scripting/Hooks.cs
@@ -63,10 +63,14 @@ public static void CallHook(HookHandler hookHandler, params object[] args)
             Invoker.CallNative("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);
         }
 
-        public static T? CallHook<T>(HookHandler hookHandler, params object[] args)
+        public static unsafe T? CallHook<T>(HookHandler hookHandler, params object[] args)
         {
             InitializeContext();
-            return Invoker.CallNative<T>("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);
+            IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);
+            byte* p = (byte*)val;
+            byte* tp = (byte*)&p;
+            Type t = typeof(T);
+            return (T?)CallContext.ReadValue(ref t, ref tp);
         }
     }
 }
diff --git a/src/managed/API/Scripting/Player.cs b/src/managed/API/Scripting/Player.cs
@@ -107,9 +107,13 @@ public string GetSteamID2()
             
             return Internal_API.Invoker.CallNative<string>("Player", "GetSteamID2", Internal_API.CallKind.ClassFunction, m_classData) ?? "";
         }
-        public T? GetVar<T>(string key)
+        public unsafe T? GetVar<T>(string key)
         {
-            return Internal_API.Invoker.CallNative<T>("Player", "GetVar", Internal_API.CallKind.ClassFunction, m_classData, key);
+            IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Player", "GetVar", Internal_API.CallKind.CoreClassFunction, m_classData, key);
+            byte* p = (byte*)val;
+            byte* tp = (byte*)&p;
+            Type t = typeof(T);
+            return (T?)CallContext.ReadValue(ref t, ref tp);
         }
         public ulong GetVoiceFlags()
         {
diff --git a/src/managed/Internal_API/CallContext.cs b/src/managed/Internal_API/CallContext.cs
@@ -141,10 +141,14 @@ public unsafe CallContext(CallData* data)
         private readonly object ms_lock = new();
         internal object Lock => ms_lock;
         internal bool isCleanupLocked = false;
+        internal int lockedCount = 0;
 
         public void SetCleanupLock(bool state)
         {
-            isCleanupLocked = state;
+            if (state) lockedCount++;
+            else lockedCount--;
+
+            isCleanupLocked = (lockedCount > 0);
         }
 
         public void Reset()
@@ -629,17 +633,17 @@ internal unsafe object GetArgument(Type type, int index)
         }
 
         [SecuritySafeCritical]
-        public T GetReturn<T>()
+        public T? GetReturn<T>()
         {
-            return (T)GetReturn(typeof(T));
+            return (T?)GetReturn(typeof(T));
         }
 
         [SecurityCritical]
-        internal unsafe object GetReturn(Type type)
+        internal unsafe object? GetReturn(Type type)
         {
             fixed (CallData* data = &m_cdata)
             {
-                if (data->has_return == 0) return null;
+                if (data->has_return == 0) return Activator.CreateInstance(type);
                 byte* p = data->return_value;
                 return ReadValue(ref type, ref p);
             }
@@ -655,7 +659,8 @@ public static unsafe object ReadValue(ref Type type, ref byte* ptr)
                 StringData* data = (StringData*)p;
 
                 if (data->len == 0) return "";
-                return Encoding.UTF8.GetString(new ReadOnlySpan<byte>(data->ptr, data->len));
+                string outs = Encoding.UTF8.GetString(new ReadOnlySpan<byte>(data->ptr, data->len));
+                return outs;
             }
             else if(type == typeof(ClassData) || typeof(ClassData).IsAssignableFrom(type))
             {
@@ -739,8 +744,7 @@ public static unsafe object ReadValue(ref Type type, ref byte* ptr)
             }
             else if(type == typeof(IntPtr))
             {
-                ref byte start = ref ptr[0];
-                return Unsafe.ReadUnaligned<IntPtr>(ref start);
+                return *(IntPtr*)ptr;
             }
 
             return ReadPointerToPrimitive(ref ptr, ref type);
diff --git a/src/managed/Internal_API/EventsListener.cs b/src/managed/Internal_API/EventsListener.cs
@@ -1,16 +1,16 @@
 ﻿using System.Text.Json;
+using SwiftlyS2.API;
 using SwiftlyS2.API.Scripting;
-using SwiftlyS2.Internal_API;
 
-namespace SwiftlyS2.API.Events
+namespace SwiftlyS2.Internal_API
 {
-    static class Listener
+    static class EventsListener
     {
-        private static unsafe EventResult CallEventHandlers(ref List<Scripting.EventHandler> events, Scripting.Events.Event ev, ref IntPtr[] args)
+        private static unsafe EventResult CallEventHandlers(ref List<API.Scripting.EventHandler> events, API.Scripting.Events.Event ev, ref nint[] args)
         {
             for (int i = 0; i < events.Count; i++)
             {
-                Scripting.EventHandler eventInfo = events[i];
+                API.Scripting.EventHandler eventInfo = events[i];
 
                 var functionParams = eventInfo.Parameters;
 
@@ -30,11 +30,11 @@ private static unsafe EventResult CallEventHandlers(ref List<Scripting.EventHand
                         if(Cacher.ConsiderTypeAPointer(ref t))
                         {
                             byte* marg = (byte*)&arg;
-                            a.Add(Internal_API.CallContext.ReadValue(ref t, ref marg));
+                            a.Add(CallContext.ReadValue(ref t, ref marg));
                         }
                         else
                         {
-                            a.Add(Internal_API.CallContext.ReadValue(ref t, ref arg));
+                            a.Add(CallContext.ReadValue(ref t, ref arg));
                         }
                     }
                     returnValue = eventInfo.Callback(eventInfo.TargetInstance, a.ToArray()) ?? EventResult.Continue;
@@ -48,11 +48,11 @@ private static unsafe EventResult CallEventHandlers(ref List<Scripting.EventHand
             return EventResult.Continue;
         }
 
-        private static EventResult CallEventHandlersJSON(ref List<Scripting.EventHandler> events, Scripting.Events.Event ev, ref object[] args)
+        private static EventResult CallEventHandlersJSON(ref List<API.Scripting.EventHandler> events, API.Scripting.Events.Event ev, ref object[] args)
         {
             for (int i = 0; i < events.Count; i++)
             {
-                Scripting.EventHandler eventInfo = events[i];
+                API.Scripting.EventHandler eventInfo = events[i];
 
                 var functionParams = eventInfo.Parameters;
                 List<object> a = [ev];
@@ -71,35 +71,35 @@ public static unsafe void StartListening()
         {
             FunctionCallers.AddFunctionCaller(Plugin.PluginContext, "AddGlobalEvents", (ctx) =>
             {
-                IntPtr eventObject = ctx.GetArgument<IntPtr>(0);
+                nint eventObject = ctx.GetArgument<nint>(0);
                 string eventName = ctx.GetArgument<string>(1);
-                IntPtr[] arguments = ctx.GetArgument<IntPtr[]>(2);
+                nint[] arguments = ctx.GetArgument<nint[]>(2);
 
-                List<Scripting.EventHandler> callbacks = Scripting.Events.GetEventCallbacks(eventName);
+                List<API.Scripting.EventHandler> callbacks = API.Scripting.Events.GetEventCallbacks(eventName);
                 if (callbacks.Count == 0)
                 {
                     ctx.SetReturn(EventResult.Continue);
                     return;
                 }
 
-                ctx.SetReturn(CallEventHandlers(ref callbacks, new Scripting.Events.Event(eventObject), ref arguments));
+                ctx.SetReturn(CallEventHandlers(ref callbacks, new API.Scripting.Events.Event(eventObject), ref arguments));
             });
 
             FunctionCallers.AddFunctionCaller(Plugin.PluginContext, "AddGlobalEventsJSON", (ctx) =>
             {
-                IntPtr eventObject = ctx.GetArgument<IntPtr>(0);
+                nint eventObject = ctx.GetArgument<nint>(0);
                 string eventName = ctx.GetArgument<string>(1);
                 string arguments = ctx.GetArgument<string>(2);
                 object[] parsedArgs = JsonSerializer.Deserialize<object[]>(arguments) ?? [];
 
-                List<Scripting.EventHandler> callbacks = Scripting.Events.GetEventCallbacks(eventName);
+                List<API.Scripting.EventHandler> callbacks = API.Scripting.Events.GetEventCallbacks(eventName);
                 if (callbacks.Count == 0)
                 {
                     ctx.SetReturn(EventResult.Continue);
                     return;
                 }
 
-                ctx.SetReturn(CallEventHandlersJSON(ref callbacks, new Scripting.Events.Event(eventObject), ref parsedArgs));
+                ctx.SetReturn(CallEventHandlersJSON(ref callbacks, new API.Scripting.Events.Event(eventObject), ref parsedArgs));
             });
 
             Invoker.CallNative("_G", "AddGlobalEvents", CallKind.Function, "AddGlobalEvents");
diff --git a/src/managed/Plugins/Context.cs b/src/managed/Plugins/Context.cs
@@ -3,6 +3,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using SwiftlyS2.API;
 using SwiftlyS2.API.Scripting;
+using SwiftlyS2.Internal_API;
 using static SwiftlyS2.API.Scripting.Events;
 
 namespace SwiftlyS2.Plugins

Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,14 @@ public static bool Exists(string key)`
`21`	`21`	`InitializeContext();`
`22`	`22`	`return Internal_API.Invoker.CallNative<bool>("Configuration", "Exists", Internal_API.CallKind.CoreClassFunction, _ctx, key);`
`23`	`23`	`}`
`24`		`- public static T? Fetch<T>(string key)`
	`24`	`+ public static unsafe T? Fetch<T>(string key)`
`25`	`25`	`{`
`26`	`26`	`InitializeContext();`
`27`		`- return Internal_API.Invoker.CallNative<T>("Configuration", "Fetch", Internal_API.CallKind.CoreClassFunction, _ctx, key);`
	`27`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Configuration", "Fetch", Internal_API.CallKind.CoreClassFunction, _ctx, key);`
	`28`	`+ byte* p = (byte*)val;`
	`29`	`+ byte* tp = (byte*)&p;`
	`30`	`+ Type t = typeof(T);`
	`31`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`28`	`32`	`}`
`29`	`33`	`public static int FetchArraySize(string key)`
`30`	`34`	`{`
Original file line number	Diff line number	Diff line change
`@@ -46,10 +46,14 @@ public static bool ExistsFake(string name)`
`46`	`46`	`InitializeContext();`
`47`	`47`	`return Internal_API.Invoker.CallNative<bool>("Convars", "ExistsFake", Internal_API.CallKind.CoreClassFunction, _ctx, name);`
`48`	`48`	`}`
`49`		`- public static T? Get<T>(string name)`
	`49`	`+ public static unsafe T? Get<T>(string name)`
`50`	`50`	`{`
`51`	`51`	`InitializeContext();`
`52`		`- return Internal_API.Invoker.CallNative<T>("Convars", "Get", Internal_API.CallKind.CoreClassFunction, _ctx, name);`
	`52`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Convars", "Get", Internal_API.CallKind.CoreClassFunction, _ctx, name);`
	`53`	`+ byte* p = (byte*)val;`
	`54`	`+ byte* tp = (byte*)&p;`
	`55`	`+ Type t = typeof(T);`
	`56`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`53`	`57`	`}`
`54`	`58`	`public static long GetFlags(string name)`
`55`	`59`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ private static void InitializeContext()`
`30`	`30`
`31`	`31`	`public class DB : ClassData`
`32`	`32`	`{`
`33`		`- public DB(string connection_name): base(Internal_API.Invoker.CallNative<IntPtr>("DB", "DB", CallKind.ClassFunction, connection_name))`
	`33`	`+ public DB(string connection_name, bool? skip_default_connection): base(Internal_API.Invoker.CallNative<IntPtr>("DB", "DB", CallKind.ClassFunction, connection_name, skip_default_connection))`
`34`	`34`	`{`
`35`	`35`	`InitializeContext();`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,11 +81,12 @@ public static List<EventHandler> GetEventCallbacks(string event_name)`
`81`	`81`
`82`	`82`	`public static unsafe (EventResult, Event) TriggerEvent(string event_name, params object[] args)`
`83`	`83`	`{`
`84`		`- IntPtr[] a = Invoker.CallNative<IntPtr[]>("_G", "TriggerEventInternal", CallKind.Function, event_name, JsonSerializer.Serialize(args));`
	`84`	`+ IntPtr[] a = Invoker.CallNative<IntPtr[]>("_G", "TriggerEventInternal", CallKind.Function, event_name, JsonSerializer.Serialize(args)) ?? [IntPtr.Zero, IntPtr.Zero];`
`85`	`85`
`86`	`86`	`byte* p = (byte*)a[0];`
	`87`	`+ byte* pptr = (byte*)&p;`
`87`	`88`	`Type evResult = typeof(EventResult);`
`88`		`- EventResult res = (EventResult)CallContext.ReadValue(ref evResult, ref p);`
	`89`	`+ EventResult res = (EventResult)CallContext.ReadValue(ref evResult, ref pptr);`
`89`	`90`	`Event ev = new(a[1]);`
`90`	`91`
`91`	`92`	`return (res, ev);`
`@@ -154,9 +155,13 @@ public string GetString(string key)`
`154`	`155`	`{`
`155`	`156`	`return Internal_API.Invoker.CallNative<string>("Event", "GetString", Internal_API.CallKind.ClassFunction, m_classData, key) ?? "";`
`156`	`157`	`}`
`157`		`- public T? GetReturn<T>()`
	`158`	`+ public unsafe T? GetReturn<T>()`
`158`	`159`	`{`
`159`		`- return Internal_API.Invoker.CallNative<T>("Event", "GetReturn", Internal_API.CallKind.ClassFunction, m_classData);`
	`160`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Event", "GetReturn", Internal_API.CallKind.ClassFunction, m_classData);`
	`161`	`+ byte* p = (byte*)val;`
	`162`	`+ byte* tp = (byte*)&p;`
	`163`	`+ Type t = typeof(T);`
	`164`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`160`	`165`	`}`
`161`	`166`	`public void SetReturn(object value)`
`162`	`167`	`{`
`@@ -242,9 +247,13 @@ public Memory GetHookPointer(uint index)`
`242`	`247`	`{`
`243`	`248`	`return Internal_API.Invoker.CallNative<Memory>("Event", "GetHookPointer", Internal_API.CallKind.ClassFunction, m_classData, index) ?? new();`
`244`	`249`	`}`
`245`		`- public T? GetHookReturn<T>()`
	`250`	`+ public unsafe T? GetHookReturn<T>()`
`246`	`251`	`{`
`247`		`- return Internal_API.Invoker.CallNative<T>("Event", "GetHookReturn", Internal_API.CallKind.ClassFunction, m_classData);`
	`252`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Event", "GetHookReturn", Internal_API.CallKind.ClassFunction, m_classData);`
	`253`	`+ byte* p = (byte*)val;`
	`254`	`+ byte* tp = (byte*)&p;`
	`255`	`+ Type t = typeof(T);`
	`256`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`248`	`257`	`}`
`249`	`258`	`public void SetHookReturn(object value)`
`250`	`259`	`{`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public static void Call(string plugin_name, string name, params object[] args)`
`18`	`18`	`var output = Events.TriggerEvent($"export:{plugin_name}:{name}", args);`
`19`	`19`	`if (output.Item1 != EventResult.Stop)`
`20`	`20`	`{`
`21`		`- Console.WriteLine($"Export '{name}' is '{plugin_name}' doesn't exists.");`
	`21`	`+ Console.WriteLine($"Export '{name}' in '{plugin_name}' doesn't exists.");`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`@@ -27,7 +27,7 @@ public static void Call(string plugin_name, string name, params object[] args)`
`27`	`27`	`var output = Events.TriggerEvent($"export:{plugin_name}:{name}", args);`
`28`	`28`	`if (output.Item1 != EventResult.Stop)`
`29`	`29`	`{`
`30`		`- Console.WriteLine($"Export '{name}' is '{plugin_name}' doesn't exists.");`
	`30`	`+ Console.WriteLine($"Export '{name}' in '{plugin_name}' doesn't exists.");`
`31`	`31`	`}`
`32`	`32`	`return output.Item2.GetReturn<T>();`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,10 +63,14 @@ public static void CallHook(HookHandler hookHandler, params object[] args)`
`63`	`63`	`Invoker.CallNative("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);`
`64`	`64`	`}`
`65`	`65`
`66`		`- public static T? CallHook<T>(HookHandler hookHandler, params object[] args)`
	`66`	`+ public static unsafe T? CallHook<T>(HookHandler hookHandler, params object[] args)`
`67`	`67`	`{`
`68`	`68`	`InitializeContext();`
`69`		`- return Invoker.CallNative<T>("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);`
	`69`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Hooks", "Call", Internal_API.CallKind.CoreClassFunction, _ctx, hookHandler.HookId, (object)args);`
	`70`	`+ byte* p = (byte*)val;`
	`71`	`+ byte* tp = (byte*)&p;`
	`72`	`+ Type t = typeof(T);`
	`73`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`70`	`74`	`}`
`71`	`75`	`}`
`72`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,9 +107,13 @@ public string GetSteamID2()`
`107`	`107`
`108`	`108`	`return Internal_API.Invoker.CallNative<string>("Player", "GetSteamID2", Internal_API.CallKind.ClassFunction, m_classData) ?? "";`
`109`	`109`	`}`
`110`		`- public T? GetVar<T>(string key)`
	`110`	`+ public unsafe T? GetVar<T>(string key)`
`111`	`111`	`{`
`112`		`- return Internal_API.Invoker.CallNative<T>("Player", "GetVar", Internal_API.CallKind.ClassFunction, m_classData, key);`
	`112`	`+ IntPtr val = Internal_API.Invoker.CallNative<IntPtr>("Player", "GetVar", Internal_API.CallKind.CoreClassFunction, m_classData, key);`
	`113`	`+ byte* p = (byte*)val;`
	`114`	`+ byte* tp = (byte*)&p;`
	`115`	`+ Type t = typeof(T);`
	`116`	`+ return (T?)CallContext.ReadValue(ref t, ref tp);`
`113`	`117`	`}`
`114`	`118`	`public ulong GetVoiceFlags()`
`115`	`119`	`{`
Original file line number	Diff line number	Diff line change
`@@ -141,10 +141,14 @@ public unsafe CallContext(CallData* data)`
`141`	`141`	`private readonly object ms_lock = new();`
`142`	`142`	`internal object Lock => ms_lock;`
`143`	`143`	`internal bool isCleanupLocked = false;`
	`144`	`+ internal int lockedCount = 0;`
`144`	`145`
`145`	`146`	`public void SetCleanupLock(bool state)`
`146`	`147`	`{`
`147`		`- isCleanupLocked = state;`
	`148`	`+ if (state) lockedCount++;`
	`149`	`+ else lockedCount--;`
	`150`	`+`
	`151`	`+ isCleanupLocked = (lockedCount > 0);`
`148`	`152`	`}`
`149`	`153`
`150`	`154`	`public void Reset()`
`@@ -629,17 +633,17 @@ internal unsafe object GetArgument(Type type, int index)`
`629`	`633`	`}`
`630`	`634`
`631`	`635`	`[SecuritySafeCritical]`
`632`		`- public T GetReturn<T>()`
	`636`	`+ public T? GetReturn<T>()`
`633`	`637`	`{`
`634`		`- return (T)GetReturn(typeof(T));`
	`638`	`+ return (T?)GetReturn(typeof(T));`
`635`	`639`	`}`
`636`	`640`
`637`	`641`	`[SecurityCritical]`
`638`		`- internal unsafe object GetReturn(Type type)`
	`642`	`+ internal unsafe object? GetReturn(Type type)`
`639`	`643`	`{`
`640`	`644`	`fixed (CallData* data = &m_cdata)`
`641`	`645`	`{`
`642`		`- if (data->has_return == 0) return null;`
	`646`	`+ if (data->has_return == 0) return Activator.CreateInstance(type);`
`643`	`647`	`byte* p = data->return_value;`
`644`	`648`	`return ReadValue(ref type, ref p);`
`645`	`649`	`}`
`@@ -655,7 +659,8 @@ public static unsafe object ReadValue(ref Type type, ref byte* ptr)`
`655`	`659`	`StringData* data = (StringData*)p;`
`656`	`660`
`657`	`661`	`if (data->len == 0) return "";`
`658`		`- return Encoding.UTF8.GetString(new ReadOnlySpan<byte>(data->ptr, data->len));`
	`662`	`+ string outs = Encoding.UTF8.GetString(new ReadOnlySpan<byte>(data->ptr, data->len));`
	`663`	`+ return outs;`
`659`	`664`	`}`
`660`	`665`	`else if(type == typeof(ClassData) \|\| typeof(ClassData).IsAssignableFrom(type))`
`661`	`666`	`{`
`@@ -739,8 +744,7 @@ public static unsafe object ReadValue(ref Type type, ref byte* ptr)`
`739`	`744`	`}`
`740`	`745`	`else if(type == typeof(IntPtr))`
`741`	`746`	`{`
`742`		`- ref byte start = ref ptr[0];`
`743`		`- return Unsafe.ReadUnaligned<IntPtr>(ref start);`
	`747`	`+ return (IntPtr)ptr;`
`744`	`748`	`}`
`745`	`749`
`746`	`750`	`return ReadPointerToPrimitive(ref ptr, ref type);`