feat(commands): IsCommandRegistered

Author: skuzzis

managed/src/SwiftlyS2.Core/Modules/Commands/CommandService.cs

@@ -86,6 +86,11 @@ public void UnregisterCommand( string commandName )
         }
     }
 
+    public bool IsCommandRegistered( string commandName )
+    {
+        return NativeCommands.IsCommandRegistered(commandName);
+    }
+
     public Guid HookClientCommand( ICommandService.ClientCommandHandler handler )
     {
         var callback = new ClientCommandListenerCallback(handler, loggerFactory, profiler);

managed/src/SwiftlyS2.Generated/Natives/Commands.cs

@@ -53,6 +53,21 @@ public unsafe static void UnregisterCommand(ulong callbackID) {
     _UnregisterCommand(callbackID);
   }
 
+  private unsafe static delegate* unmanaged<byte*, byte> _IsCommandRegistered;
+
+  public unsafe static bool IsCommandRegistered(string commandName) {
+    var pool = ArrayPool<byte>.Shared;
+    var commandNameLength = Encoding.UTF8.GetByteCount(commandName);
+    var commandNameBuffer = pool.Rent(commandNameLength + 1);
+    Encoding.UTF8.GetBytes(commandName, commandNameBuffer);
+    commandNameBuffer[commandNameLength] = 0;
+    fixed (byte* commandNameBufferPtr = commandNameBuffer) {
+      var ret = _IsCommandRegistered(commandNameBufferPtr);
+      pool.Return(commandNameBuffer);
+      return ret == 1;
+    }
+  }
+
   private unsafe static delegate* unmanaged<byte*, byte*, byte, ulong> _RegisterAlias;
 
   /// <summary>

managed/src/SwiftlyS2.Shared/Modules/Commands/ICommandService.cs

@@ -57,6 +57,13 @@ public interface ICommandService
     /// <param name="commandName">The command name.</param>
     public void UnregisterCommand( string commandName );
 
+    /// <summary>
+    /// Checks if a command is registered.
+    /// </summary>
+    /// <param name="commandName">The command name.</param>
+    /// <returns>Whether the command is registered.</returns>
+    public bool IsCommandRegistered( string commandName );
+
     /// <summary>
     /// Hooks client commands, will be fired when a player sends any command.
     /// </summary>

natives/server/commands.native

@@ -3,6 +3,7 @@ class Commands
 int32 HandleCommandForPlayer = int32 playerid, string command // 1 -> not silent, 2 -> silent, -1 -> invalid player, 0 -> no command
 uint64 RegisterCommand = string commandName, ptr callback, bool registerRaw // callback should receive (int32 playerid, string arguments_list (separated by \x01), string commandName, string prefix, bool silent), if registerRaw is false, it will not put "sw_" before the command name
 void UnregisterCommand = uint64 callbackID
+bool IsCommandRegistered = string commandName
 uint64 RegisterAlias = string aliasName, string commandName, bool registerRaw // registerRaw behaves the same as on RegisterCommand, for commandName you need to also put the "sw_" prefix if the command is registered without raw mode
 void UnregisterAlias = uint64 callbackID
 uint64 RegisterClientCommandsListener = ptr callback // callback should receive: int32 playerid, string commandline, return true -> ignored, return false -> supercede

src/api/server/commands/manager.h

@@ -37,6 +37,7 @@ class IServerCommands
     // playerid, args, command_name, prefix, silent
     virtual uint64_t RegisterCommand(std::string command_name, std::function<void(int, std::vector<std::string>, std::string, std::string, bool)> handler, bool registerRaw) = 0;
     virtual void UnregisterCommand(uint64_t command_id) = 0;
+    virtual bool IsCommandRegistered(std::string command_name) = 0;
 
     virtual uint64_t RegisterAlias(std::string alias_command, std::string command_name, bool registerRaw) = 0;
     virtual void UnregisterAlias(uint64_t alias_id) = 0;

src/scripting/server/commands.cpp

@@ -65,6 +65,12 @@ void Bridge_Commands_UnregisterCommand(uint64_t callbackID)
     servercommands->UnregisterCommand(callbackID);
 }
 
+uint8_t Bridge_Commands_IsCommandRegistered(const char* commandName)
+{
+    auto servercommands = g_ifaceService.FetchInterface<IServerCommands>(SERVERCOMMANDS_INTERFACE_VERSION);
+    return servercommands->IsCommandRegistered(commandName) ? 1 : 0;
+}
+
 uint64_t Bridge_Commands_RegisterAlias(const char* alias, const char* command, bool registerRaw)
 {
     auto servercommands = g_ifaceService.FetchInterface<IServerCommands>(SERVERCOMMANDS_INTERFACE_VERSION);

src/server/commands/manager.cpp

@@ -318,6 +318,23 @@ void CServerCommands::UnregisterCommand(uint64_t commandId)
     delete conCommand;
 }
 
+bool CServerCommands::IsCommandRegistered(std::string commandName)
+{
+    std::transform(commandName.begin(), commandName.end(), commandName.begin(), ::tolower);
+    if (commandHandlers.contains(commandName))
+    {
+        return true;
+    }
+
+    commandName = "sw_" + commandName;
+    if (commandHandlers.contains(commandName))
+    {
+        return true;
+    }
+
+    return false;
+}
+
 uint64_t CServerCommands::RegisterAlias(std::string aliasCommand, std::string commandName, bool registerRaw)
 {
     std::transform(commandName.begin(), commandName.end(), commandName.begin(), ::tolower);

src/server/commands/manager.h

@@ -35,6 +35,7 @@ class CServerCommands : public IServerCommands
     // playerid, args, command_name, prefix, silent
     virtual uint64_t RegisterCommand(std::string command_name, std::function<void(int, std::vector<std::string>, std::string, std::string, bool)> handler, bool registerRaw) override;
     virtual void UnregisterCommand(uint64_t command_id) override;
+    virtual bool IsCommandRegistered(std::string command_name) override;
 
     virtual uint64_t RegisterAlias(std::string alias_command, std::string command_name, bool registerRaw) override;
     virtual void UnregisterAlias(uint64_t alias_id) override;