diff --git a/Game.Server.Tests/VoiceGameMgrTests.cs b/Game.Server.Tests/VoiceGameMgrTests.cs new file mode 100644 index 00000000..78612f79 --- /dev/null +++ b/Game.Server.Tests/VoiceGameMgrTests.cs @@ -0,0 +1,423 @@ +using Microsoft.Extensions.DependencyInjection; + +using Source.Common; +using Source.Common.Bitbuffers; +using Source.Common.Commands; +using Source.Common.Engine; +using Source.Common.Server; + +using System.Reflection; +using System.Reflection.Emit; + +using static Game.Server.VoiceGameMgrGlobals; + +namespace Game.Server.Tests; + +public static class FakeEngineCalls +{ + public static readonly Edict?[] Edicts = new Edict?[130]; + public static readonly List<(string Name, byte[] Data)> Messages = []; + public static readonly List ServerCommands = []; + static string? messageName; + static byte[]? messageData; + static bf_write? messageBuffer; + + public static Edict? PEntityOfEntIndex(int index) => index >= 0 && index < Edicts.Length ? Edicts[index] : null; + public static int IndexOfEdict(Edict? edict) => edict?.EdictIndex ?? 0; + public static int GetPlayerUserId(Edict e) => 100 + e.EdictIndex; + public static void ServerCommand(ReadOnlySpan str) => ServerCommands.Add(str.ToString()); + public static Source.Common.GarrysMod.IGMODDataTable GMOD_CreateDataTable() => null!; + + public static bf_write UserMessageBegin(in IRecipientFilter filter, int msgType) { + messageName = SourceDllMain.usermessages.GetUserMessageName(msgType).ToString(); + messageData = new byte[256]; + messageBuffer = new bf_write(messageData, messageData.Length); + return messageBuffer; + } + + public static void MessageEnd() { + Messages.Add((messageName!, messageData![..messageBuffer!.BytesWritten])); + messageName = null; + messageData = null; + messageBuffer = null; + } + + public static void Reset() { + Array.Clear(Edicts); + Messages.Clear(); + ServerCommands.Clear(); + } +} + +// Mocking libraries cannot implement ReadOnlySpan parameters, so each method calls the same static method in calls or throws +public static class FakeInterface +{ + public static T Create(Type calls) where T : class { + string name = $"Fake{typeof(T).Name}"; + AssemblyBuilder assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run); + ModuleBuilder module = assembly.DefineDynamicModule(name); + TypeBuilder type = module.DefineType(name, TypeAttributes.Public | TypeAttributes.Sealed, typeof(object), [typeof(T)]); + + foreach (Type iface in typeof(T).GetInterfaces().Prepend(typeof(T))) { + foreach (MethodInfo method in iface.GetMethods()) { + ParameterInfo[] parameters = method.GetParameters(); + Type[] types = [.. parameters.Select(p => p.ParameterType)]; + MethodBuilder impl = type.DefineMethod($"{iface.Name}.{method.Name}", + MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot, + CallingConventions.HasThis); + + Type[] genericArgs = method.IsGenericMethodDefinition ? method.GetGenericArguments() : []; + GenericTypeParameterBuilder[] genericParams = genericArgs.Length > 0 ? impl.DefineGenericParameters([.. genericArgs.Select(g => g.Name)]) : []; + for (int i = 0; i < genericParams.Length; i++) { + genericParams[i].SetGenericParameterAttributes(genericArgs[i].GenericParameterAttributes); + genericParams[i].SetInterfaceConstraints([.. genericArgs[i].GetGenericParameterConstraints()]); + } + + Type Map(Type t) => t.IsByRef ? Map(t.GetElementType()!).MakeByRefType() : t.IsGenericMethodParameter ? genericParams[t.GenericParameterPosition] : t; + + impl.SetSignature(Map(method.ReturnType), + method.ReturnParameter.GetRequiredCustomModifiers(), method.ReturnParameter.GetOptionalCustomModifiers(), + [.. types.Select(Map)], [.. parameters.Select(p => p.GetRequiredCustomModifiers())], [.. parameters.Select(p => p.GetOptionalCustomModifiers())]); + + ILGenerator il = impl.GetILGenerator(); + MethodInfo? target = genericArgs.Length > 0 ? null : calls.GetMethod(method.Name, BindingFlags.Public | BindingFlags.Static, types); + if (target != null && target.ReturnType == method.ReturnType) { + for (int i = 0; i < parameters.Length; i++) + il.Emit(OpCodes.Ldarg, i + 1); + il.Emit(OpCodes.Call, target); + il.Emit(OpCodes.Ret); + } + else { + il.Emit(OpCodes.Ldstr, $"{iface.Name}.{method.Name}"); + il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructor([typeof(string)])!); + il.Emit(OpCodes.Throw); + } + + type.DefineMethodOverride(impl, method); + } + } + + return (T)Activator.CreateInstance(type.CreateType())!; + } +} + +public static class FakeCvarCalls +{ + public static void CallGlobalChangeCallbacks(ConVar var, in ConVarChangeContext ctx) { } +} + +public class FakeVoiceServer : IVoiceServer +{ + public readonly bool[,] Listening = new bool[130, 130]; + public readonly bool[,] Proximity = new bool[130, 130]; + public readonly List<(int Receiver, int Sender)> Queries = []; + + public bool GetClientListening(int receiver, int sender) { + Queries.Add((receiver, sender)); + return Listening[receiver, sender]; + } + + public bool GetClientProximity(int receiver, int sender) => Proximity[receiver, sender]; + + public bool SetClientListening(int receiver, int sender, bool listen) { + Listening[receiver, sender] = listen; + return true; + } + + public bool SetClientProximity(int receiver, int sender, bool useProximity) { + Proximity[receiver, sender] = useProximity; + return true; + } +} + +public class FakeVoiceHelper : IVoiceGameMgrHelper +{ + public readonly List<(double Time, int Listener, int Talker)> Calls = []; + public bool CanHear = true; + public bool UseProximity; + + public bool CanPlayerHearPlayer(BasePlayer listener, BasePlayer talker, ref bool proximity) { + Calls.Add((SourceDllMain.gpGlobals.CurTime, listener.EntIndex(), talker.EntIndex())); + proximity = UseProximity; + return CanHear; + } +} + +[CollectionDefinition(nameof(ServerGlobalsCollection), DisableParallelization = true)] +public class ServerGlobalsCollection; + +[Collection(nameof(ServerGlobalsCollection))] +public class VoiceGameMgrTests +{ + static readonly IEngineServer FakeEngine = FakeInterface.Create(typeof(FakeEngineCalls)); + static readonly GlobalEntityList EntityList = new(); + static readonly IServiceProvider Provider = new ServiceCollection() + .AddSingleton(EntityList) + .AddSingleton(EntityList) + .AddSingleton(FakeInterface.Create(typeof(FakeCvarCalls))) + .BuildServiceProvider(); + + readonly VoiceGameMgr Mgr = new(); + readonly FakeVoiceHelper Helper = new(); + readonly FakeVoiceServer VoiceServer = new(); + readonly ServerGlobalVariables Globals = new(); + readonly BasePlayer[] Players; + + public VoiceGameMgrTests() { + FakeEngineCalls.Reset(); + GameRules.g_pGameRules = (GameRules)System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(typeof(GarrysMod.GMODGameRules)); + typeof(Source.Common.Engine.ImportUtils).GetProperty("EngineProvider", BindingFlags.NonPublic | BindingFlags.Static)!.SetValue(null, Provider); + SetGlobal(nameof(SourceDllMain.engine), FakeEngine); + SetGlobal(nameof(SourceDllMain.gpGlobals), Globals); + SetGlobal(nameof(SourceDllMain.g_pVoiceServer), VoiceServer); + SetGlobal(nameof(SourceDllMain.usermessages), new Game.Shared.UserMessages()); + + g_PlayerModEnable = default; + g_bWantModEnable = default; + Array.Clear(g_BanMasks); + Array.Clear(g_SentGameRulesMasks); + Array.Clear(g_SentBanMasks); + sv_alltalk.SetValue(0); + + Globals.MaxClients = 2; + Globals.CurTime = 100; + Players = [CreatePlayer(1), CreatePlayer(2)]; + g_PlayerModEnable.Set(0, true); + g_PlayerModEnable.Set(1, true); + + Mgr.Init(Helper, Globals.MaxClients); + } + + static void SetGlobal(string name, object value) => typeof(SourceDllMain).GetProperty(name)!.SetValue(null, value); + + static BasePlayer CreatePlayer(int index) { + Edict edict = new() { EdictIndex = index }; + BasePlayer player = new(); + player.NetworkProp().AttachEdict(edict); + FakeEngineCalls.Edicts[index] = edict; + return player; + } + + void Advance(double seconds) { + Globals.CurTime += seconds; + Mgr.Update(seconds); + } + + void ReceiveVoicePacket(int index) => Mgr.OnReceivedVoicePacket(Players[index - 1]); + + static (int Listener, int Talker)[] Pairs(IEnumerable<(double Time, int Listener, int Talker)> calls) + => [.. calls.Select(c => (c.Listener, c.Talker))]; + + [Fact] + public void NobodyTalking_FullUpdateEveryFiveSeconds() { + for (int i = 0; i < 80; i++) + Advance(0.125); + + Assert.Equal([105.0, 105.0, 105.0, 105.0, 110.0, 110.0, 110.0, 110.0], Helper.Calls.Select(c => c.Time)); + Assert.Equal([(1, 1), (1, 2), (2, 1), (2, 2)], Pairs(Helper.Calls.Take(4))); + } + + [Fact] + public void FirstVoicePacket_UpdatesRightAway_OnlyForTheTalker() { + ReceiveVoicePacket(1); + + Assert.Equal([(1, 1), (2, 1)], Pairs(Helper.Calls)); + Assert.Equal([(1, 2), (2, 2)], VoiceServer.Queries); + } + + [Fact] + public void VoicePacketWithinPointThreeSeconds_DoesNotUpdateAgain() { + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + + Globals.CurTime += 0.25; + ReceiveVoicePacket(1); + + Assert.Empty(Helper.Calls); + } + + [Fact] + public void Talking_PartialUpdateAfterPointThreeSeconds() { + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + VoiceServer.Queries.Clear(); + + Advance(0.25); + ReceiveVoicePacket(1); + Assert.Empty(Helper.Calls); + + Advance(0.25); + Assert.Equal([(1, 1), (2, 1)], Pairs(Helper.Calls)); + Assert.Equal([(1, 2), (2, 2)], VoiceServer.Queries); + } + + [Fact] + public void SilenceAfterTalking_NoPartialUpdates() { + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + + for (int i = 0; i < 32; i++) + Advance(0.125); + + Assert.Empty(Helper.Calls); + } + + [Fact] + public void PlayerWhoTalkedWithinOneSecond_IsStillAsked() { + ReceiveVoicePacket(2); + Advance(0.25); + ReceiveVoicePacket(1); + Advance(0.25); + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + VoiceServer.Queries.Clear(); + + Advance(0.25); + + Assert.Equal([(1, 1), (1, 2), (2, 1), (2, 2)], Pairs(Helper.Calls)); + Assert.Empty(VoiceServer.Queries); + } + + [Fact] + public void PlayerWhoTalkedOneSecondAgo_UsesTheEngineState() { + ReceiveVoicePacket(2); + Advance(1.0); + ReceiveVoicePacket(1); + Advance(0.25); + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + VoiceServer.Queries.Clear(); + + Advance(0.25); + + Assert.Equal([(1, 1), (2, 1)], Pairs(Helper.Calls)); + Assert.Equal([(1, 2), (2, 2)], VoiceServer.Queries); + } + + [Fact] + public void Talking_FullUpdateEveryFiveSeconds() { + for (int i = 0; i < 24; i++) { + ReceiveVoicePacket(1); + Advance(0.25); + } + + Assert.Contains(Helper.Calls, c => c.Talker == 2 && c.Time == 105.5); + Assert.Single(Helper.Calls, c => c.Listener == 1 && c.Talker == 2); + } + + [Fact] + public void MoreThanThreeSecondsSinceLastUpdate_IsAFullUpdate() { + ReceiveVoicePacket(1); + Helper.Calls.Clear(); + + Globals.CurTime += 0.25; + Mgr.Update(3.25); + + Assert.Equal([(1, 1), (1, 2), (2, 1), (2, 2)], Pairs(Helper.Calls)); + } + + [Fact] + public void PartialUpdate_KeepsWhatTheEngineHas() { + VoiceServer.Listening[1, 2] = true; + VoiceServer.Proximity[1, 2] = true; + VoiceServer.Listening[2, 2] = false; + + ReceiveVoicePacket(1); + + Assert.True(VoiceServer.Listening[1, 2]); + Assert.True(VoiceServer.Proximity[1, 2]); + Assert.False(VoiceServer.Listening[2, 2]); + } + + [Fact] + public void AllTalk_IsNotChecked() { + sv_alltalk.SetValue(1); + Helper.CanHear = false; + + for (int i = 0; i < 40; i++) + Advance(0.125); + + Assert.False(VoiceServer.Listening[1, 2]); + Assert.False(VoiceServer.Listening[2, 1]); + } + + [Fact] + public void VoiceMask_SentOnlyWhenItChanges() { + Helper.UseProximity = true; + for (int i = 0; i < 80; i++) + Advance(0.125); + + (string Name, byte[] Data)[] masks = [.. FakeEngineCalls.Messages.Where(m => m.Name == "VoiceMask")]; + Assert.Equal(2, masks.Length); + Assert.Equal(33, masks[0].Data.Length); + Assert.Equal(0b11, BitConverter.ToInt32(masks[0].Data, 0)); + Assert.Equal(0, BitConverter.ToInt32(masks[0].Data, 4)); + Assert.Equal(1, masks[0].Data[32]); + Assert.True(VoiceServer.Proximity[1, 2]); + } + + [Fact] + public void RequestState_SentOnceAfterConnect() { + Mgr.ClientConnected(Players[0].Edict()); + + for (int i = 0; i < 80; i++) + Advance(0.125); + + Assert.Single(FakeEngineCalls.Messages, m => m.Name == "RequestState"); + } + + [Fact] + public void ClientConnected_IgnoresNullAndOutOfRangeEdicts() { + Mgr.ClientConnected(null); + Mgr.ClientConnected(new Edict { EdictIndex = 129 }); + Mgr.ClientConnected(new Edict { EdictIndex = 0 }); + + Assert.True(g_bWantModEnable.IsAllClear()); + } + + [Fact] + public void VoicePacketFromNonPlayer_IsIgnored() { + Mgr.OnReceivedVoicePacket(null); + + Assert.Empty(Helper.Calls); + } + + [Fact] + public void TooManyVoicePacketsInOneFrame_KicksOnce() { + for (int i = 0; i < 48; i++) + ReceiveVoicePacket(1); + Assert.Empty(FakeEngineCalls.ServerCommands); + + ReceiveVoicePacket(1); + ReceiveVoicePacket(1); + + Assert.Equal(["kickid 101 \"Too many voice packets (49) in a single frame!\"\n"], FakeEngineCalls.ServerCommands); + Assert.True(Players[0].Kicked); + } + + [Fact] + public void VoicePacketCount_ResetsEveryFrame() { + for (int frame = 0; frame < 10; frame++) { + for (int i = 0; i < 48; i++) + ReceiveVoicePacket(1); + Globals.CurTime += 0.015; + } + + Assert.Empty(FakeEngineCalls.ServerCommands); + } + + [Fact] + public void VoicePacketLimitZero_NeverKicks() { + ConVar limit = (ConVar)typeof(BasePlayer).GetField("sv_maxvoicepacketsperframe", BindingFlags.NonPublic | BindingFlags.Static)!.GetValue(null)!; + limit.SetValue(0); + try { + for (int i = 0; i < 100; i++) + ReceiveVoicePacket(1); + } + finally { + limit.SetValue(48); + } + + Assert.Empty(FakeEngineCalls.ServerCommands); + } +} diff --git a/Game.Server/GameInterface.cs b/Game.Server/GameInterface.cs index e3c8af26..5f14c4e4 100644 --- a/Game.Server/GameInterface.cs +++ b/Game.Server/GameInterface.cs @@ -912,6 +912,8 @@ public TimeUnit_t ProcessUsercmds(Edict player, bf_read buf, int numCmds, int to public void GMOD_SentClientStringTables(int userID) => Game.Server.GarrysMod.GModDataPack.DataPack().SendFileRequestRequest(userID); + public void GMOD_OnReceivedVoicePacket(Edict? player) => GetVoiceGameMgr().OnReceivedVoicePacket(BaseEntity.Instance(player)); + public void GMOD_ReceiveClientMessage(int userID, Edict player, bf_read msg, int bits) { int type = msg.ReadByte(); if (bits <= 7 || type > 5) { diff --git a/Game.Server/Player.cs b/Game.Server/Player.cs index e636c799..b2afaad1 100644 --- a/Game.Server/Player.cs +++ b/Game.Server/Player.cs @@ -2370,6 +2370,39 @@ public virtual void ForceDropOfCarriedPhysObjects(BaseEntity? ground) { } internal int GetUserID() => engine.GetPlayerUserId(Edict()); +#if GMOD_DLL + static readonly ConVar sv_maxvoicepacketsperframe = new("sv_maxvoicepacketsperframe", "48", 0, "How many voice packets the server will accept from a single client per frame/tick, before the client is kicked. 0 to disable. Higher values will make the server more vulnerable to DoS attacks."); + + public double LastVoicePacketTime; + ushort VoicePacketsThisFrame; + public bool Kicked; + + public void OnVoicePacketReceived() { + double curTime = gpGlobals.CurTime; + ushort packets; + if (LastVoicePacketTime == curTime) + packets = (ushort)(VoicePacketsThisFrame + 1); + else { + packets = 1; + VoicePacketsThisFrame = 0; + } + + LastVoicePacketTime = curTime; + VoicePacketsThisFrame = packets; + + int maxPackets = sv_maxvoicepacketsperframe.GetInt(); + if (maxPackets <= 0) + return; + + if ((VoicePacketsThisFrame > 65000 || maxPackets < VoicePacketsThisFrame) && !Kicked) { + Span cmd = stackalloc char[600]; + sprintf(cmd, "kickid %d \"Too many voice packets (%i) in a single frame!\"\n").D(engine.GetPlayerUserId(Edict())).I(VoicePacketsThisFrame); + engine.ServerCommand(cmd.SliceNullTerminatedString()); + Kicked = true; + } + } +#endif + public bool GetSteamID(out Steamworks.CSteamID id) { Steamworks.CSteamID? steamID = engine.GetClientSteamID(Edict()); id = steamID ?? default; diff --git a/Game.Server/VoiceGameMgr.cs b/Game.Server/VoiceGameMgr.cs index 15d04ccd..c85e373c 100644 --- a/Game.Server/VoiceGameMgr.cs +++ b/Game.Server/VoiceGameMgr.cs @@ -42,7 +42,11 @@ public static class VoiceGameMgrGlobals // Set game rules to allow all clients to talk to each other. // Muted players still can't talk to each other. +#if GMOD_DLL + public static readonly ConVar sv_alltalk = new("sv_alltalk", "0", FCvar.Notify, "Players can hear all other players, no team restrictions"); +#else public static readonly ConVar sv_alltalk = new("sv_alltalk", "0", FCvar.Notify | FCvar.Replicated, "Players can hear all other players, no team restrictions"); +#endif public static readonly VoiceGameMgr g_VoiceGameMgr = new(); @@ -67,9 +71,15 @@ public static void VoiceServerDebug(ReadOnlySpan msg) { // VoiceGameMgr manages which clients can hear which other clients. public class VoiceGameMgr { +#if GMOD_DLL + double LastVoicePacketTime; +#endif IVoiceGameMgrHelper? Helper; int MaxPlayers; double UpdateInterval; // How long since the last update. +#if GMOD_DLL + double FullUpdateInterval; +#endif int ProximityDistance; public VoiceGameMgr() { @@ -94,17 +104,67 @@ public void SetHelper(IVoiceGameMgrHelper? helper) { // If gameplay mode is teamplay, then only players on the same team can hear each other. // Player masks are always applied. public void Update(double frametime) { +#if GMOD_DLL + UpdateInterval += frametime; + FullUpdateInterval += frametime; + if (UpdateInterval < UPDATE_INTERVAL) + return; + + if (gpGlobals.CurTime - LastVoicePacketTime > UPDATE_INTERVAL && UpdateInterval < 5.0) + return; + + if (UpdateInterval > 3.0 || FullUpdateInterval > 5.0) { + FullUpdateInterval = 0; + UpdatePlayers(true, null); + } + else + UpdatePlayers(false, null); +#else // Only update periodically. UpdateInterval += frametime; if (UpdateInterval < UPDATE_INTERVAL) return; UpdateMasks(); +#endif + } + +#if GMOD_DLL + public void OnReceivedVoicePacket(BaseEntity? entity) { + if (entity == null || !entity.IsPlayer()) + return; + + BasePlayer player = (BasePlayer)entity; + bool startedTalking = gpGlobals.CurTime - player.LastVoicePacketTime > UPDATE_INTERVAL; + player.OnVoicePacketReceived(); + LastVoicePacketTime = gpGlobals.CurTime; + + if (startedTalking) + UpdatePlayers(false, player); + } + + void UpdatePlayers(bool full, BasePlayer? talker) { + UpdateInterval = 0; + + for (int iClient = 0; iClient < MaxPlayers; iClient++) { + BaseEntity? ent = Util.PlayerByIndex(iClient + 1); + if (ent != null && ent.IsPlayer()) + UpdatePlayer((BasePlayer)ent, full, talker); + } } +#endif // Called when a new client connects (unsquelches its entity for everyone). - public void ClientConnected(Edict edict) { - int index = edict.EdictIndex - 1; + public void ClientConnected(Edict? edict) { +#if GMOD_DLL + if (edict == null) + return; +#endif + int index = edict!.EdictIndex - 1; +#if GMOD_DLL + if ((uint)index >= VOICE_MAX_PLAYERS) + return; +#endif // Clear out everything we use for deltas on this guy. g_bWantModEnable.Set(index, true); @@ -164,6 +224,74 @@ public bool IsPlayerIgnoringPlayer(int talker, int listener) { return g_BanMasks[listener - 1].IsBitSet(talker - 1); } +#if GMOD_DLL + void UpdatePlayer(BasePlayer player, bool full, BasePlayer? talker) { + int playerIndex = player.EntIndex(); + int iClient = playerIndex - 1; + + SingleUserRecipientFilter user = new(player); + + // Request the state of their "VModEnable" cvar + if (g_bWantModEnable.IsBitSet(iClient)) { + UserMessageBegin(user, "RequestState"); + MessageEnd(); + // Only send it once + g_bWantModEnable.Set(iClient, false); + } + + PlayerBitSet gameRulesMask = default; + PlayerBitSet proximityMask = default; + if (g_PlayerModEnable.IsBitSet(iClient)) { + bool proximity = false; + + // Build a mask of who they can hear based on the game rules + for (int iOtherClient = 0; iOtherClient < MaxPlayers; iOtherClient++) { + BaseEntity? otherEnt = Util.PlayerByIndex(iOtherClient + 1); + if (otherEnt == null || !otherEnt.IsPlayer()) + continue; + + BasePlayer other = (BasePlayer)otherEnt; + bool canHear; + if (full || other == talker || gpGlobals.CurTime - other.LastVoicePacketTime < 1.0) + canHear = Helper!.CanPlayerHearPlayer(player, other, ref proximity); + else { + canHear = g_pVoiceServer.GetClientListening(playerIndex, iOtherClient + 1); + proximity = g_pVoiceServer.GetClientProximity(playerIndex, iOtherClient + 1); + } + + if (canHear) { + gameRulesMask.Set(iOtherClient, true); + proximityMask.Set(iOtherClient, proximity); + } + } + } + + // If this is different from what the client has, send an update + if (gameRulesMask != g_SentGameRulesMasks[iClient] || + g_BanMasks[iClient] != g_SentBanMasks[iClient]) { + g_SentGameRulesMasks[iClient] = gameRulesMask; + g_SentBanMasks[iClient] = g_BanMasks[iClient]; + + UserMessageBegin(user, "VoiceMask"); + int dw; + for (dw = 0; dw < VOICE_MAX_PLAYERS_DW; dw++) { + MessageWriteLong((int)gameRulesMask.GetWord(dw)); + MessageWriteLong((int)g_BanMasks[iClient].GetWord(dw)); + } + MessageWriteByte(g_PlayerModEnable.IsBitSet(iClient) ? 1 : 0); + MessageEnd(); + } + + // Tell the engine. + for (int iOtherClient = 0; iOtherClient < MaxPlayers; iOtherClient++) { + bool canHear = gameRulesMask.IsBitSet(iOtherClient) && !g_BanMasks[iClient].IsBitSet(iOtherClient); + g_pVoiceServer.SetClientListening(playerIndex, iOtherClient + 1, canHear); + + if (canHear) + g_pVoiceServer.SetClientProximity(playerIndex, iOtherClient + 1, proximityMask.IsBitSet(iOtherClient)); + } + } +#else // Force it to update the client masks. void UpdateMasks() { UpdateInterval = 0; @@ -228,4 +356,5 @@ void UpdateMasks() { } } } +#endif } diff --git a/Source.Common/Server/IServerGameDLL.cs b/Source.Common/Server/IServerGameDLL.cs index d44cddba..484e22af 100644 --- a/Source.Common/Server/IServerGameDLL.cs +++ b/Source.Common/Server/IServerGameDLL.cs @@ -163,6 +163,7 @@ public interface IServerGameClients void GMOD_ReceiveClientMessage(int userID, Edict player, bf_read msg, int bits); void GMOD_ClientConnected(int userID); void GMOD_SentClientStringTables(int userID); + void GMOD_OnReceivedVoicePacket(Edict? player); } public interface IServerGCLobby diff --git a/Source.Common/Server/IVoiceServer.cs b/Source.Common/Server/IVoiceServer.cs index 0c04b172..0d794991 100644 --- a/Source.Common/Server/IVoiceServer.cs +++ b/Source.Common/Server/IVoiceServer.cs @@ -12,4 +12,7 @@ public interface IVoiceServer bool GetClientListening(int receiver, int sender); bool SetClientListening(int receiver, int sender, bool listen); bool SetClientProximity(int receiver, int sender, bool useProximity); +#if GMOD_DLL + bool GetClientProximity(int receiver, int sender); +#endif } diff --git a/Source.Engine/Server/GameClient.cs b/Source.Engine/Server/GameClient.cs index 7d1ff817..db191e6b 100644 --- a/Source.Engine/Server/GameClient.cs +++ b/Source.Engine/Server/GameClient.cs @@ -112,6 +112,18 @@ protected override bool ProcessMove(CLC_Move m) { } protected override bool ProcessVoiceData(CLC_VoiceData msg) { +#if GMOD_DLL + if ((uint)(msg.Length - 9) >= 0x3FF8) { + Disconnect($"Invalid voice packet length {msg.Length}."); + return false; + } + + if (!IsActive()) + return false; + + serverGameClients.GMOD_OnReceivedVoicePacket(Edict); +#endif + byte[] voiceDataBuffer = new byte[4096]; int bitsRead = (int)msg.DataIn.ReadBitsClamped(voiceDataBuffer, (uint)msg.Length); diff --git a/Source.Engine/Server/VoiceServerImpl.cs b/Source.Engine/Server/VoiceServerImpl.cs index 860a1588..41b5daf0 100644 --- a/Source.Engine/Server/VoiceServerImpl.cs +++ b/Source.Engine/Server/VoiceServerImpl.cs @@ -47,4 +47,16 @@ public bool SetClientProximity(int receiver, int sender, bool useProximity) { return true; } + +#if GMOD_DLL + public bool GetClientProximity(int receiver, int sender) { + --receiver; + --sender; + + if (receiver < 0 || receiver >= sv.GetClientCount() || sender < 0 || sender >= sv.GetClientCount()) + return false; + + return sv.Client(sender).VoiceProximity.Get(receiver) != 0; + } +#endif }