Merge pull request #58 from ELDment/beta-2

Author: skuzzis

managed/src/SwiftlyS2.Core/Modules/Engine/CommandTrackerManager.cs

@@ -1,10 +1,8 @@
 using System.Text;
 using System.Collections.Concurrent;
 using Spectre.Console;
-using SwiftlyS2.Shared;
 using SwiftlyS2.Shared.Misc;
 using SwiftlyS2.Shared.Events;
-using SwiftlyS2.Shared.Services;
 
 namespace SwiftlyS2.Core.Services;
 
@@ -27,25 +25,20 @@ private readonly record struct ExecutingCommand(Action<string> Callback)
     private readonly CancellationTokenSource cancellationTokenSource = new();
     private readonly ConcurrentQueue<Action<string>> pendingCallbacks = new();
     private volatile bool disposed;
-    private volatile bool eventsSubscribed;
 
     public CommandTrackerManager()
     {
-        eventsSubscribed = false;
-
         StartCleanupTimer();
     }
 
     public void ProcessCommand(IOnCommandExecuteHookEvent @event)
     {
-        if (string.IsNullOrEmpty(@event.OriginalName) || !@event.OriginalName.StartsWith("^wb^"))
-        {
-            Interlocked.Exchange(ref currentCommandContainer, CommandIdContainer.Empty);
-            return;
-        }
-
         if (@event.HookMode == HookMode.Pre)
         {
+            if (string.IsNullOrWhiteSpace(@event.Command[0]) || !@event.Command[0]!.StartsWith("^wb^"))
+            {
+                return;
+            }
             ProcessCommandStart(@event);
         }
         else if (@event.HookMode == HookMode.Post)
@@ -78,7 +71,7 @@ public void ProcessCommandStart(IOnCommandExecuteHookEvent @event)
             {
                 var newContainer = new CommandIdContainer(newCommandId);
                 Interlocked.Exchange(ref currentCommandContainer, newContainer);
-                @event.SetCommandName(@event.OriginalName.Replace("^wb^", string.Empty));
+                @event.Command.Tokenize($"{@event.Command[0]!.Replace("^wb^", string.Empty)} {@event.Command.ArgS}");
             }
         }
         else
@@ -87,7 +80,7 @@ public void ProcessCommandStart(IOnCommandExecuteHookEvent @event)
         }
     }
 
-    public void ProcessCommandEnd(IOnCommandExecuteHookEvent @event)
+    public void ProcessCommandEnd(IOnCommandExecuteHookEvent _)
     {
         var previousContainer = Interlocked.Exchange(ref currentCommandContainer, CommandIdContainer.Empty);
         var commandId = previousContainer?.Value ?? Guid.Empty;
@@ -101,10 +94,7 @@ public void ProcessCommandEnd(IOnCommandExecuteHookEvent @event)
                 output.Append(line);
             }
 
-            Task.Run(() =>
-            {
-                command.Callback.Invoke(output.ToString());
-            });
+            Task.Run(() => command.Callback.Invoke(output.ToString()));
         }
     }
 
@@ -119,7 +109,8 @@ private void StartCleanupTimer()
                     await Task.Delay(TimeSpan.FromMilliseconds(200), cancellationTokenSource.Token);
                     CleanupExpiredCommands();
                 }
-                catch (Exception ex) { 
+                catch (Exception ex)
+                {
                     AnsiConsole.WriteException(ex);
                 }
             }

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

@@ -1,21 +1,20 @@
 using SwiftlyS2.Shared.Misc;
 using SwiftlyS2.Shared.Events;
+using SwiftlyS2.Shared.Natives;
 
 namespace SwiftlyS2.Core.Events;
 
 internal class OnCommandExecuteHookEvent : IOnCommandExecuteHookEvent
 {
-  public required string OriginalName { get; init; }
-  public required string[] OriginalArgs { get; init; }
-  public string CommandName { get; set; } = string.Empty;
+  private CCommand _command;
 
-  public required HookMode HookMode { get; init; }
+  public ref CCommand Command => ref _command;
 
-  public bool Intercepted { get; set; } = false;
+  public HookMode HookMode { get; init; }
 
-  public void SetCommandName(string name) {
-    if (HookMode == HookMode.Post) return;
-    CommandName = name;
-    Intercepted = true;
+  public OnCommandExecuteHookEvent(ref CCommand command, HookMode hookMode)
+  {
+    _command = command;
+    HookMode = hookMode;
   }
 }

managed/src/SwiftlyS2.Core/Services/CoreHookService.cs

@@ -9,6 +9,7 @@
 using SwiftlyS2.Shared.Memory;
 using SwiftlyS2.Shared.Misc;
 using SwiftlyS2.Shared.SchemaDefinitions;
+using SwiftlyS2.Shared.Natives;
 
 namespace SwiftlyS2.Core.Services;
 
@@ -103,66 +104,28 @@ private void HookCommandExecute()
     var address = _Core.GameData.GetSignature("Cmd_ExecuteCommand");
 
     _Logger.LogInformation("Hooking Cmd_ExecuteCommand at {Address}", address);
-    var commandNameOffset = NativeOffsets.Fetch("CommandNameOffset");
-    var commandArgsOffset = NativeOffsets.Fetch("CommandArgsOffset");
 
     _ExecuteCommand = _Core.Memory.GetUnmanagedFunctionByAddress<ExecuteCommandDelegate>(address);
     _ExecuteCommandGuid = _ExecuteCommand.AddHook((next) =>
     {
       return (a1, a2, a3, a4, a5) =>
       {
-        var commandName = (a5 != nint.Zero && a5 < nint.MaxValue && commandNameOffset != 0) switch
+        unsafe
         {
-          true when Marshal.ReadIntPtr(new nint(a5 + commandNameOffset)) is var basePtr && basePtr != nint.Zero && basePtr < nint.MaxValue
-            => Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(basePtr)) ?? string.Empty,
-          _ => string.Empty
-        };
-        var commandArgs = (a5 != nint.Zero && a5 < nint.MaxValue && commandArgsOffset != 0) switch
-        {
-          true => Marshal.PtrToStringAnsi(new nint(a5 + commandArgsOffset)) ?? string.Empty,
-          _ => string.Empty
-        };
-
-        var argsSplit = commandArgs.Split(' ', StringSplitOptions.RemoveEmptyEntries);
-        var args = argsSplit.Length > 1 ? argsSplit[1..] : [];
-
-        var preEvent = new OnCommandExecuteHookEvent
-        {
-          OriginalName = commandName,
-          OriginalArgs = args,
-          HookMode = HookMode.Pre
-        };
-        EventPublisher.InvokeOnCommandExecuteHook(preEvent);
-
-        nint newCommandNamePtr = nint.Zero;
-
-        if (preEvent.Intercepted && preEvent.CommandName.Length < commandName.Length)
-        {
-          var newCommandName = Encoding.UTF8.GetBytes(preEvent.CommandName);
-
-          newCommandNamePtr = NativeAllocator.Alloc((ulong)(newCommandName.Length + 1));
-          newCommandNamePtr.Write(newCommandName.Length, 0);
-
-          newCommandNamePtr.CopyFrom(newCommandName);
-          (a5 + commandNameOffset).Read<nint>().Write(newCommandNamePtr);
-        }
-
-        var result = next()(a1, a2, a3, a4, a5);
+          if (a5 != nint.Zero)
+          {
+            ref var command = ref Unsafe.AsRef<CCommand>((void*)a5);
+            var @eventPre = new OnCommandExecuteHookEvent(ref command, HookMode.Pre);
+            EventPublisher.InvokeOnCommandExecuteHook(@eventPre);
 
-        var postEvent = new OnCommandExecuteHookEvent
-        {
-          OriginalName = commandName,
-          OriginalArgs = args,
-          HookMode = HookMode.Post
-        };
-        EventPublisher.InvokeOnCommandExecuteHook(postEvent);
+            var result = next()(a1, a2, a3, a4, a5);
 
-        if (newCommandNamePtr != nint.Zero)
-        {
-          NativeAllocator.Free(newCommandNamePtr);
+            var @eventPost = new OnCommandExecuteHookEvent(ref command, HookMode.Post);
+            EventPublisher.InvokeOnCommandExecuteHook(@eventPost);
+            return result;
+          }
+          return next()(a1, a2, a3, a4, a5);
         }
-
-        return result;
       };
     });
   }

managed/src/SwiftlyS2.Shared/Modules/Events/EventParams/IOnCommandExecuteHookEvent.cs

@@ -1,31 +1,20 @@
 using SwiftlyS2.Shared.Misc;
+using SwiftlyS2.Shared.Natives;
 
 namespace SwiftlyS2.Shared.Events;
 
 /// <summary>
 /// Called when a command is executed.
 /// </summary>
-public interface IOnCommandExecuteHookEvent {
-
-  /// <summary>
-  /// The original command name.
-  /// </summary>
-  public string OriginalName { get; }
-
+public interface IOnCommandExecuteHookEvent
+{
   /// <summary>
-  /// The original command arguments.
+  /// The command.
   /// </summary>
-  public string[] OriginalArgs { get; }
+  public ref CCommand Command { get; }
 
   /// <summary>
-  /// The command arguments.
+  /// The hook mode.
   /// </summary>
   public HookMode HookMode { get; }
-
-  /// <summary>
-  /// Intercept and modify the command name.
-  /// This will modify the command name and stop the following hooks and original function.
-  /// </summary>
-  /// <param name="name">The name to modify.</param>
-  public void SetCommandName(string name);
 }