Merge pull request #39 from peans99/release/0.8.35

0.8.35 - retrievals recorded again, who is with you, and what loot is worth

Author: peans99

Directory.Build.props

@@ -10,9 +10,9 @@
     <Copyright>Copyright © nekron</Copyright>
     <Description>A pilot's logbook for Star Citizen: second-screen dashboard, in-game overlay, and flight-log analysis for Star Citizen, driven by Game.log.</Description>
 
-    <Version>0.8.32</Version>
-    <AssemblyVersion>0.8.32.0</AssemblyVersion>
-    <FileVersion>0.8.32.0</FileVersion>
+    <Version>0.8.35</Version>
+    <AssemblyVersion>0.8.35.0</AssemblyVersion>
+    <FileVersion>0.8.35.0</FileVersion>
 
     <RepositoryUrl>https://github.com/peans99/QuantumWake</RepositoryUrl>
     <PackageProjectUrl>https://github.com/peans99/QuantumWake</PackageProjectUrl>

README.md

@@ -384,6 +384,31 @@ affiliated with or endorsed by Cloud Imperium Games.
 Newest first. Each version's section is what the GitHub release says too — the
 release workflow lifts it from here, so it is written once.
 
+### 0.8.35
+
+- Ship retrievals are recorded again. Game build 12519617 stopped writing the
+  log line that confirmed a retrieved ship had reached the pad, so retrievals
+  on the current build went uncounted — the ship shown for a session stayed
+  empty and sortie totals stopped rising. Quantum Wake now reads the request
+  line the game still writes. Existing sessions are re-read on upgrade, so the
+  history fills itself back in.
+
+- The Now page says who is with you. A Party card lists everyone the party
+  channel has named this session and the last thing it said about each of
+  them, so a member who dropped is not left looking like one still aboard. It
+  is a floor rather than a roster, and says so: somebody already online when
+  you grouped up is never announced, and the card stays away entirely rather
+  than showing a zero it cannot stand behind. It can be switched on in the
+  overlay widget too.
+
+- Loot says what things are worth. Each item carries the median price across
+  every terminal UEX reports stocking it — what it usually goes for, rather
+  than the cheapest run to make. The two are not the same: one item here is
+  stocked near 19,175 by a hundred terminals and at 1,975 by one, so the
+  cheapest understates it tenfold. Items UEX does not stock show a dash and
+  the reason instead of a zero, and the summary says how many of the rows
+  carry a price at all.
+
 ### 0.8.32
 
 - **Settings can save a report to send with a bug.** If a page is empty for

src/Quantumwake.Core/Parsing/LogEventParser.cs

@@ -248,12 +248,9 @@ private static string Truncate(string value) =>
                     m.Groups["flags"].Success
                         && m.Groups["flags"].Value.Contains("ShowInLog", StringComparison.Ordinal))),
 
+            "CEntityComponentShipListProvider::SetVehicleSpawningInformations" or
             "CEntityComponentShipListProvider::SetVehicleSpawnedInformations" =>
-                Match(VehicleSpawnRegex, line, m =>
-                    new VehicleSpawnEvent(
-                        line.Timestamp,
-                        m.Groups["entity"].Value,
-                        m.Groups["area"].Success ? m.Groups["area"].Value.Trim() : null)),
+                ParseVehicleSpawn(line),
 
             "AttachmentReceived" => Match(AttachmentRegex, line, m =>
                 new AttachmentEvent(
@@ -565,6 +562,36 @@ internal static (string? Manufacturer, string Model) SplitVehicleId(string vehic
         return m.Success ? project(m) : null;
     }
 
+    /// <summary>
+    /// A ship being retrieved, from either spelling of the line.
+    /// </summary>
+    /// <remarks>
+    /// Both spellings mark the same retrieval: "Spawning" when the request goes
+    /// in, "Spawned" a few seconds later once the ship is on the pad. Build
+    /// 12519617 stopped emitting "Spawned" at all, so reading only that one lost
+    /// every retrieval on current builds - and silently, because the tag simply
+    /// stopped appearing rather than failing to parse. The timestamp is
+    /// therefore the request, not the arrival, which is all the current build
+    /// offers. <see cref="SessionBuilder"/> collapses the pair by entity id, so
+    /// reading both does not double-count a retrieval on older logs.
+    ///
+    /// The ASOP terminal also emits an [Error] twin of the request line when it
+    /// cannot resolve the landing area name. It repeats an entity id already
+    /// being retrieved on the line beside it, so it is not a second retrieval
+    /// and must not count as a parse failure either.
+    /// </remarks>
+    private GameEvent? ParseVehicleSpawn(LogLine line)
+    {
+        if (line.Body.Contains("Invalid landingAreaLocStr", StringComparison.Ordinal))
+            return null;
+
+        return Match(VehicleSpawnRegex, line, m =>
+            new VehicleSpawnEvent(
+                line.Timestamp,
+                m.Groups["entity"].Value,
+                m.Groups["area"].Success ? m.Groups["area"].Value.Trim() : null));
+    }
+
     /// <summary>
     /// Fleet queries log twice: an opening "Fetching vehicle list…" line with no
     /// counts, then a completion line carrying them. Only the latter is an event;

src/Quantumwake.Core/State/Party.cs

@@ -88,6 +88,32 @@ public sealed record PartyNote(DateTimeOffset At, string? Handle, PartyMoment Mo
 /// </remarks>
 public static class Party
 {
+    /// <summary>
+    /// The latest note about each named player, most recent first.
+    /// </summary>
+    /// <remarks>
+    /// Latest-wins rather than a tally, because the moments are not commutative:
+    /// somebody who connected, dropped and connected again is present, and
+    /// counting arrivals against departures would call that a draw. Disbanded
+    /// names nobody, so it is dropped here and asked about separately.
+    ///
+    /// The result is a floor and every caller has to word it as one. A member
+    /// already online when the party formed, who never drops, is never the
+    /// subject of a toast - so absence from this list says nothing at all.
+    /// </remarks>
+    public static IReadOnlyList<PartyNote> Latest(IReadOnlyList<PartyNote> notes)
+    {
+        var latest = new Dictionary<string, PartyNote>(StringComparer.Ordinal);
+
+        foreach (var note in notes)
+        {
+            if (note.Handle is { Length: > 0 } handle)
+                latest[handle] = note;
+        }
+
+        return [.. latest.Values.OrderByDescending(note => note.At)];
+    }
+
     /// <summary>True when a notification came from the party channel at all.</summary>
     /// <remarks>
     /// Both shared titles are asked about their body rather than taken on their

src/Quantumwake.Data/OverlayLayout.cs

@@ -28,7 +28,7 @@ public sealed record OverlayLayout(
 
     /// <summary>The Now page's cards, by their data-card name.</summary>
     public static readonly IReadOnlyList<string> SelectableCards =
-        ["location", "briefing", "ship", "session", "handle", "feed", "stats", "respawn", "job", "checklist", "trip", "trade"];
+        ["location", "briefing", "ship", "session", "handle", "feed", "stats", "party", "respawn", "job", "checklist", "trip", "trade"];
 
     public static OverlayLayout Default => new(
         ["now", "map", "commodities", "market", "loadout", "stash"],

src/Quantumwake.Data/SessionStore.cs

@@ -146,7 +146,7 @@ payload      TEXT NOT NULL
     // 7: ship comms channels are kept, so sessions summarised before them know
     //    nobody was ever aboard anything and the Crew page's ships would be
     //    empty for every install except a brand new one.
-    private const int PayloadVersion = 7;
+    private const int PayloadVersion = 8;
 
 
     /// <summary>

src/Quantumwake.Data/UexData.cs

@@ -266,6 +266,37 @@ public UexData(string? directory = null)
     public decimal? ItemPrice(string? uuid) =>
         uuid is not null && _itemPrices.TryGetValue(uuid, out var price) ? price : null;
 
+    /// <summary>
+    /// What an item usually costs: the median buy price across every terminal
+    /// stocking it. Null when nothing stocks it.
+    /// </summary>
+    /// <remarks>
+    /// Median rather than mean, and deliberately not <see cref="ItemPrice"/>.
+    /// The cheapest is what you would pay having flown to the right terminal,
+    /// which is a different question from what a thing is worth, and one odd
+    /// row makes it wildly unrepresentative: this install's MaxLift Tractor
+    /// Beam is stocked by 103 terminals at about 19,175 and by one at 1,975,
+    /// so the cheapest understates it tenfold. A mean would still be dragged
+    /// by that row; a median ignores it.
+    ///
+    /// Falls back to the cheapest when the per-terminal rows are missing but a
+    /// price is known, so an item is never left unpriced over a gap in the
+    /// market table alone.
+    /// </remarks>
+    public decimal? TypicalItemPrice(string? uuid)
+    {
+        var rows = ItemMarket(uuid);
+        if (rows.Count == 0)
+            return ItemPrice(uuid);
+
+        var sorted = rows.Select(row => row.Buy).Order().ToArray();
+        var middle = sorted.Length / 2;
+
+        return sorted.Length % 2 == 1
+            ? sorted[middle]
+            : (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+
     /// <summary>Every terminal stocking an item, by uuid. Empty when unknown.</summary>
     public IReadOnlyList<UexItemRow> ItemMarket(string? uuid) =>
         uuid is not null && _itemMarket.TryGetValue(uuid, out var rows) ? rows : [];

src/Quantumwake.Server/LiveSessionService.cs

@@ -36,8 +36,28 @@ public sealed record NowState
     public int Kills { get; init; }
 
     public IReadOnlyList<TimelineEntry> RecentEvents { get; init; } = [];
+
+    /// <summary>
+    /// Everyone the party channel has named this session, most recent first.
+    /// </summary>
+    /// <remarks>
+    /// Not a roster, and the view must not present it as one. A party member who
+    /// was already online when you grouped up and never dropped produces no
+    /// toast at all, so this is a floor: everyone here was mentioned, and being
+    /// absent from it means nothing either way.
+    /// </remarks>
+    public IReadOnlyList<PartySighting> Party { get; init; } = [];
+
+    /// <summary>True once a "Party Disbanded" toast has been seen this session.</summary>
+    public bool PartyDisbanded { get; init; }
 }
 
+/// <summary>The last thing the party channel said about one player.</summary>
+/// <param name="Moment">
+/// The <see cref="PartyMoment"/> name, lowercased for display.
+/// </param>
+public sealed record PartySighting(string Handle, string Moment, DateTimeOffset At);
+
 /// <summary>SignalR hub clients subscribe to for live updates.</summary>
 public sealed class LiveHub : Hub
 {
@@ -208,10 +228,23 @@ private NowState Snapshot()
             Incapacitations = summary.Incapacitations,
             Deaths = summary.Deaths,
             Kills = summary.Kills,
-            RecentEvents = [.. _recent]
+            RecentEvents = [.. _recent],
+            Party = ReadParty(summary.PartyNotes),
+            PartyDisbanded = summary.PartyNotes.Count > 0
+                && summary.PartyNotes[^1].Moment == PartyMoment.Disbanded
         };
     }
 
+    /// <summary>
+    /// The party channel's latest word on each player, shaped for the client.
+    /// </summary>
+    private static IReadOnlyList<PartySighting> ReadParty(IReadOnlyList<PartyNote> notes) =>
+        [.. Party.Latest(notes)
+            .Select(note => new PartySighting(
+                note.Handle!,
+                note.Moment.ToString().ToLowerInvariant(),
+                note.At))];
+
     private async Task BroadcastAsync()
     {
         NowState snapshot;

src/Quantumwake.Server/ServerHost.cs

@@ -838,7 +838,20 @@ static void MustRevalidate(StaticFileResponseContext context) =>
         });
 
         // Items observed entering the player's inventories - the Loot page.
-        app.MapGet("/api/loot", (LogLibrary lib, int? days) => lib.Pickups(days ?? 0));
+        // Priced at the endpoint rather than in the library, the same join the
+        // stash uses: the item class names a community entry, which carries the
+        // uuid UEX prices against. Null price is normal and the page says so -
+        // UEX stocks 64 of this install's 109 looted classes.
+        app.MapGet("/api/loot", (LogLibrary lib, UexData uex, int? days) =>
+            lib.Pickups(days ?? 0).Select(p => new
+            {
+                p.At,
+                p.Item,
+                p.ItemClass,
+                p.Place,
+                p.Category,
+                price = uex.TypicalItemPrice(lib.Community.Item(p.ItemClass)?.Uuid)
+            }));
         app.MapGet("/api/contracts", (LogLibrary lib, int? days) => lib.Contracts(days ?? 0));
 
         // Work done per faction, and the little reputation anyone has written

tests/Quantumwake.Tests/LogEventParserTests.cs

@@ -301,6 +301,61 @@ public void Extracts_client_spawned()
         ParseOne<ClientSpawnedEvent>("<2026-08-20T01:28:58.254Z> [CSessionManager::OnClientSpawned] Spawned!");
     }
 
+    /// <summary>
+    /// The retrieval line the game writes today. Build 12519617 stopped emitting
+    /// the "Spawned" confirmation, so this spelling is the only one left - and
+    /// reading only the other one lost every retrieval on current builds without
+    /// registering as a parse failure.
+    /// </summary>
+    [Fact]
+    public void Extracts_retrieval_from_the_spawning_line()
+    {
+        var ev = ParseOne<VehicleSpawnEvent>(
+            "<2026-08-27T14:00:41.291Z> [Notice] " +
+            "<CEntityComponentShipListProvider::SetVehicleSpawningInformations> " +
+            "SetVehicleSpawningInformations - VehicleEntityId: [787284778374], LandingArea: nekron's");
+
+        Assert.Equal("787284778374", ev.EntityId);
+        Assert.Equal("nekron's", ev.LandingArea);
+    }
+
+    /// <summary>
+    /// The ASOP terminal emits an [Error] twin beside the real request when it
+    /// cannot resolve the landing area name. It names an entity already being
+    /// retrieved, so it is neither a retrieval nor a parse failure.
+    /// </summary>
+    [Fact]
+    public void Ignores_the_invalid_landing_area_twin()
+    {
+        Assert.True(LogEnvelope.TryParse(
+            "<2026-07-26T19:37:55.992Z> [Error] " +
+            "<CEntityComponentShipListProvider::SetVehicleSpawningInformations> " +
+            "SetVehicleSpawningInformations - Invalid landingAreaLocStr - " +
+            "Entity id: 738680164755 [Team_GameServices][ASOP]", out var line));
+
+        var parser = new LogEventParser();
+
+        Assert.Null(parser.Parse(line));
+        Assert.Equal(0, parser.UnmatchedKnownTags);
+    }
+
+    /// <summary>
+    /// The older confirmation line, still present in archived logs. Its extra
+    /// LandingATCId field sits between the id and the landing area.
+    /// </summary>
+    [Fact]
+    public void Extracts_retrieval_from_the_spawned_line()
+    {
+        var ev = ParseOne<VehicleSpawnEvent>(
+            "<2026-08-24T01:34:39.741Z> [Notice] " +
+            "<CEntityComponentShipListProvider::SetVehicleSpawnedInformations> " +
+            "SetVehicleSpawnedInformations - VehicleEntityId: [774736075446], " +
+            "LandingATCId: [746997539721], LandingArea: nekron's");
+
+        Assert.Equal("774736075446", ev.EntityId);
+        Assert.Equal("nekron's", ev.LandingArea);
+    }
+
     /// <summary>
     /// The session header spans several lines and only completes at FileVersion,
     /// so the parser must hold state across them.