audio and microphone range overrides added

Author: dooly123

Basis Server/BasisNetworkCore/BasisConfigXmlDocs.cs

@@ -186,6 +186,8 @@ private static void RegisterServerConfig()
             t.Fields.Add(new FieldDoc("AdditionalAvatarDataLock", " Strip AdditionalAvatarDatas (blendshapes, custom-behaviour params) from inbound avatar sync before relaying; muscle/position/rotation still sync. true|false. "));
             t.Fields.Add(new FieldDoc("CameraMetadataDisallowMask", " Bitmask of camera photo-metadata categories disallowed for all clients (set bit = disallowed). 0 = everything allowed. byte, range 0-255; the category-to-bit mapping is defined client-side. "));
             t.Fields.Add(new FieldDoc("CrashReportingEnabled", " Allow clients to send a one-shot report of each error/exception they hit to the server, stored under CrashReports/<uuid>.jsonl with their UUID and display name. true|false; default true. Set false to globally disable reporting (clients are told to stop sending). ", " ===== Diagnostics ===== "));
+            t.Fields.Add(new FieldDoc("MaxMicrophoneRangeMeters", " Maximum microphone (voice transmit) range, in metres, a client may set. Clients clamp their Microphone Range slider and effective range to this ceiling; can also be changed live from the admin panel. float; default 25. ", " ===== Audio / voice range ===== "));
+            t.Fields.Add(new FieldDoc("MaxHearingRangeMeters", " Maximum hearing (audio receive) range, in metres, a client may set. Clients clamp their Hearing Range slider and effective range to this ceiling. float; default 25. "));
             _docs[typeof(global::Configuration)] = t;
         }
 

Basis Server/BasisNetworkCore/BasisServerConfiguration.cs

@@ -19,7 +19,7 @@ public class Configuration
     /// doc comments). Newly-added settings are healed automatically regardless: on load a
     /// config missing any current field is re-saved with the new settings added.
     /// </summary>
-    public const int CurrentConfigVersion = 1;
+    public const int CurrentConfigVersion = 2;
     /// <summary>Schema version stamped into config.xml; 0 = a pre-versioning file that is upgraded on load.</summary>
     public int ConfigVersion = 0;
 
@@ -102,6 +102,8 @@ public class Configuration
     /// </summary>
     public byte CameraMetadataDisallowMask = 0;
     public bool CrashReportingEnabled = true;
+    public float MaxMicrophoneRangeMeters = 25f;
+    public float MaxHearingRangeMeters = 25f;
     /// <summary>
     /// Read config from file. If no file is found create a default config file at filePath.
     /// Also loads per-transport config sidecars from <c>{configDir}/transports/{stackId}.xml</c>.

Basis Server/BasisNetworkCore/Serializable/AdminRequest.cs

@@ -106,6 +106,9 @@ public enum AdminRequestMode : byte
 
             GlobalGetCrashReportState, // server→client: whether client error/exception reporting is enabled
             SetGlobalCrashReporting,   // admin: enable/disable client error/exception reporting (persisted). Payload: [bool]
+
+            GlobalGetAudioRangeLimits, // server→client: max microphone + hearing range in metres. Payload: [float micMeters][float hearingMeters]
+            SetGlobalAudioRangeLimits, // admin: set max microphone + hearing range in metres (persisted). Payload: [float micMeters][float hearingMeters]
         }
     }
 }

Basis Server/BasisNetworkServer/BasisServerHandleEvents.cs

@@ -359,6 +359,7 @@ public static void OnNetworkAccepted(NetPeer newPeer, ReadyMessage ReadyMessage,
                 BasisNetworkServer.Security.BasisOpusFrameDurationStateManager.SendStateToPeer(newPeer);
                 BasisNetworkServer.Security.BasisUserOpusBitrateStateManager.SendStateToPeer(newPeer);
                 BasisNetworkServer.Security.BasisCrashReportStateManager.SendStateToPeer(newPeer);
+                BasisNetworkServer.Security.BasisAudioRangeLimitManager.SendStateToPeer(newPeer);
                 SendShoutStateToPeer(newPeer);
             }
             else

Basis Server/BasisNetworkServer/NetworkServer.cs

@@ -74,6 +74,7 @@ public static void StartServer(Configuration configuration)
         BasisHeadlessConnectionPolicyManager.InitializeFromConfig(configuration.DisallowHeadless);
         BasisNetworkServer.Security.BasisGlobalLockManager.InitializeFromConfig(configuration);
         BasisNetworkServer.Security.BasisCrashReportStateManager.InitializeFromConfig(configuration);
+        BasisNetworkServer.Security.BasisAudioRangeLimitManager.InitializeFromConfig(configuration);
         SetupServer(configuration);
         SubscribeEvents(Configuration);
 

Basis Server/BasisNetworkServer/Security/BasisAudioRangeLimitManager.cs

@@ -0,0 +1,80 @@
+using Basis.Network.Core;
+using System.Threading;
+using static BasisNetworkCore.Serializable.SerializableBasis;
+
+namespace BasisNetworkServer.Security
+{
+    /// <summary>
+    /// Server-defined ceilings (in metres) for how far clients may set their microphone (voice
+    /// transmit) and hearing (audio receive) range. Seeded from Configuration at boot and pushed to
+    /// clients via GlobalGetAudioRangeLimits so they clamp their sliders and effective range to it.
+    /// Admins can change it live; the new values are persisted to config.xml and broadcast.
+    /// </summary>
+    public static class BasisAudioRangeLimitManager
+    {
+        private const float DefaultMeters = 25f;
+
+        private static float _maxMicrophoneRangeMeters = DefaultMeters;
+        private static float _maxHearingRangeMeters = DefaultMeters;
+
+        public static float MaxMicrophoneRangeMeters => Interlocked.CompareExchange(ref _maxMicrophoneRangeMeters, 0f, 0f);
+        public static float MaxHearingRangeMeters => Interlocked.CompareExchange(ref _maxHearingRangeMeters, 0f, 0f);
+
+        public static void InitializeFromConfig(Configuration config)
+        {
+            Interlocked.Exchange(ref _maxMicrophoneRangeMeters, Sanitize(config.MaxMicrophoneRangeMeters));
+            Interlocked.Exchange(ref _maxHearingRangeMeters, Sanitize(config.MaxHearingRangeMeters));
+        }
+
+        /// <summary>Clamp, set, and report whether either value actually changed.</summary>
+        public static bool SetLimits(float microphoneMeters, float hearingMeters)
+        {
+            float mic = Sanitize(microphoneMeters);
+            float hearing = Sanitize(hearingMeters);
+            float prevMic = Interlocked.Exchange(ref _maxMicrophoneRangeMeters, mic);
+            float prevHearing = Interlocked.Exchange(ref _maxHearingRangeMeters, hearing);
+            return prevMic != mic || prevHearing != hearing;
+        }
+
+        public static void SendStateToPeer(NetPeer peer)
+        {
+            NetDataWriter writer = NetworkServer.RentWriter();
+            try
+            {
+                new AdminRequest().Serialize(writer, AdminRequestMode.GlobalGetAudioRangeLimits);
+                writer.Put(MaxMicrophoneRangeMeters);
+                writer.Put(MaxHearingRangeMeters);
+                NetworkServer.TrySend(peer, writer, BasisNetworkCommons.AdminChannel, DeliveryMethod.ReliableOrdered);
+            }
+            finally
+            {
+                NetworkServer.ReturnWriter(writer);
+            }
+        }
+
+        public static void BroadcastState()
+        {
+            NetDataWriter writer = NetworkServer.RentWriter();
+            try
+            {
+                new AdminRequest().Serialize(writer, AdminRequestMode.GlobalGetAudioRangeLimits);
+                writer.Put(MaxMicrophoneRangeMeters);
+                writer.Put(MaxHearingRangeMeters);
+                NetworkServer.BroadcastMessageToClients(
+                    writer,
+                    BasisNetworkCommons.AdminChannel,
+                    NetworkServer.PeerSnapshot,
+                    DeliveryMethod.ReliableOrdered);
+            }
+            finally
+            {
+                NetworkServer.ReturnWriter(writer);
+            }
+        }
+
+        private static float Sanitize(float meters)
+        {
+            return meters <= 0f ? DefaultMeters : meters;
+        }
+    }
+}

Basis Server/BasisNetworkServer/Security/BasisPlayerModeration.cs

@@ -364,6 +364,11 @@ public static void OnAdminMessage(NetPeer peer, NetPacketReader reader)
                         HandleCrashReportingSet(peer, reader));
                     break;
 
+                case AdminRequestMode.SetGlobalAudioRangeLimits:
+                    Require(peer, PermNodes.ModerationGlobalLock, () =>
+                        HandleAudioRangeLimitsSet(peer, reader));
+                    break;
+
                 case AdminRequestMode.SetGlobalHeadlessDisallow:
                     Require(peer, PermNodes.ModerationGlobalLock, () =>
                         HandleHeadlessDisallowSet(peer, reader));
@@ -684,6 +689,18 @@ private static void HandleCrashReportingSet(NetPeer peer, NetPacketReader reader
             SendBackMessage(peer, $"Crash reporting {(enabled ? "ENABLED" : "DISABLED")}.");
         }
 
+        private static void HandleAudioRangeLimitsSet(NetPeer peer, NetPacketReader reader)
+        {
+            float microphoneMeters = reader.GetFloat();
+            float hearingMeters = reader.GetFloat();
+            BasisAudioRangeLimitManager.SetLimits(microphoneMeters, hearingMeters);
+            NetworkServer.Configuration.MaxMicrophoneRangeMeters = BasisAudioRangeLimitManager.MaxMicrophoneRangeMeters;
+            NetworkServer.Configuration.MaxHearingRangeMeters = BasisAudioRangeLimitManager.MaxHearingRangeMeters;
+            SaveConfig();
+            BasisAudioRangeLimitManager.BroadcastState();
+            SendBackMessage(peer, $"Audio range limits set: microphone {NetworkServer.Configuration.MaxMicrophoneRangeMeters} m, hearing {NetworkServer.Configuration.MaxHearingRangeMeters} m.");
+        }
+
         private static void HandleGlobalToggle(NetPeer peer, string contentType, bool nowLocked)
         {
             string state = nowLocked ? "DISABLED" : "ENABLED";

Basis/Packages/com.basis.framework/BasisUI/Localization/Languages/en.json

@@ -5026,6 +5026,14 @@
       "key": "settings.admin.opusFecLoss",
       "value": "Opus FEC loss %"
     },
+    {
+      "key": "settings.admin.maxMicrophoneRange",
+      "value": "Max Microphone Range"
+    },
+    {
+      "key": "settings.admin.maxHearingRange",
+      "value": "Max Hearing Range"
+    },
     {
       "key": "settings.main.title.searchMenus",
       "value": "Search Menus"

Basis/Packages/com.basis.framework/BasisUI/Menus/Main Menu Providers/SettingsProvider.cs

@@ -771,7 +771,7 @@ void MicrophoneSelectionChanged(string name)
             // Microphone broadcast range (relocated from General).
             PanelSlider sliderMicrophoneRange = PanelSlider.CreateEntryAndBind(
                 microphoneGroup,
-                PanelSlider.SliderSettings.Distance(BasisLocalization.Get("settings.general.microphoneRange"), 25),
+                PanelSlider.SliderSettings.Distance(BasisLocalization.Get("settings.general.microphoneRange"), BasisNetworkModeration.ServerMaxMicrophoneRangeMeters),
                 BasisSettingsDefaults.MicrophoneRange);
 
             PanelToggle toggleMicrophoneDenoiser = PanelToggle.CreateNewEntry(microphoneGroup);

Basis/Packages/com.basis.framework/BasisUI/Menus/Main Menu Providers/SettingsProviderParts/SettingsProviderAdminTab.cs

@@ -98,6 +98,16 @@ public static PanelTabPage AdminTab(PanelTabGroup tabGroup)
             opusPacketLossSlider.SetValueWithoutNotify(BasisNetworkModeration.GlobalOpusPacketLossPercent);
             opusPacketLossSlider.OnValueChanged += value => BasisNetworkModeration.SetGlobalOpusPacketLoss(Mathf.RoundToInt(value));
 
+            PanelSlider maxMicrophoneRangeSlider = PanelSlider.CreateNew(PanelSlider.SliderStyles.Entry, lockGroup.ContentParent);
+            maxMicrophoneRangeSlider.SetSliderSettings(PanelSlider.SliderSettings.Advanced(BasisLocalization.Get("settings.admin.maxMicrophoneRange"), 1f, 200f, true, 0, ValueDisplayMode.Meters));
+            maxMicrophoneRangeSlider.Descriptor.SetDescription("Maximum microphone (voice transmit) range in metres any client may set. Each client's Microphone Range slider and effective range is clamped to this.");
+            maxMicrophoneRangeSlider.SetValueWithoutNotify(BasisNetworkModeration.ServerMaxMicrophoneRangeMeters);
+
+            PanelSlider maxHearingRangeSlider = PanelSlider.CreateNew(PanelSlider.SliderStyles.Entry, lockGroup.ContentParent);
+            maxHearingRangeSlider.SetSliderSettings(PanelSlider.SliderSettings.Advanced(BasisLocalization.Get("settings.admin.maxHearingRange"), 1f, 200f, true, 0, ValueDisplayMode.Meters));
+            maxHearingRangeSlider.Descriptor.SetDescription("Maximum hearing (audio receive) range in metres any client may set. Each client's Hearing Range slider and effective range is clamped to this.");
+            maxHearingRangeSlider.SetValueWithoutNotify(BasisNetworkModeration.ServerMaxHearingRangeMeters);
+
             controller.AvatarLockToggle = avatarLock;
             controller.PropLockToggle = propLock;
             controller.WorldLockToggle = worldLock;
@@ -107,6 +117,20 @@ public static PanelTabPage AdminTab(PanelTabGroup tabGroup)
             controller.HeadlessAudioToggle = headlessAudioToggle;
             controller.HeadlessDisallowToggle = disallowHeadlessToggle;
             controller.OpusPacketLossSlider = opusPacketLossSlider;
+            controller.MaxMicrophoneRangeSlider = maxMicrophoneRangeSlider;
+            controller.MaxHearingRangeSlider = maxHearingRangeSlider;
+            controller.MaxMicrophoneRangeMeters = BasisNetworkModeration.ServerMaxMicrophoneRangeMeters;
+            controller.MaxHearingRangeMeters = BasisNetworkModeration.ServerMaxHearingRangeMeters;
+            maxMicrophoneRangeSlider.OnValueChanged += value =>
+            {
+                controller.MaxMicrophoneRangeMeters = value;
+                BasisNetworkModeration.SetGlobalAudioRangeLimits(controller.MaxMicrophoneRangeMeters, controller.MaxHearingRangeMeters);
+            };
+            maxHearingRangeSlider.OnValueChanged += value =>
+            {
+                controller.MaxHearingRangeMeters = value;
+                BasisNetworkModeration.SetGlobalAudioRangeLimits(controller.MaxMicrophoneRangeMeters, controller.MaxHearingRangeMeters);
+            };
 
             // --- Camera photo metadata policy (per-category disallow; default allowed) ---
             PanelElementDescriptor cameraPolicyGroup =
@@ -425,6 +449,10 @@ private sealed class AdminTabController : MonoBehaviour
             public PanelToggle HeadlessAudioToggle;
             public PanelToggle HeadlessDisallowToggle;
             public PanelSlider OpusPacketLossSlider;
+            public PanelSlider MaxMicrophoneRangeSlider;
+            public PanelSlider MaxHearingRangeSlider;
+            public float MaxMicrophoneRangeMeters;
+            public float MaxHearingRangeMeters;
             public System.Action<byte> ApplyCameraMask;
 
             private void OnEnable()
@@ -443,6 +471,8 @@ private void OnEnable()
                 BasisNetworkModeration.OnGlobalHeadlessDisallowStateChanged += OnGlobalHeadlessDisallowStateChanged;
                 BasisNetworkModeration.OnGlobalOpusPacketLossChanged -= OnGlobalOpusPacketLossChanged;
                 BasisNetworkModeration.OnGlobalOpusPacketLossChanged += OnGlobalOpusPacketLossChanged;
+                BasisNetworkModeration.OnAudioRangeLimitsChanged -= OnAudioRangeLimitsChanged;
+                BasisNetworkModeration.OnAudioRangeLimitsChanged += OnAudioRangeLimitsChanged;
                 BasisNetworkModeration.OnGlobalCameraPolicyChanged -= OnGlobalCameraPolicyChanged;
                 BasisNetworkModeration.OnGlobalCameraPolicyChanged += OnGlobalCameraPolicyChanged;
             }
@@ -457,6 +487,7 @@ private void OnDisable()
                 BasisNetworkModeration.OnGlobalHeadlessAudioStateChanged -= OnGlobalHeadlessAudioStateChanged;
                 BasisNetworkModeration.OnGlobalHeadlessDisallowStateChanged -= OnGlobalHeadlessDisallowStateChanged;
                 BasisNetworkModeration.OnGlobalOpusPacketLossChanged -= OnGlobalOpusPacketLossChanged;
+                BasisNetworkModeration.OnAudioRangeLimitsChanged -= OnAudioRangeLimitsChanged;
                 BasisNetworkModeration.OnGlobalCameraPolicyChanged -= OnGlobalCameraPolicyChanged;
             }
 
@@ -468,6 +499,7 @@ private void OnDestroy()
                 BasisNetworkModeration.OnGlobalHeadlessAudioStateChanged -= OnGlobalHeadlessAudioStateChanged;
                 BasisNetworkModeration.OnGlobalHeadlessDisallowStateChanged -= OnGlobalHeadlessDisallowStateChanged;
                 BasisNetworkModeration.OnGlobalOpusPacketLossChanged -= OnGlobalOpusPacketLossChanged;
+                BasisNetworkModeration.OnAudioRangeLimitsChanged -= OnAudioRangeLimitsChanged;
                 BasisNetworkModeration.OnGlobalCameraPolicyChanged -= OnGlobalCameraPolicyChanged;
             }
 
@@ -504,6 +536,14 @@ private void OnGlobalOpusPacketLossChanged(int percent)
                 if (OpusPacketLossSlider != null) OpusPacketLossSlider.SetValueWithoutNotify(percent);
             }
 
+            private void OnAudioRangeLimitsChanged(float microphoneMeters, float hearingMeters)
+            {
+                MaxMicrophoneRangeMeters = microphoneMeters;
+                MaxHearingRangeMeters = hearingMeters;
+                if (MaxMicrophoneRangeSlider != null) MaxMicrophoneRangeSlider.SetValueWithoutNotify(microphoneMeters);
+                if (MaxHearingRangeSlider != null) MaxHearingRangeSlider.SetValueWithoutNotify(hearingMeters);
+            }
+
             private void OnGlobalCameraPolicyChanged(byte mask)
             {
                 ApplyCameraMask?.Invoke(mask);