UI HUGE UPDATE

Assets/_mainSpine/op/serverSelector.cs

@@ -9,6 +9,7 @@ public class serverSelector : MonoBehaviour
 {
     private const string DefaultServerUrl = "http://47.112.187.172:8080";
     private const float RefreshIntervalSeconds = 5f;
+    private const float StatusCacheDurationSeconds = 60f;
 
     [Header("button")]
     [SerializeField] private Button serverSelectorButton;
@@ -16,6 +17,7 @@ public class serverSelector : MonoBehaviour
     [Header("text")]
     [SerializeField] private Text currentServerName;
     [SerializeField] private Image currentServerStatus;
+    [SerializeField] private uServerStatus currentServerStatusDisplay;
 
     [Header("Server Status Sprites")]
     [SerializeField] private Sprite serverOkaySprite;
@@ -33,6 +35,10 @@ public class serverSelector : MonoBehaviour
     [SerializeField] private float requestTimeoutSeconds = 5f;
 
     private Coroutine _pollCoroutine;
+    private bool _started;
+    private static bool s_hasCachedStatus;
+    private static uServerStatus.ServerStatus s_cachedStatus;
+    private static DateTime s_lastValidationUtc;
 
     [Serializable]
     private class ServerStatusResponse
@@ -62,6 +68,8 @@ public class serverSelector : MonoBehaviour
 
     private void Start()
     {
+        _started = true;
+
         if (serverSelectorPanel != null)
         {
             serverSelectorPanel.SetActive(false);
@@ -69,20 +77,38 @@ public class serverSelector : MonoBehaviour
 
         if (OnlineModeSettings.IsLocalOnlyMode)
         {
-            ApplySprite(userOfflineSprite != null ? userOfflineSprite : serverErrorSprite);
+            ApplyStatus(uServerStatus.ServerStatus.Offline);
             return;
         }
 
-        ApplySprite(userOfflineSprite != null ? userOfflineSprite : serverErrorSprite);
-        _pollCoroutine = StartCoroutine(StatusPollLoop());
+        StartOrRestartPolling(refreshImmediately: true);
     }
 
     private void OnEnable()
     {
-        if (_pollCoroutine == null && Application.isPlaying && !OnlineModeSettings.IsLocalOnlyMode)
+        if (!_started || !Application.isPlaying)
         {
-            _pollCoroutine = StartCoroutine(StatusPollLoop());
+            return;
         }
+
+        if (OnlineModeSettings.IsLocalOnlyMode)
+        {
+            ApplyStatus(uServerStatus.ServerStatus.Offline);
+            return;
+        }
+
+        StartOrRestartPolling(refreshImmediately: true);
+    }
+
+    private void StartOrRestartPolling(bool refreshImmediately)
+    {
+        if (_pollCoroutine != null)
+        {
+            StopCoroutine(_pollCoroutine);
+            _pollCoroutine = null;
+        }
+
+        _pollCoroutine = StartCoroutine(StatusPollLoop(refreshImmediately));
     }
 
     private void OnDisable()
@@ -94,12 +120,26 @@ public class serverSelector : MonoBehaviour
         }
     }
 
-    private IEnumerator StatusPollLoop()
+    private IEnumerator StatusPollLoop(bool refreshImmediately)
     {
+        if (refreshImmediately)
+        {
+            if (TryApplyFreshCachedStatus())
+            {
+                float remainingLockDuration = GetRemainingCacheLockSeconds();
+                if (remainingLockDuration > 0f)
+                {
+                    yield return new WaitForSecondsRealtime(remainingLockDuration);
+                }
+            }
+
+            yield return RefreshServerStatus();
+        }
+
         while (true)
         {
-            yield return RefreshServerStatus();
             yield return new WaitForSecondsRealtime(RefreshIntervalSeconds);
+            yield return RefreshServerStatus();
         }
     }
 
@@ -107,18 +147,17 @@ public class serverSelector : MonoBehaviour
     {
         if (OnlineModeSettings.IsLocalOnlyMode)
         {
-            ApplySprite(userOfflineSprite != null ? userOfflineSprite : serverErrorSprite);
+            ApplyStatus(uServerStatus.ServerStatus.Offline);
             yield break;
         }
 
         if (Application.internetReachability == NetworkReachability.NotReachable)
         {
-            ApplySprite(userOfflineSprite);
+            ApplyStatus(uServerStatus.ServerStatus.Offline);
             yield break;
         }
 
         string statusUrl = BuildServerStatusUrl();
-        ApplySprite(serverSupportingSprite);
         using (UnityWebRequest request = UnityWebRequest.Get(statusUrl))
         {
             request.timeout = Mathf.Max(1, Mathf.RoundToInt(requestTimeoutSeconds));
@@ -126,14 +165,14 @@ public class serverSelector : MonoBehaviour
 
             if (request.result != UnityWebRequest.Result.Success)
             {
-                ApplySprite(serverErrorSprite);
+                CacheAndApplyStatus(uServerStatus.ServerStatus.Unreachable);
                 yield break;
             }
 
             string responseText = request.downloadHandler != null ? request.downloadHandler.text : string.Empty;
             if (string.IsNullOrWhiteSpace(responseText))
             {
-                ApplySprite(serverErrorSprite);
+                CacheAndApplyStatus(uServerStatus.ServerStatus.Unreachable);
                 yield break;
             }
 
@@ -144,31 +183,17 @@ public class serverSelector : MonoBehaviour
             }
             catch
             {
-                ApplySprite(serverErrorSprite);
+                CacheAndApplyStatus(uServerStatus.ServerStatus.Unreachable);
                 yield break;
             }
 
             if (response == null || !response.success)
             {
-                ApplySprite(serverErrorSprite);
+                CacheAndApplyStatus(uServerStatus.ServerStatus.Unreachable);
                 yield break;
             }
 
-            switch ((response.server_state ?? string.Empty).Trim().ToUpperInvariant())
-            {
-                case "MAINTENANCE":
-                    ApplySprite(serverSupportingSprite);
-                    break;
-                case "BUSY":
-                    ApplySprite(serverBusySprite);
-                    break;
-                case "OK":
-                    ApplySprite(serverOkaySprite);
-                    break;
-                default:
-                    ApplySprite(serverErrorSprite);
-                    break;
-            }
+            CacheAndApplyStatus(ResolveStatus(response));
         }
     }
 
@@ -181,11 +206,11 @@ public class serverSelector : MonoBehaviour
 
         if (!OnlineModeSettings.IsLocalOnlyMode)
         {
-            StartCoroutine(RefreshServerStatus());
+            StartCoroutine(RefreshServerStatusIfNeeded());
         }
         else
         {
-            ApplySprite(userOfflineSprite != null ? userOfflineSprite : serverErrorSprite);
+            ApplyStatus(uServerStatus.ServerStatus.Offline);
         }
     }
 
@@ -213,13 +238,127 @@ public class serverSelector : MonoBehaviour
         return $"{ResolveServerBaseUrl()}/api/server-status";
     }
 
-    private void ApplySprite(Sprite sprite)
+    private IEnumerator RefreshServerStatusIfNeeded()
     {
+        if (TryApplyFreshCachedStatus())
+        {
+            yield break;
+        }
+
+        yield return RefreshServerStatus();
+    }
+
+    private uServerStatus.ServerStatus ResolveStatus(ServerStatusResponse response)
+    {
+        if (response == null)
+        {
+            return uServerStatus.ServerStatus.Unreachable;
+        }
+
+        if (response.maintenance_enabled)
+        {
+            return uServerStatus.ServerStatus.Maintenance;
+        }
+
+        string normalizedState = (response.server_state ?? string.Empty).Trim().ToUpperInvariant();
+        switch (normalizedState)
+        {
+            case "MAINTENANCE":
+                return uServerStatus.ServerStatus.Maintenance;
+            case "BUSY":
+                return uServerStatus.ServerStatus.Fair;
+            case "OK":
+                if (response.busy_qps_threshold > 0f &&
+                    response.requests_per_second >= response.busy_qps_threshold)
+                {
+                    return uServerStatus.ServerStatus.Fair;
+                }
+
+                return uServerStatus.ServerStatus.Good;
+            default:
+                return uServerStatus.ServerStatus.Unknown;
+        }
+    }
+
+    private bool TryApplyFreshCachedStatus()
+    {
+        if (!HasFreshCachedStatus())
+        {
+            return false;
+        }
+
+        ApplyStatus(s_cachedStatus);
+        return true;
+    }
+
+    private bool HasFreshCachedStatus()
+    {
+        if (!s_hasCachedStatus)
+        {
+            return false;
+        }
+
+        return (DateTime.UtcNow - s_lastValidationUtc).TotalSeconds < StatusCacheDurationSeconds;
+    }
+
+    private float GetRemainingCacheLockSeconds()
+    {
+        if (!s_hasCachedStatus)
+        {
+            return 0f;
+        }
+
+        double elapsedSeconds = (DateTime.UtcNow - s_lastValidationUtc).TotalSeconds;
+        return Mathf.Max(0f, StatusCacheDurationSeconds - (float)elapsedSeconds);
+    }
+
+    private void CacheAndApplyStatus(uServerStatus.ServerStatus status)
+    {
+        s_cachedStatus = status;
+        s_lastValidationUtc = DateTime.UtcNow;
+        s_hasCachedStatus = true;
+        ApplyStatus(status);
+    }
+
+    private Sprite ResolveSpriteForStatus(uServerStatus.ServerStatus status)
+    {
+        switch (status)
+        {
+            case uServerStatus.ServerStatus.Good:
+                return serverOkaySprite;
+            case uServerStatus.ServerStatus.Fair:
+                return serverBusySprite;
+            case uServerStatus.ServerStatus.Maintenance:
+                return serverSupportingSprite;
+            case uServerStatus.ServerStatus.Offline:
+                return userOfflineSprite != null ? userOfflineSprite : serverErrorSprite;
+            case uServerStatus.ServerStatus.Unreachable:
+            case uServerStatus.ServerStatus.Unknown:
+            case uServerStatus.ServerStatus.Test:
+            default:
+                return serverErrorSprite;
+        }
+    }
+
+    private void ApplyStatus(uServerStatus.ServerStatus status)
+    {
+        Sprite sprite = ResolveSpriteForStatus(status);
+
         if (currentServerStatus == null || sprite == null)
         {
+            if (currentServerStatusDisplay != null)
+            {
+                currentServerStatusDisplay.SetStatus(status);
+            }
+
             return;
         }
 
         currentServerStatus.sprite = sprite;
+
+        if (currentServerStatusDisplay != null)
+        {
+            currentServerStatusDisplay.SetStatus(status);
+        }
     }
 }