Merge branch 'more-bug-fixes' into developer

Author: dooly123

Basis Server/BasisNetworkClientConsole/BasisNetworkClientConsole/ClientManager.cs

@@ -181,7 +181,10 @@ public async Task StartClientsAsync()
                     BNL.Log($"Connecting: {name} ({identity.Did})");
                 }
 
-                await Task.Delay(1, cts.Token);
+                if (ConfigManager.ClientConnectIntervalMs > 0)
+                {
+                    await Task.Delay(ConfigManager.ClientConnectIntervalMs, cts.Token);
+                }
             }
         }
         public async Task ReconnectClientAsync(int index)

Basis Server/BasisNetworkClientConsole/BasisNetworkClientConsole/ConfigManager.cs

@@ -8,6 +8,7 @@ public static class ConfigManager
         public static string Ip = "localhost";
         public static int Port = 4296;
         public static int ClientCount = 250;
+        public static int ClientConnectIntervalMs = 1;
 
         public static string AvatarPassword = "default_avatar_password";
         public static string AvatarUrl = "http://localhost/avatar";
@@ -180,6 +181,8 @@ public static void LoadOrCreateConfigXml(string filePath)
                                 new XElement("Port", Port),
                                 new XComment(" Number of simulated clients to spawn for load testing. int (>= 1); higher counts need more CPU, memory and sockets. "),
                                 new XElement("ClientCount", ClientCount),
+                                new XComment(" Delay in ms between starting each simulated client's connection, controlling how fast the crowd ramps up. 0 or less starts them as fast as the loop runs. int. "),
+                                new XElement("ClientConnectIntervalMs", ClientConnectIntervalMs),
                                 new XComment(" Avatar unlock password/key sent with the avatar; used to decrypt the (encrypted .BEE) bundle at <AvatarUrl>. string. "),
                                 new XElement("AvatarPassword", AvatarPassword),
                                 new XComment(" Avatar source each fake client advertises. For AvatarLoadMode 0 this is the (encrypted .BEE) bundle download URL. string. "),
@@ -276,6 +279,7 @@ public static void LoadOrCreateConfigXml(string filePath)
                     Ip = ReadString(root, "Ip", Ip);
                     Port = ReadInt(root, "Port", Port);
                     ClientCount = ReadInt(root, "ClientCount", ClientCount);
+                    ClientConnectIntervalMs = ReadInt(root, "ClientConnectIntervalMs", ClientConnectIntervalMs);
 
                     AvatarPassword = ReadString(root, "AvatarPassword", AvatarPassword);
                     AvatarUrl = ReadString(root, "AvatarUrl", AvatarUrl);

Basis Server/BasisNetworkClientConsole/BasisNetworkClientConsole/FakePoseGenerator.cs

@@ -149,9 +149,6 @@ public static void WriteBoneRotations(byte[] dst, int byteOffset, BitQuality qua
 
             for (int slot = 0; slot < WireBoneCount; slot++)
             {
-                int bitsPerComp = bpc[slot];
-                int totalBits = 2 + 3 * bitsPerComp;
-
                 // Every slot animates every frame — a load-test sender must produce fresh
                 // rotation bits per send like a real tracked human, not a frozen statue.
                 int idx = slot * 4;
@@ -162,7 +159,10 @@ public static void WriteBoneRotations(byte[] dst, int byteOffset, BitQuality qua
                 QuatMul(bx, by, bz, bw, dx, dy, dz, dw, out float rx, out float ry, out float rz, out float rw);
                 Normalize(ref rx, ref ry, ref rz, ref rw);
 
-                ulong packed = BasisBoneRotationCompression.EncodeSmallestThree(rx, ry, rz, rw, bitsPerComp, ranges[slot]);
+                int totalBits = BasisBoneRotationCompression.BoneFieldWidth(quality, slot);
+                ulong packed = BasisBoneRotationCompression.BONE_DOF[slot] == 3
+                    ? BasisBoneRotationCompression.EncodeSmallestThree(rx, ry, rz, rw, bpc[slot], ranges[slot])
+                    : BasisBoneRotationCompression.EncodeRestricted(rx, ry, rz, rw, slot, quality);
 
                 BasisBoneRotationCompression.WriteBits(dst, baseBit + offsets[slot], packed, totalBits);
             }
@@ -352,8 +352,13 @@ private static void GetIdleDelta(int slot, double t, float phase, out float dx,
                     frequency *= 1f + 0.07f * (slot % 3);
                     float angle = amplitude * MathF.Sin((float)(t * frequency * TwoPi + p * 1.1f + slot * 0.61f));
 
-                    // Cycle the rotation axis per slot so motion isn't uniformly single-axis.
-                    switch (slot % 3)
+                    // Restricted slots (v52) only carry their anatomical axes on the wire, so
+                    // animate the hinge axis — motion on a dropped axis would encode to silence.
+                    // Full 3-DOF slots keep the per-slot axis cycle so motion isn't single-axis.
+                    int axisCode = BasisBoneRotationCompression.BONE_DOF[slot] == 3
+                        ? slot % 3
+                        : BasisBoneRotationCompression.BONE_AXIS_A[slot];
+                    switch (axisCode)
                     {
                         case 0: AxisAngleToQuat(1, 0, 0, angle, out dx, out dy, out dz, out dw); break;
                         case 1: AxisAngleToQuat(0, 1, 0, angle, out dx, out dy, out dz, out dw); break;

Basis Server/BasisNetworkCore/BasisNetworkVersion.cs

@@ -2,6 +2,8 @@ namespace Basis.Network.Core
 {
     public class BasisNetworkVersion
     {
-        public static ushort ServerVersion = 51;
+        // 52: restricted-DOF bone encoding — 2-DOF limb/extremity joints and 1-DOF toes ship
+        // quantized angles instead of smallest-three quaternions (wire-format change).
+        public static ushort ServerVersion = 52;
     }
 }

Basis Server/BasisNetworkCore/BasisServerConfiguration.cs

@@ -104,6 +104,24 @@ public class Configuration
     /// When false, clients upload full keyframes only (legacy behavior).
     /// </summary>
     public bool EnableUplinkAvatarDelta = true;
+    /// <summary>
+    /// Hold shared images in server RAM so a joining player is handed them immediately, instead of
+    /// the original sharer having to re-upload every image to each arrival. Costs memory; saves the
+    /// sharer's uplink and gets pictures on the wall far sooner in a busy instance.
+    /// </summary>
+    public bool ImageCacheEnabled = true;
+    /// <summary>
+    /// Ceiling on the image cache, in megabytes. Set 0 to hold nothing (equivalent to disabling the
+    /// cache). This is a hard cap on retained payloads, not a target.
+    /// </summary>
+    public int ImageCacheMaxMegabytes = 512;
+    /// <summary>
+    /// Floor on one player's slice of the cache, in megabytes. The buffer is divided evenly between
+    /// everyone currently holding images so nobody can crowd anyone else out; without a floor a busy
+    /// instance would shrink each share below a single image and cache nothing at all. An owner over
+    /// their share evicts their own oldest image, never another player's.
+    /// </summary>
+    public int ImageCacheMinimumPerOwnerMegabytes = 32;
     public bool EnableBSRProfiling = false;
     /// <summary>
     /// Worker cap for the BSR tick's parallel phases (send loop, message processing, distance
@@ -345,8 +363,43 @@ public void ProcessEnvironmentalOverrides()
         ApplyEnvironmentalOverridesTo(this);
     }
 
+    /// <summary>
+    /// Settings established once during boot — socket binds, the transport stack, the health and
+    /// API listeners, the console, and disk support. Editing one persists and takes effect on the
+    /// next start; everything else is re-applied live by NetworkServer.ApplyLiveConfiguration.
+    /// </summary>
+    private static readonly string[] RestartOnlyFields =
+    {
+        nameof(SetPort),
+        nameof(IPv4Address),
+        nameof(IPv6Address),
+        nameof(OverrideAutoDiscoveryOfIpv),
+        nameof(NetworkStackId),
+        nameof(HasFileSupport),
+        nameof(EnableStatistics),
+        nameof(EnableConsole),
+        nameof(HealthCheckHost),
+        nameof(HealthCheckPort),
+        nameof(HealthPath),
+        nameof(ApiEnabled),
+        nameof(ApiHost),
+        nameof(ApiPort),
+        nameof(ApiKey),
+    };
+
+    /// <summary>Whether a field only takes effect after a restart. See <see cref="RestartOnlyFields"/>.</summary>
+    public static bool RequiresRestart(string fieldName) =>
+        Array.IndexOf(RestartOnlyFields, fieldName) >= 0;
+
+    /// <summary>
+    /// Settings a connected client is told about at join time only, so an edit reaches new joiners
+    /// but leaves the existing crowd on the value they connected with.
+    /// </summary>
+    public static bool AppliesToNewJoinsOnly(string fieldName) =>
+        fieldName == nameof(BSRSlowestSendRate);
+
     /// <summary>Field names whose values must never reach the log.</summary>
-    private static bool IsSecretFieldName(string fieldName)
+    public static bool IsSecretFieldName(string fieldName)
     {
         if (string.IsNullOrEmpty(fieldName)) return false;
         return fieldName.IndexOf("password", StringComparison.OrdinalIgnoreCase) >= 0

Basis Server/BasisNetworkCore/Compression/BasisAvatarChannelMap.cs

@@ -174,11 +174,26 @@ private static BasisAvatarChannelLayout Build(BasisAvatarBitPacking.BitQuality q
             {
                 fieldFirst[BasisAvatarDeltaCompression.BoneFieldStart + slot] = channels.Count;
                 int b = rotBase + fieldOffsets[slot];
-                // Smallest-three: the 2-bit index selects which component was dropped, so it changes
-                // what the other three MEAN. Differencing across an index change is nonsense — Raw.
-                channels.Add(new BasisAvatarChannel(b, 2, BasisChannelKind.Raw));
-                for (int c = 0; c < 3; c++)
-                    channels.Add(new BasisAvatarChannel(b + 2 + c * bpc[slot], bpc[slot], BasisChannelKind.Delta));
+                switch (BasisBoneRotationCompression.BONE_DOF[slot])
+                {
+                    case 3:
+                        // Smallest-three: the 2-bit index selects which component was dropped, so it
+                        // changes what the other three MEAN. Differencing across an index change is
+                        // nonsense — Raw.
+                        channels.Add(new BasisAvatarChannel(b, 2, BasisChannelKind.Raw));
+                        for (int c = 0; c < 3; c++)
+                            channels.Add(new BasisAvatarChannel(b + 2 + c * bpc[slot], bpc[slot], BasisChannelKind.Delta));
+                        break;
+                    case 2:
+                        // Hinge + twist angles: uniformly quantized scalars, both deltable.
+                        int hingeBits = BasisBoneRotationCompression.HingeBits(q);
+                        channels.Add(new BasisAvatarChannel(b, hingeBits, BasisChannelKind.Delta));
+                        channels.Add(new BasisAvatarChannel(b + hingeBits, BasisBoneRotationCompression.TwistBits(q), BasisChannelKind.Delta));
+                        break;
+                    default:
+                        channels.Add(new BasisAvatarChannel(b, BasisBoneRotationCompression.SingleAxisBits(q), BasisChannelKind.Delta));
+                        break;
+                }
             }
 
             for (int f = 0; f < BasisBoneRotationCompression.FingerChannelCount; f++)