From 4ca46799d9295c4ea94feb7a9b330ffdd668ccd9 Mon Sep 17 00:00:00 2001 From: Space V <40030799+spacevx@users.noreply.github.com> Date: Mon, 16 Nov 2026 08:59:15 +0100 Subject: [PATCH 1/2] Port command buffer ticks, wait and execution marker filtering --- Source.Engine/CL.cs | 19 ++++++ Source.Engine/Cbuf.cs | 132 ++++++++++++++++++++++++++++++------------ Source.Engine/Cmd.cs | 26 ++++++--- 3 files changed, 131 insertions(+), 46 deletions(-) diff --git a/Source.Engine/CL.cs b/Source.Engine/CL.cs index 10bea7de..053e3c3d 100644 --- a/Source.Engine/CL.cs +++ b/Source.Engine/CL.cs @@ -1097,6 +1097,25 @@ public void Init() { ClientLeafSystem = services.GetRequiredService(); InitRecvTableMgr(); + InitExtraClientCmdCanExecuteVars(); + } + + void InitExtraClientCmdCanExecuteVars() { + Cmd cmd = services.GetRequiredService(); + cmd.AddClientCmdCanExecuteVar("cancelselect"); + cmd.AddClientCmdCanExecuteVar("spec_next"); + cmd.AddClientCmdCanExecuteVar("spec_prev"); + cmd.AddClientCmdCanExecuteVar("spec_mode"); + cmd.AddClientCmdCanExecuteVar("spec_menu"); + cmd.AddClientCmdCanExecuteVar("spec_autodirector"); + cmd.AddClientCmdCanExecuteVar("overview_zoom"); + cmd.AddClientCmdCanExecuteVar("overview_mode"); + cmd.AddClientCmdCanExecuteVar("overview_health"); + cmd.AddClientCmdCanExecuteVar("overview_names"); + cmd.AddClientCmdCanExecuteVar("overview_tracks"); + cmd.AddClientCmdCanExecuteVar("overview_locked"); + cmd.AddClientCmdCanExecuteVar("overview_alpha"); + cmd.AddClientCmdCanExecuteVar("playgamesound"); } private void InitRecvTableMgr() { diff --git a/Source.Engine/Cbuf.cs b/Source.Engine/Cbuf.cs index 4f74a1bb..4e81dcc5 100644 --- a/Source.Engine/Cbuf.cs +++ b/Source.Engine/Cbuf.cs @@ -3,12 +3,15 @@ using Microsoft.Extensions.DependencyInjection; using Source.Common.Commands; +using Source.Engine.Server; + +using System.Diagnostics; namespace Source.Engine; public class CommandBuffer { - public const int ARGS_BUFFER_LENGTH = 2 << 13; + public const int ARGS_BUFFER_LENGTH = 8192; public class Command { @@ -37,17 +40,19 @@ public bool DequeueNextCommand() { if (Commands.Count == 0) return false; - LinkedListNode? command = Commands.First; - if (command == null) + LinkedListNode? head = Commands.First; + if (head == null) return false; - Command cmd = command.Value; + Command cmd = head.Value; + if (cmd.Tick > lastTickToProcess) + return false; currentTick = cmd.Tick; if (cmd.BufferSize > 0) currentCommand.Tokenize(argsBuffer.AsSpan()[cmd.FirstArgS..(cmd.FirstArgS + cmd.BufferSize)]); - Commands.Remove(cmd); + Commands.Remove(head); nextCommand = Commands.First; return true; } @@ -66,12 +71,14 @@ public CommandBuffer() { public ref TokenizedCommand GetCommand() => ref currentCommand; - public bool AddText(ReadOnlySpan text, long tickDelay = 0) { + public bool AddText(ReadOnlySpan text, int tickDelay = 0) { + Dbg.Assert(tickDelay >= 0); + long tick = currentTick + tickDelay; ReadOnlySpan currentCommand = text.SliceNullTerminatedString(); - Span argV0 = stackalloc char[1024]; + Span argV0Stack = stackalloc char[1024]; int len = currentCommand.Length; int offsetToNextCommand = 0; for (; len > 0; len -= offsetToNextCommand, currentCommand = currentCommand[(offsetToNextCommand)..]) { @@ -79,13 +86,17 @@ public bool AddText(ReadOnlySpan text, long tickDelay = 0) { if (commandLength <= 0) continue; + Span argV0 = commandLength + 1 <= argV0Stack.Length ? argV0Stack[..(commandLength + 1)] : new char[commandLength + 1]; StringReader reader = new StringReader(new(currentCommand[..commandLength])); - ParseArgV0(reader, argV0[..commandLength], out ReadOnlySpan argS); - // We had this, but it seems unnecessary now due to the SliceNullTerminatedString call, and it breaks - // single-letter commands (which don't really exist anyway, but its still a bug) - //if (argV0[0] == '\0') continue; + ParseArgV0(reader, argV0, out ReadOnlySpan argS); + if (argV0[0] == '\0') + continue; - // wait command later + if (stricmp(argV0, "wait") == 0 && IsWaitEnabled()) { + long delay = !argS.IsEmpty ? atoi(argS) : waitDelayTicks; + tick += delay; + continue; + } if (!InsertCommand(currentCommand[..commandLength], tick)) return false; @@ -97,20 +108,19 @@ public bool AddText(ReadOnlySpan text, long tickDelay = 0) { void Compact() { argBufferSize = 0; Span tempBuffer = stackalloc char[ARGS_BUFFER_LENGTH]; - Span writeBuffer = argsBuffer.AsSpan(); foreach (Command command in Commands) { - writeBuffer[command.FirstArgS..].CopyTo(tempBuffer[argBufferSize..]); + argsBuffer.AsSpan(command.FirstArgS, command.BufferSize).CopyTo(tempBuffer[argBufferSize..]); command.FirstArgS = argBufferSize; argBufferSize += command.BufferSize; } - tempBuffer[..argBufferSize].CopyTo(writeBuffer); + tempBuffer[..argBufferSize].CopyTo(argsBuffer); } private unsafe bool InsertCommand(ReadOnlySpan argS, long tick) { int commandSize = argS.Length; - if (commandSize > TokenizedCommand.MaxCommandLength) { + if (commandSize >= TokenizedCommand.MaxCommandLength) { Dbg.Warning($"WARNING: Command too long... ignoring!\n{argS}\n"); return false; } @@ -147,7 +157,7 @@ private void InsertImmediateCommand(Command command) { if (nextCommand == null) Commands.AddLast(command); else - Commands.AddAfter(nextCommand, command); + Commands.AddBefore(nextCommand, command); } private void InsertCommandAtAppropriateTime(Command command) { @@ -166,11 +176,18 @@ private bool ParseArgV0(StringReader buf, Span argV0, out ReadOnlySpan 0) ? buf.PeekToEnd() : null; return true; } @@ -209,6 +226,9 @@ private bool ParseArgV0(StringReader buf, Span argV0, out ReadOnlySpan? i = Commands.First; + if (i == null) { + argBufferSize = 0; + return; + } + + while (i != null) { + if (i.Value.Tick >= currentTick) + break; + + LinkedListNode? next = i.Next; // note: GMod loops forever here + Dbg.Msg("Warning: Skipping command %s\n", new string(argsBuffer, i.Value.FirstArgS, i.Value.BufferSize - 1)); + Commands.Remove(i); + i = next; + } + + Compact(); } public bool IsProcessingCommands() => isProcessingCommands; public LinkedListNode? GetNextCommandHandle() { - return nextCommand; + return Commands.First; } public int GetArgumentBufferSize() { @@ -236,9 +273,16 @@ public int GetMaxArgumentBufferSize() { return maxArgBufferLength; } + public void SetWaitDelayTime(int tickDelay) { + Dbg.Assert(tickDelay >= 0); + waitDelayTicks = tickDelay; + } + public void SetWaitEnabled(bool wait) { waitEnabled = wait; } + + public bool IsWaitEnabled() => waitEnabled; } public class Cbuf(IServiceProvider provider) @@ -246,9 +290,14 @@ public class Cbuf(IServiceProvider provider) public readonly CommandBuffer Buffer = new(); Cmd Cmd; + Host Host; + + static bool WarnedOutsideMainThread; public void Init() { Cmd = provider.GetRequiredService(); + Host = provider.GetRequiredService(); + Buffer.SetWaitDelayTime(1); } public void Shutdown() { } @@ -259,7 +308,7 @@ public void ExecuteCommand(ref TokenizedCommand command, CommandSource source, i public void AddText(ReadOnlySpan text) { lock (Buffer) { if (!Buffer.AddText(text)) - Dbg.ConMsg("CBuf.AddText: buffer overflow;\n"); + Dbg.ConMsg("Cbuf_AddText: buffer overflow\n"); } } @@ -271,7 +320,22 @@ public void InsertText(ReadOnlySpan text) { } public void Execute() { + if (!ThreadInMainThread()) { + Dbg.Warning("Executing command outside main loop thread\n"); + if (!WarnedOutsideMainThread) { + WarnedOutsideMainThread = true; + if (Debugger.IsAttached) + Debugger.Break(); + } + } + lock (Buffer) { + if (Buffer.IsProcessingCommands()) + return; + + if (BaseServer.sv_allow_wait_command.GetBool() != Buffer.IsWaitEnabled()) + Buffer.SetWaitEnabled(BaseServer.sv_allow_wait_command.GetBool()); + Buffer.BeginProcessingCommands(1); while (Buffer.DequeueNextCommand()) { ExecuteCommand(ref Buffer.GetCommand(), CommandSource.Command); @@ -289,35 +353,30 @@ public bool HasRoomForExecutionMarkers(int executionMarkersCount) { } public bool AddTextWithMarkers(CmdExecutionMarker markerLeft, ReadOnlySpan text, CmdExecutionMarker markerRight) { if (!HasRoomForExecutionMarkers(2)) { - Dbg.ConMsg("Cbuf.AddTextWithMarkers: execution marker overflow\n"); + Dbg.ConMsg("Cbuf_AddTextWithMarkers: execution marker overflow\n"); return false; } int markerCodeLeft = CreateExecutionMarker(); int markerCodeRight = CreateExecutionMarker(); - Span strMarkerLeft = stackalloc char[512]; - Span strMarkerRight = stackalloc char[512]; - - $"{CMDSTR_ADD_EXECUTION_MARKER} {markerLeft} {markerCodeLeft}".CopyTo(strMarkerLeft); - $"{CMDSTR_ADD_EXECUTION_MARKER} {markerRight} {markerCodeRight}".CopyTo(strMarkerRight); + string strMarkerLeft = $";{CMDSTR_ADD_EXECUTION_MARKER} {(char)markerLeft} {markerCodeLeft};"; + string strMarkerRight = $";{CMDSTR_ADD_EXECUTION_MARKER} {(char)markerRight} {markerCodeRight};"; - int strLeftLen = System.MemoryExtensions.IndexOf(strMarkerLeft, '\0'); - int strRightLen = System.MemoryExtensions.IndexOf(strMarkerRight, '\0'); - int textToBeAddedLen = strLeftLen + strRightLen + text.Length + 3; + int textToBeAddedLen = strMarkerLeft.Length + strMarkerRight.Length + (int)strlen(text) + 3; lock (Buffer) { if (Buffer.GetArgumentBufferSize() + textToBeAddedLen + 1 > Buffer.GetMaxArgumentBufferSize()) { FindAndRemoveExecutionMarker(markerCodeLeft); FindAndRemoveExecutionMarker(markerCodeRight); - Dbg.ConMsg("Cbuf.AddTextWithMarkers: buffer overflow\n"); + Dbg.ConWarning("Cbuf_AddTextWithMarkers: buffer overflow\n"); return false; } - bool success = AddExecutionMarker(markerLeft, strMarkerLeft[..strLeftLen]) && Buffer.AddText(text) && AddExecutionMarker(markerRight, strMarkerRight[..strRightLen]); + bool success = AddExecutionMarker(markerLeft, strMarkerLeft) && Buffer.AddText(text) && AddExecutionMarker(markerRight, strMarkerRight); if (!success) - Dbg.ConMsg("Cbuf.AddTextWithMarkers: buffer overflow\n"); + Host.Error("Cbuf_AddTextWithMarkers: buffer overflow\n"); return true; } @@ -337,9 +396,8 @@ private bool AddExecutionMarker(CmdExecutionMarker marker, ReadOnlySpan ma public bool FindAndRemoveExecutionMarker(int code) => ExecutionMarkers.Remove(code); public int CreateExecutionMarker() { - if (ExecutionMarkers.Count >= MAX_EXECUTION_MARKERS) { - // todo - } + if (ExecutionMarkers.Count >= MAX_EXECUTION_MARKERS) + Host.Error("CreateExecutionMarker called, but the max has already been reached."); int randomNumber; while (true) { diff --git a/Source.Engine/Cmd.cs b/Source.Engine/Cmd.cs index 805b8084..64d3cd49 100644 --- a/Source.Engine/Cmd.cs +++ b/Source.Engine/Cmd.cs @@ -31,9 +31,11 @@ public void Shutdown() { } public CommandSource Source; public int ClientSlot; + static int InvalidExecutionMarkerCount; + private void HandleExecutionMarker(ReadOnlySpan command, ReadOnlySpan markerCodeS) { - char cCommand = command[0]; - int markerCode = (int.TryParse(markerCodeS, out int i) ? i : -1); + char cCommand = command.IsEmpty ? '\0' : command[0]; + int markerCode = atoi(markerCodeS); if (Cbuf.FindAndRemoveExecutionMarker(markerCode)) { if (cCommand == (char)CmdExecutionMarker.EnableServerCanExecute) ++filterCommandsByServerCanExecute; @@ -42,7 +44,8 @@ private void HandleExecutionMarker(ReadOnlySpan command, ReadOnlySpan command, ReadOnlySpan ExtraClientCmdCanExecuteCvars = new(StringComparer.OrdinalIgnoreCase); + + public void AddClientCmdCanExecuteVar(string name) => ExtraClientCmdCanExecuteCvars.Add(name); + public bool ShouldPreventClientCommand(ConCommandBase? cmd) { - if (filterCommandsByClientCmdCanExecute > 0 && cmd != null && cmd.IsFlagSet(FCvar.ClientCmdCanExecute)) { + if (filterCommandsByClientCmdCanExecute > 0 && cmd != null && !cmd.IsFlagSet(FCvar.ClientCmdCanExecute) && !ExtraClientCmdCanExecuteCvars.Contains(cmd.GetName())) { // If this command is in the game DLL, don't mention it because we're going to forward this // request to the server and let the server handle it. if (!cmd.IsFlagSet(FCvar.GameDLL)) - Dbg.Warning($"FCvar.ServerCanExecute prevented server running command: {cmd.GetName()}\n"); + Dbg.Warning("FCVAR_CLIENTCMD_CAN_EXECUTE prevented running command: %s\n", cmd.GetName()); return true; } @@ -166,13 +175,12 @@ public bool ShouldPreventClientCommand(ConCommandBase? cmd) { public bool ShouldPreventServerCommand(ConCommandBase? cmd) { if (!Host.IsSinglePlayerGame()) { - // todo: make this work. if (filterCommandsByServerCanExecute > 0) { if (cmd == null) return false; if (!cmd.IsFlagSet(FCvar.ServerCanExecute)) { - Dbg.Warning($"FCvar.ServerCanExecute prevented server running command: {cmd.GetName()}\n"); + Dbg.Warning("FCVAR_SERVER_CAN_EXECUTE prevented server running command: %s\n", cmd.GetName()); return true; } } From 6495f0ae2f50dd0ed185affea655a247ae8e27c2 Mon Sep 17 00:00:00 2001 From: Space V <40030799+spacevx@users.noreply.github.com> Date: Mon, 16 Nov 2026 08:59:15 +0100 Subject: [PATCH 2/2] Port raw command text, incrementvar and multvar --- Source.Engine/Cbuf.cs | 15 ++++++ Source.Engine/CdllEngineInterface.cs | 4 +- Source.Engine/EngineServerImpl.cs | 4 +- Source.Engine/Host.cs | 73 ++++++++++++++++++++++++++++ 4 files changed, 94 insertions(+), 2 deletions(-) diff --git a/Source.Engine/Cbuf.cs b/Source.Engine/Cbuf.cs index 4e81dcc5..300d34b8 100644 --- a/Source.Engine/Cbuf.cs +++ b/Source.Engine/Cbuf.cs @@ -105,6 +105,12 @@ public bool AddText(ReadOnlySpan text, int tickDelay = 0) { return true; } +#if GMOD_DLL + public bool AddRawText(ReadOnlySpan text, int tickDelay = 0) { + return InsertCommand(text.SliceNullTerminatedString(), currentTick + tickDelay); + } +#endif + void Compact() { argBufferSize = 0; Span tempBuffer = stackalloc char[ARGS_BUFFER_LENGTH]; @@ -312,6 +318,15 @@ public void AddText(ReadOnlySpan text) { } } +#if GMOD_DLL + public void AddRawText(ReadOnlySpan text) { + lock (Buffer) { + if (!Buffer.AddRawText(text)) + Dbg.ConWarning("Cbuf_AddRawText: buffer overflow\n"); + } + } +#endif + public void InsertText(ReadOnlySpan text) { lock (Buffer) { Dbg.Assert(Buffer.IsProcessingCommands()); diff --git a/Source.Engine/CdllEngineInterface.cs b/Source.Engine/CdllEngineInterface.cs index 9865f6ec..5bc95ff2 100644 --- a/Source.Engine/CdllEngineInterface.cs +++ b/Source.Engine/CdllEngineInterface.cs @@ -654,7 +654,9 @@ public void GMOD_R_RedownloadAllLightmaps(bool unk) { } public void GMOD_RawClientCmd_Unrestricted(ReadOnlySpan command) { - throw new NotImplementedException(); +#if GMOD_DLL + Cbuf.AddRawText(command); +#endif } public IGMODDataTable GMOD_CreateDataTable(GMODDataTableCallbackFn fnCallback) => new GMODDataTable(fnCallback); diff --git a/Source.Engine/EngineServerImpl.cs b/Source.Engine/EngineServerImpl.cs index 6e7a986b..e31c5ad2 100644 --- a/Source.Engine/EngineServerImpl.cs +++ b/Source.Engine/EngineServerImpl.cs @@ -1087,7 +1087,9 @@ public void GMOD_SendToClient(int client, ReadOnlySpan data, int dataBits) } public void GMOD_RawServerCommand(ReadOnlySpan command) { - throw new NotImplementedException(); +#if GMOD_DLL + Cbuf.AddRawText(command); +#endif } public IGMODDataTable GMOD_CreateDataTable() => new GMODDataTable(null); diff --git a/Source.Engine/Host.cs b/Source.Engine/Host.cs index 7c4ff666..4ec94aa7 100644 --- a/Source.Engine/Host.cs +++ b/Source.Engine/Host.cs @@ -18,6 +18,7 @@ using Steamworks; using System.Diagnostics.CodeAnalysis; +using System.Globalization; using System.Runtime.CompilerServices; using System.Text; @@ -1610,6 +1611,78 @@ public void ShutdownServer() { GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive); } + [ConCommand(helpText: "Increment specified convar value.", flags: FCvar.DontRecord)] + void incrementvar(in TokenizedCommand args) { + if (args.ArgC() != 5) { + Warning("Usage: incrementvar varName minValue maxValue delta\n"); + return; + } + + ReadOnlySpan varName = args[1]; + + ConVar? var = cvar.FindVar(varName); + if (var == null) { + ConDMsg("cvar \"%s\" not found\n", varName.ToString()); + return; + } + + float currentValue = var.GetFloat(); + float startValue = (float)atof(args[2]); + float endValue = (float)atof(args[3]); + float delta = (float)atof(args[4]); + float newValue = currentValue + delta; + if (newValue > endValue) + newValue = startValue; + else if (newValue < startValue) + newValue = endValue; + + string value = ((double)newValue).ToString("F6", CultureInfo.InvariantCulture); + string command = $"{varName} {value}"; +#if GMOD_DLL + Cbuf.AddRawText(command); +#else + Cbuf.AddText(command); +#endif + + ConDMsg("%s = %s\n", var.GetName(), value); + } + + [ConCommand(helpText: "Multiply specified convar value.", flags: FCvar.DontRecord)] + void multvar(in TokenizedCommand args) { + if (args.ArgC() != 5) { + Warning("Usage: multvar varName minValue maxValue factor\n"); + return; + } + + ReadOnlySpan varName = args[1]; + + ConVar? var = cvar.FindVar(varName); + if (var == null) { + ConDMsg("cvar \"%s\" not found\n", varName.ToString()); + return; + } + + float currentValue = var.GetFloat(); + float startValue = (float)atof(args[2]); + float endValue = (float)atof(args[3]); + float factor = (float)atof(args[4]); + float newValue = currentValue * factor; + if (newValue > endValue) + newValue = endValue; + else if (newValue < startValue) + newValue = startValue; + + string value = ((double)newValue).ToString("F6", CultureInfo.InvariantCulture); + string command = $"{varName} {value}"; +#if GMOD_DLL + Cbuf.AddRawText(command); +#else + Cbuf.AddText(command); +#endif + + ConDMsg("%s = %s\n", var.GetName(), value); + } + [ConCommand] void dumpstringtables() { SV.DumpStringTables();