update(natives): Make methods sync

skuzzis · skuzzis · commit 4101d31699a6 · 2025-12-02T23:57:53.000+02:00
diff --git a/managed/src/SwiftlyS2.Generated/Natives/Commands.cs b/managed/src/SwiftlyS2.Generated/Natives/Commands.cs
@@ -17,6 +17,9 @@ internal static class NativeCommands {
   /// 1 -> not silent, 2 -> silent, -1 -> invalid player, 0 -> no command
   /// </summary>
   public unsafe static int HandleCommandForPlayer(int playerid, string command) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var commandLength = Encoding.UTF8.GetByteCount(command);
     var commandBuffer = pool.Rent(commandLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/Convars.cs b/managed/src/SwiftlyS2.Generated/Natives/Convars.cs
@@ -14,6 +14,9 @@ internal static class NativeConvars {
   private unsafe static delegate* unmanaged<int, byte*, void> _QueryClientConvar;
 
   public unsafe static void QueryClientConvar(int playerid, string cvarName) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -458,6 +461,9 @@ public unsafe static int GetConvarType(string cvarName) {
   private unsafe static delegate* unmanaged<int, byte*, byte*, void> _SetClientConvarValueString;
 
   public unsafe static void SetClientConvarValueString(int playerid, string cvarName, string defaultValue) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -494,6 +500,9 @@ public unsafe static ulong GetFlags(string cvarName) {
   private unsafe static delegate* unmanaged<byte*, ulong, void> _SetFlags;
 
   public unsafe static void SetFlags(string cvarName, ulong flags) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -568,6 +577,9 @@ public unsafe static nint GetDefaultValuePtr(string cvarName) {
   private unsafe static delegate* unmanaged<byte*, nint, void> _SetDefaultValue;
 
   public unsafe static void SetDefaultValue(string cvarName, nint defaultValue) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -582,6 +594,9 @@ public unsafe static void SetDefaultValue(string cvarName, nint defaultValue) {
   private unsafe static delegate* unmanaged<byte*, byte*, void> _SetDefaultValueString;
 
   public unsafe static void SetDefaultValueString(string cvarName, string defaultValue) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -618,6 +633,9 @@ public unsafe static nint GetValuePtr(string cvarName) {
   private unsafe static delegate* unmanaged<byte*, nint, void> _SetValuePtr;
 
   public unsafe static void SetValuePtr(string cvarName, nint value) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
@@ -632,6 +650,9 @@ public unsafe static void SetValuePtr(string cvarName, nint value) {
   private unsafe static delegate* unmanaged<byte*, nint, void> _SetValueInternalPtr;
 
   public unsafe static void SetValueInternalPtr(string cvarName, nint value) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
     var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/EngineHelpers.cs b/managed/src/SwiftlyS2.Generated/Natives/EngineHelpers.cs
@@ -46,6 +46,9 @@ public unsafe static bool IsMapValid(string map_name) {
   private unsafe static delegate* unmanaged<byte*, void> _ExecuteCommand;
 
   public unsafe static void ExecuteCommand(string command) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var commandLength = Encoding.UTF8.GetByteCount(command);
     var commandBuffer = pool.Rent(commandLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/EntitySystem.cs b/managed/src/SwiftlyS2.Generated/Natives/EntitySystem.cs
@@ -14,12 +14,18 @@ internal static class NativeEntitySystem {
   private unsafe static delegate* unmanaged<nint, nint, void> _Spawn;
 
   public unsafe static void Spawn(nint entity, nint keyvalues) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _Spawn(entity, keyvalues);
   }
 
   private unsafe static delegate* unmanaged<nint, void> _Despawn;
 
   public unsafe static void Despawn(nint entity) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _Despawn(entity);
   }
 
@@ -41,6 +47,9 @@ public unsafe static nint CreateEntityByName(string name) {
   private unsafe static delegate* unmanaged<nint, byte*, nint, nint, nint, int, void> _AcceptInput;
 
   public unsafe static void AcceptInput(nint entity, string input, nint activator, nint caller, nint value, int outputID) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var inputLength = Encoding.UTF8.GetByteCount(input);
     var inputBuffer = pool.Rent(inputLength + 1);
@@ -55,6 +64,9 @@ public unsafe static void AcceptInput(nint entity, string input, nint activator,
   private unsafe static delegate* unmanaged<nint, byte*, nint, nint, nint, float, void> _AddEntityIOEvent;
 
   public unsafe static void AddEntityIOEvent(nint entity, string input, nint activator, nint caller, nint value, float delay) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var inputLength = Encoding.UTF8.GetByteCount(input);
     var inputBuffer = pool.Rent(inputLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/FileSystem.cs b/managed/src/SwiftlyS2.Generated/Natives/FileSystem.cs
@@ -35,6 +35,9 @@ public unsafe static string GetSearchPath(string pathId, int searchPathType, int
   private unsafe static delegate* unmanaged<byte*, byte*, int, int, void> _AddSearchPath;
 
   public unsafe static void AddSearchPath(string path, string pathId, int searchPathAdd, int searchPathPriority) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var pathLength = Encoding.UTF8.GetByteCount(path);
     var pathBuffer = pool.Rent(pathLength + 1);
@@ -156,6 +159,9 @@ public unsafe static string ReadFile(string fileName, string pathId) {
   private unsafe static delegate* unmanaged<byte*, byte*, byte*, byte> _WriteFile;
 
   public unsafe static bool WriteFile(string fileName, string pathId, string content) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var fileNameLength = Encoding.UTF8.GetByteCount(fileName);
     var fileNameBuffer = pool.Rent(fileNameLength + 1);
@@ -251,6 +257,9 @@ public unsafe static bool IsFileWritable(string fileName, string pathId) {
   private unsafe static delegate* unmanaged<byte*, byte*, byte, byte> _SetFileWritable;
 
   public unsafe static bool SetFileWritable(string fileName, string pathId, bool writable) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var fileNameLength = Encoding.UTF8.GetByteCount(fileName);
     var fileNameBuffer = pool.Rent(fileNameLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/GameEvents.cs b/managed/src/SwiftlyS2.Generated/Natives/GameEvents.cs
@@ -465,12 +465,18 @@ public unsafe static void FreeEvent(nint _event) {
   private unsafe static delegate* unmanaged<nint, byte, void> _FireEvent;
 
   public unsafe static void FireEvent(nint _event, bool dontBroadcast) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _FireEvent(_event, dontBroadcast ? (byte)1 : (byte)0);
   }
 
   private unsafe static delegate* unmanaged<nint, int, void> _FireEventToClient;
 
   public unsafe static void FireEventToClient(nint _event, int playerid) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _FireEventToClient(_event, playerid);
   }
 
diff --git a/managed/src/SwiftlyS2.Generated/Natives/NetMessages.cs b/managed/src/SwiftlyS2.Generated/Natives/NetMessages.cs
@@ -1123,6 +1123,9 @@ public unsafe static void ClearRepeatedField(nint netmsg, string fieldName) {
   private unsafe static delegate* unmanaged<nint, int, int, void> _SendMessage;
 
   public unsafe static void SendMessage(nint netmsg, int msgid, int playerid) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _SendMessage(netmsg, msgid, playerid);
   }
 
@@ -1132,6 +1135,9 @@ public unsafe static void SendMessage(nint netmsg, int msgid, int playerid) {
   /// each bit in player_mask represents a playerid
   /// </summary>
   public unsafe static void SendMessageToPlayers(nint netmsg, int msgid, ulong playermask) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _SendMessageToPlayers(netmsg, msgid, playermask);
   }
 
diff --git a/managed/src/SwiftlyS2.Generated/Natives/Player.cs b/managed/src/SwiftlyS2.Generated/Natives/Player.cs
@@ -14,6 +14,9 @@ internal static class NativePlayer {
   private unsafe static delegate* unmanaged<int, int, byte*, int, void> _SendMessage;
 
   public unsafe static void SendMessage(int playerid, int kind, string message, int htmlDuration) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var messageLength = Encoding.UTF8.GetByteCount(message);
     var messageBuffer = pool.Rent(messageLength + 1);
@@ -91,6 +94,9 @@ public unsafe static ulong GetPressedButtons(int playerid) {
   private unsafe static delegate* unmanaged<int, byte*, void> _PerformCommand;
 
   public unsafe static void PerformCommand(int playerid, string command) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var commandLength = Encoding.UTF8.GetByteCount(command);
     var commandBuffer = pool.Rent(commandLength + 1);
@@ -119,6 +125,9 @@ public unsafe static string GetIPAddress(int playerid) {
   private unsafe static delegate* unmanaged<int, byte*, int, void> _Kick;
 
   public unsafe static void Kick(int playerid, string reason, int gamereason) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var reasonLength = Encoding.UTF8.GetByteCount(reason);
     var reasonBuffer = pool.Rent(reasonLength + 1);
@@ -152,24 +161,36 @@ public unsafe static void ClearTransmitEntityBlocked(int playerid) {
   private unsafe static delegate* unmanaged<int, int, void> _ChangeTeam;
 
   public unsafe static void ChangeTeam(int playerid, int newteam) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _ChangeTeam(playerid, newteam);
   }
 
   private unsafe static delegate* unmanaged<int, int, void> _SwitchTeam;
 
   public unsafe static void SwitchTeam(int playerid, int newteam) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _SwitchTeam(playerid, newteam);
   }
 
   private unsafe static delegate* unmanaged<int, nint, void> _TakeDamage;
 
   public unsafe static void TakeDamage(int playerid, nint dmginfo) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _TakeDamage(playerid, dmginfo);
   }
 
   private unsafe static delegate* unmanaged<int, Vector, QAngle, Vector, void> _Teleport;
 
   public unsafe static void Teleport(int playerid, Vector pos, QAngle angle, Vector velocity) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _Teleport(playerid, pos, angle, velocity);
   }
 
@@ -217,6 +238,9 @@ public unsafe static bool HasMenuShown(int playerid) {
   private unsafe static delegate* unmanaged<int, byte*, void> _ExecuteCommand;
 
   public unsafe static void ExecuteCommand(int playerid, string command) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var commandLength = Encoding.UTF8.GetByteCount(command);
     var commandBuffer = pool.Rent(commandLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/PlayerManager.cs b/managed/src/SwiftlyS2.Generated/Natives/PlayerManager.cs
@@ -35,6 +35,9 @@ public unsafe static int GetPlayerCap() {
   private unsafe static delegate* unmanaged<int, byte*, int, void> _SendMessage;
 
   public unsafe static void SendMessage(int kind, string message, int duration) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     var pool = ArrayPool<byte>.Shared;
     var messageLength = Encoding.UTF8.GetByteCount(message);
     var messageBuffer = pool.Rent(messageLength + 1);
diff --git a/managed/src/SwiftlyS2.Generated/Natives/Schema.cs b/managed/src/SwiftlyS2.Generated/Natives/Schema.cs
@@ -14,6 +14,9 @@ internal static class NativeSchema {
   private unsafe static delegate* unmanaged<nint, ulong, void> _SetStateChanged;
 
   public unsafe static void SetStateChanged(nint entity, ulong hash) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _SetStateChanged(entity, hash);
   }
 
@@ -79,6 +82,9 @@ public unsafe static nint GetPropPtr(nint entity, ulong hash) {
   private unsafe static delegate* unmanaged<nint, ulong, nint, uint, void> _WritePropPtr;
 
   public unsafe static void WritePropPtr(nint entity, ulong hash, nint value, uint size) {
+    if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
+      throw new InvalidOperationException("This method can only be called from the main thread.");
+    }
     _WritePropPtr(entity, hash, value, size);
   }
 
diff --git a/natives/engine/convars.native b/natives/engine/convars.native
@@ -1,6 +1,6 @@
 class Convars
 
-void QueryClientConvar = int32 playerid, string cvarName
+sync void QueryClientConvar = int32 playerid, string cvarName
 int32 AddQueryClientCvarCallback = ptr callback // the callback should receive the following: int32 playerid, string cvarName, string cvarValue
 void RemoveQueryClientCvarCallback = int32 callbackID
 uint64 AddGlobalChangeListener = ptr callback // the callback should receive the following: string convarName, int playerid, string newValue, string oldValue
@@ -27,15 +27,15 @@ void CreateConvarString = string cvarName, int32 cvarType, uint64 cvarFlags, str
 void DeleteConvar = string cvarName
 bool ExistsConvar = string cvarName
 int32 GetConvarType = string cvarName
-void SetClientConvarValueString = int32 playerid, string cvarName, string defaultValue
+sync void SetClientConvarValueString = int32 playerid, string cvarName, string defaultValue
 uint64 GetFlags = string cvarName
-void SetFlags = string cvarName, uint64 flags
+sync void SetFlags = string cvarName, uint64 flags
 ptr GetMinValuePtrPtr = string cvarName
 ptr GetMaxValuePtrPtr = string cvarName
 bool HasDefaultValue = string cvarName
 ptr GetDefaultValuePtr = string cvarName
-void SetDefaultValue = string cvarName, ptr defaultValue
-void SetDefaultValueString = string cvarName, string defaultValue
+sync void SetDefaultValue = string cvarName, ptr defaultValue
+sync void SetDefaultValueString = string cvarName, string defaultValue
 ptr GetValuePtr = string cvarName
-void SetValuePtr = string cvarName, ptr value
-void SetValueInternalPtr = string cvarName, ptr value
+sync void SetValuePtr = string cvarName, ptr value
+sync void SetValueInternalPtr = string cvarName, ptr value
diff --git a/natives/engine/entitysystem.native b/natives/engine/entitysystem.native
@@ -1,10 +1,10 @@
 class EntitySystem
 
-void Spawn = ptr entity, ptr keyvalues
-void Despawn = ptr entity
+sync void Spawn = ptr entity, ptr keyvalues
+sync void Despawn = ptr entity
 ptr CreateEntityByName = string name
-void AcceptInput = ptr entity, string input, ptr activator, ptr caller, ptr value, int32 outputID
-void AddEntityIOEvent = ptr entity, string input, ptr activator, ptr caller, ptr value, float delay
+sync void AcceptInput = ptr entity, string input, ptr activator, ptr caller, ptr value, int32 outputID
+sync void AddEntityIOEvent = ptr entity, string input, ptr activator, ptr caller, ptr value, float delay
 bool IsValidEntity = ptr entity
 ptr GetGameRules = void
 ptr GetEntitySystem = void
diff --git a/natives/engine/filesystem.native b/natives/engine/filesystem.native
@@ -1,15 +1,15 @@
 class FileSystem
 
 string GetSearchPath = string pathId, int32 searchPathType, int32 searchPathsToGet
-void AddSearchPath = string path, string pathId, int32 searchPathAdd, int32 searchPathPriority
+sync void AddSearchPath = string path, string pathId, int32 searchPathAdd, int32 searchPathPriority
 bool RemoveSearchPath = string path, string pathId
 bool FileExists = string fileName, string pathId
 bool IsDirectory = string path, string pathId
 void PrintSearchPaths = void
 string ReadFile = string fileName, string pathId
-bool WriteFile = string fileName, string pathId, string content
+sync bool WriteFile = string fileName, string pathId, string content
 uint32 GetFileSize = string fileName, string pathId
 bool PrecacheFile = string fileName, string pathId
 bool IsFileWritable = string fileName, string pathId
-bool SetFileWritable = string fileName, string pathId, bool writable
+sync bool SetFileWritable = string fileName, string pathId, bool writable
 void FindFileAbsoluteList = ptr outVector, string wildcard, string pathId
diff --git a/natives/engine/gameevents.native b/natives/engine/gameevents.native
@@ -33,7 +33,7 @@ void RemoveListenerPreCallback = uint64 listenerID
 void RemoveListenerPostCallback = uint64 listenerID
 ptr CreateEvent = string eventName
 void FreeEvent = ptr _event
-void FireEvent = ptr _event, bool dontBroadcast
-void FireEventToClient = ptr _event, int32 playerid
+sync void FireEvent = ptr _event, bool dontBroadcast
+sync void FireEventToClient = ptr _event, int32 playerid
 bool IsPlayerListeningToEventName = int32 playerid, string eventName
 bool IsPlayerListeningToEvent = int32 playerid, ptr _event
diff --git a/natives/engine/helpers.native b/natives/engine/helpers.native
diff --git a/natives/network/netmessages.native b/natives/network/netmessages.native
diff --git a/natives/sdk/schema.native b/natives/sdk/schema.native
diff --git a/natives/server/commands.native b/natives/server/commands.native
diff --git a/natives/server/player.native b/natives/server/player.native
diff --git a/natives/server/playermanager.native b/natives/server/playermanager.native
