Rank leaderboard by net WPM (speed × accuracy)

The board ranked on gross WPM (passage length ÷ time), so racing through a
passage on wrong keys posted a high speed and topped the list regardless of
accuracy. Rank by net WPM = gross × accuracy instead, so an accurate run beats
a faster, sloppier one.

NetWpm is derived from the existing Wpm/Accuracy columns (no migration, no
backfill — existing scores re-rank correctly). Results and leaderboard now
surface net WPM as the headline metric.

Author: ManuelMadu

src/Qwertide.Api/Controllers/ScoresController.cs

@@ -8,7 +8,7 @@ namespace Qwertide.Api.Controllers;
 
 /// <summary>
 /// Leaderboard endpoints (PDD §6):
-///   GET  /api/scores?top=10  - top N entries by WPM, then accuracy
+///   GET  /api/scores?top=10  - top N entries by net WPM (speed x accuracy)
 ///   POST /api/scores         - submit a new score
 /// </summary>
 [ApiController]
@@ -26,8 +26,11 @@ public async Task<ActionResult<IReadOnlyList<Score>>> GetTop([FromQuery] int top
     {
         top = Math.Clamp(top, 1, MaxTop);
 
+        // Rank by net WPM (speed x accuracy). NetWpm is [NotMapped] so it can't be
+        // translated to SQL; ordering on Wpm * Accuracy is monotonic to it and runs
+        // in the database. Accuracy then duration break ties.
         var scores = await _db.Scores
-            .OrderByDescending(s => s.Wpm)
+            .OrderByDescending(s => s.Wpm * s.Accuracy)
             .ThenByDescending(s => s.Accuracy)
             .ThenBy(s => s.DurationSecs)
             .Take(top)

src/Qwertide.Api/Models/Score.cs

@@ -1,3 +1,5 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
 namespace Qwertide.Api.Models;
 
 /// <summary>
@@ -14,6 +16,14 @@ public sealed class Score
     public double DurationSecs { get; set; }
     public int? PassageId { get; set; }
 
+    /// <summary>
+    /// Speed weighted by accuracy - the leaderboard's ranking metric. Derived from
+    /// <see cref="Wpm"/> and <see cref="Accuracy"/> rather than stored, so it stays
+    /// consistent and needs no schema change; it serializes into the API response.
+    /// </summary>
+    [NotMapped]
+    public double NetWpm => Wpm * Accuracy / 100.0;
+
     /// <summary>Server-set on insert; never trusted from the client.</summary>
     public DateTime CreatedAtUtc { get; set; } = DateTime.UtcNow;
 }

src/Qwertide.Client/Models/Score.cs

@@ -13,4 +13,7 @@ public sealed class Score
     public double DurationSecs { get; set; }
     public int? PassageId { get; set; }
     public DateTime CreatedAtUtc { get; set; } = DateTime.UtcNow;
+
+    /// <summary>Speed weighted by accuracy - the leaderboard's ranking metric.</summary>
+    public double NetWpm => Wpm * Accuracy / 100.0;
 }

src/Qwertide.Client/Pages/Leaderboard.razor

@@ -10,6 +10,7 @@
         <div>
             <div class="q-eyebrow">top runs</div>
             <h1 style="font-size:clamp(1.8rem,4vw,2.6rem);">The high tide.</h1>
+            <p style="color:var(--text-faint);font-size:0.82rem;margin-top:6px;">ranked by net wpm — raw speed weighted by accuracy.</p>
         </div>
         <button class="q-btn q-btn-primary" @onclick='() => Nav.NavigateTo("play?d=1")'>take a run</button>
     </div>
@@ -38,6 +39,7 @@
                 <tr>
                     <th class="q-rank">#</th>
                     <th>player</th>
+                    <th class="num">net</th>
                     <th class="num">wpm</th>
                     <th class="num">acc</th>
                     <th class="num">when</th>
@@ -51,7 +53,8 @@
                     <tr class="@(s.Id == Result.LastSavedScoreId ? "is-you" : null)">
                         <td class="q-rank @(rank <= 3 ? "top" : null)">@rank</td>
                         <td>@s.PlayerName</td>
-                        <td class="num q-wpm">@s.Wpm</td>
+                        <td class="num q-wpm">@s.NetWpm.ToString("0")</td>
+                        <td class="num" style="color:var(--text-faint);">@s.Wpm</td>
                         <td class="num">@s.Accuracy.ToString("0.0")%</td>
                         <td class="num" style="color:var(--text-faint);">@Ago(s.CreatedAtUtc)</td>
                     </tr>

src/Qwertide.Client/Pages/Results.razor

@@ -25,7 +25,11 @@
 
         <div class="q-result-grid q-rise-2">
             <div class="q-result-cell">
-                <div class="big">@Result.Wpm<span class="unit">wpm</span></div>
+                <div class="big">@NetWpm.ToString("0")<span class="unit">net</span></div>
+                <div class="cap">speed × accuracy · ranks you</div>
+            </div>
+            <div class="q-result-cell">
+                <div class="big neutral">@Result.Wpm<span class="unit">wpm</span></div>
                 <div class="cap">gross words / min</div>
             </div>
             <div class="q-result-cell">
@@ -77,6 +81,9 @@
     private bool _saving;
     private bool _saved;
 
+    // The leaderboard ranks on net WPM; show the player the same number they'll place by.
+    private double NetWpm => Qwertide.Client.Services.TypingSession.NetWpmFor(Result.Wpm, Result.Accuracy);
+
     private async Task Save()
     {
         if (_saving || _saved || string.IsNullOrWhiteSpace(_name)) return;

src/Qwertide.Client/Services/LocalLeaderboardService.cs

@@ -53,7 +53,7 @@ private async Task SaveAsync(List<Score> scores)
     public async Task<IReadOnlyList<Score>> GetTopAsync(int top = 10)
     {
         var all = await LoadAsync();
-        return all.OrderByDescending(s => s.Wpm).ThenByDescending(s => s.Accuracy).Take(top).ToList();
+        return all.OrderByDescending(s => s.NetWpm).ThenByDescending(s => s.Accuracy).Take(top).ToList();
     }
 
     public async Task<Score> SubmitAsync(Score score)

src/Qwertide.Client/Services/TypingSession.cs

@@ -33,6 +33,13 @@ public sealed class TypingSession
     /// <summary>Accuracy as a percentage 0-100. Guards zero keystrokes.</summary>
     public double Accuracy => AccuracyFor(CorrectKeystrokes, TotalKeystrokes);
 
+    /// <summary>
+    /// Net WPM: gross speed scaled by accuracy. This is what the leaderboard ranks
+    /// on, so racing through a passage on wrong keys (high gross WPM, low accuracy)
+    /// no longer beats a slower, accurate run.
+    /// </summary>
+    public double NetWpm => NetWpmFor(GrossWpm, Accuracy);
+
     public int ErrorCount => TotalKeystrokes - CorrectKeystrokes;
 
     /// <summary>Feed the live state computed by the component each input tick.</summary>
@@ -67,6 +74,22 @@ public static double AccuracyFor(int correctKeystrokes, int totalKeystrokes)
         return (double)correctKeystrokes / totalKeystrokes * 100.0;
     }
 
+    /// <summary>
+    /// Net WPM = gross WPM weighted by accuracy. <paramref name="accuracy"/> is a
+    /// percentage 0-100. Returns 0 when either input is non-positive (an empty or
+    /// zero-time run earns nothing). A 130 WPM run at 55% accuracy nets 71.5; a
+    /// 95 WPM run at 99% nets 94.1 - so the careful typist ranks above the masher.
+    /// </summary>
+    public static double NetWpmFor(double grossWpm, double accuracy)
+    {
+        if (grossWpm <= 0 || accuracy <= 0)
+        {
+            return 0;
+        }
+
+        return grossWpm * (accuracy / 100.0);
+    }
+
     /// <summary>
     /// Keystroke accounting for one input event. Counts EVERY new character appended
     /// to <paramref name="previousTyped"/> in this event - not just one - comparing

src/Qwertide.Client/wwwroot/css/qwertide.css

@@ -343,7 +343,7 @@ a { color: inherit; text-decoration: none; }
 /* ---- Results ------------------------------------------------------------ */
 .q-result-grid {
   display: grid;
-  grid-template-columns: 1.4fr 1fr 1fr;
+  grid-template-columns: 1.4fr 1fr 1fr 1fr;
   gap: 1px;
   background: var(--border-soft);
   border: 1px solid var(--border-soft);

src/Qwertide.Tests/NetWpmTests.cs

@@ -0,0 +1,45 @@
+using FluentAssertions;
+using Qwertide.Client.Services;
+
+namespace Qwertide.Tests;
+
+public class NetWpmTests
+{
+    [Fact]
+    public void Perfect_accuracy_leaves_speed_untouched()
+    {
+        // 100% accuracy is a x1 weight: net == gross
+        TypingSession.NetWpmFor(grossWpm: 90, accuracy: 100)
+            .Should().Be(90);
+    }
+
+    [Theory]
+    [InlineData(130, 55, 71.5)]   // the key-masher: fast but sloppy
+    [InlineData(95, 99, 94.05)]   // the careful typist: nearly all of their speed survives
+    [InlineData(100, 50, 50)]     // half the keys wrong -> half the score
+    public void Speed_is_weighted_by_accuracy(double gross, double accuracy, double expected)
+    {
+        TypingSession.NetWpmFor(gross, accuracy)
+            .Should().BeApproximately(expected, 0.001);
+    }
+
+    [Fact]
+    public void Careful_typist_outranks_the_masher()
+    {
+        // The whole point: lower gross speed can still net higher when accurate.
+        var masher = TypingSession.NetWpmFor(grossWpm: 130, accuracy: 55);
+        var careful = TypingSession.NetWpmFor(grossWpm: 95, accuracy: 99);
+
+        careful.Should().BeGreaterThan(masher);
+    }
+
+    [Theory]
+    [InlineData(0, 100)]    // no speed
+    [InlineData(90, 0)]     // nothing correct
+    [InlineData(-10, 100)]  // guard against negatives
+    [InlineData(90, -5)]
+    public void Non_positive_inputs_return_zero(double gross, double accuracy)
+    {
+        TypingSession.NetWpmFor(gross, accuracy).Should().Be(0);
+    }
+}