Add global leaderboards

Assets/Scripts/Domain/BoardGeneration.cs

@@ -4,10 +4,6 @@
 
 public static class BoardGeneration
 {
-    /// <summary>
-    /// Default cap kept for API backward compatibility. The greedy walk does not use it.
-    /// </summary>
-    private const int DefaultDeadEndLimit = 10;
     private const int MinArrowLength = 2;
 
     /// <summary>
@@ -57,12 +53,7 @@ public void EnsureCapacity(int requiredWords)
     /// </summary>
     public static readonly object FinalizationMarker = new object();
 
-    public static IEnumerator FillBoardIncremental(
-        Board board,
-        int maxLength,
-        Random random,
-        int deadEndLimit = DefaultDeadEndLimit
-    )
+    public static IEnumerator FillBoardIncremental(Board board, int maxLength, Random random)
     {
         board.InitializeForGeneration();
         int maxPossibleArrows = board.Width * board.Height / 2;
@@ -95,8 +86,7 @@ public static bool GenerateArrows(
         int maxLength,
         int amount,
         Random random,
-        out int createdArrows,
-        int deadEndLimit = DefaultDeadEndLimit
+        out int createdArrows
     )
     {
         createdArrows = 0;

Assets/Scripts/Domain/Models/ReplayData.cs

@@ -58,6 +58,8 @@ public double ComputedSolveElapsed
         {
             double elapsed = 0.0;
             DateTime checkpoint = DateTime.MinValue;
+            DateTime lastEventTime = DateTime.MinValue;
+            bool paused = false;
 
             foreach (var evt in events)
             {
@@ -66,14 +68,28 @@ public double ComputedSolveElapsed
                 switch (evt.type)
                 {
                     case ReplayEventType.StartSolve:
+                        checkpoint = ts;
+                        paused = false;
+                        break;
                     case ReplayEventType.SessionRejoin:
+                        if (!paused && checkpoint != DateTime.MinValue)
+                        {
+                            // Orphan rejoin: accumulate up to last event, skip the gap.
+                            elapsed += (lastEventTime - checkpoint).TotalSeconds;
+                        }
                         checkpoint = ts;
+                        paused = false;
                         break;
                     case ReplayEventType.SessionLeave:
-                    case ReplayEventType.EndSolve:
                         elapsed += (ts - checkpoint).TotalSeconds;
+                        paused = true;
+                        break;
+                    case ReplayEventType.EndSolve:
+                        if (!paused)
+                            elapsed += (ts - checkpoint).TotalSeconds;
                         break;
                 }
+                lastEventTime = ts;
             }
 
             return elapsed;

Assets/Scripts/Domain/ReplayPlayer.cs

@@ -45,12 +45,20 @@ public ReplayPlayer(ReplayData data)
         }
 
         if (startTime == DateTime.MinValue && _data.events.Count > 0)
+        {
             startTime = DateTime.Parse(_data.events[0].timestamp).ToUniversalTime();
+        }
 
         // We use the solve elapsed computation approach: track active time excluding pauses
         double activeTime = 0;
         DateTime checkpoint = startTime;
-        bool tracking = false;
+        // If there's no StartSolve event, start tracking from the beginning
+        bool tracking = (
+            startTime != DateTime.MinValue
+            && !_data.events.Exists(e => e.type == ReplayEventType.StartSolve)
+        );
+        bool paused = false; // true between session_leave and session_rejoin
+        DateTime lastEventTime = startTime;
 
         foreach (var evt in _data.events)
         {
@@ -61,13 +69,24 @@ public ReplayPlayer(ReplayData data)
                 case ReplayEventType.StartSolve:
                     checkpoint = ts;
                     tracking = true;
+                    paused = false;
                     break;
                 case ReplayEventType.SessionRejoin:
+                    if (!paused && tracking)
+                    {
+                        // Orphan rejoin (no preceding session_leave). The player
+                        // force-quit and resumed. Treat the previous event's time
+                        // as the implicit leave — accumulate active time up to that
+                        // point, excluding the gap between then and this rejoin.
+                        activeTime += (lastEventTime - checkpoint).TotalSeconds;
+                    }
                     checkpoint = ts;
+                    paused = false;
                     break;
                 case ReplayEventType.SessionLeave:
                     if (tracking)
                         activeTime += (ts - checkpoint).TotalSeconds;
+                    paused = true;
                     break;
                 case ReplayEventType.Clear:
                 case ReplayEventType.Reject:
@@ -83,19 +102,18 @@ public ReplayPlayer(ReplayData data)
                         activeTime += (ts - checkpoint).TotalSeconds;
                     break;
             }
+            lastEventTime = ts;
         }
 
         _eventTimes = times.ToArray();
         // Shift all event times by lead-in so early clears don't fire at t=0
         for (int i = 0; i < _eventTimes.Length; i++)
             _eventTimes[i] += LeadInSeconds;
 
+        double lastEventRaw =
+            _eventTimes.Length > 0 ? _eventTimes[_eventTimes.Length - 1] - LeadInSeconds : 0;
         double rawDuration =
-            _data.finalTime >= 0
-                ? _data.finalTime
-                : (
-                    _eventTimes.Length > 0 ? _eventTimes[_eventTimes.Length - 1] - LeadInSeconds : 0
-                );
+            _data.finalTime >= 0 ? Math.Max(_data.finalTime, lastEventRaw) : lastEventRaw;
         _totalDuration = rawDuration + LeadInSeconds + ExitPaddingSeconds;
     }
 

Assets/Scripts/Domain/ReplayRecorder.cs

@@ -55,6 +55,21 @@ public void RecordSessionLeave()
 
     public void RecordSessionRejoin()
     {
+        // If the previous session didn't end with a session_leave (e.g. force-quit),
+        // inject one using the timestamp of the last recorded event to avoid
+        // orphan rejoins that break time computation.
+        if (_events.Count > 0 && _events[_events.Count - 1].type != ReplayEventType.SessionLeave)
+        {
+            _events.Add(
+                new ReplayEvent
+                {
+                    seq = _nextSeq++,
+                    type = ReplayEventType.SessionLeave,
+                    timestamp = _events[_events.Count - 1].timestamp,
+                }
+            );
+        }
+
         _events.Add(
             new ReplayEvent
             {