feat: show active players vote selection, total votes and option to hide reminder if already voted

Author: wopian

Configuration/ConfigService.cs

@@ -16,6 +16,7 @@ public class ConfigService : IEagerService
     public ConfigEntry<bool> SubmitRecords { get; private set; }
     public ConfigEntry<bool> ShowRecordSubmitMessage { get; private set; }
     public ConfigEntry<float> ShowRecordSubmitMessageDuration { get; private set; }
+    public ConfigEntry<bool> ShowVoteReminderAfterVoting { get; private set; }
 
     public ConfigEntry<bool> EnableGhosts { get; private set; }
 
@@ -82,6 +83,7 @@ public ConfigService(ConfigFile config, Plugin plugin)
         ConfigDiscord(config);
         ConfigUrls(config);
         ConfigPlayback(config);
+        ConfigChatMessages(config);
 
         SettingsApi.ConfigureModSettingsTabs(plugin, builder =>
         {
@@ -96,6 +98,8 @@ public ConfigService(ConfigFile config, Plugin plugin)
                 "3. Record Holder - General",
                 "3.1 Record Holder - Visibility",
                 "3.2 Record Holder - Keys");
+            builder.Tab("Chat Messages",
+                "7. Chat Messages");
             builder.Tab("Other",
                 "4. Discord",
                 "5. URLs");
@@ -310,6 +314,15 @@ private void ConfigUrls(ConfigFile config)
             "Use http://127.0.0.1:5000/ instead of production GraphQL");
     }
 
+    private void ConfigChatMessages(ConfigFile config)
+    {
+        ShowVoteReminderAfterVoting = config.Bind(
+            "7. Chat Messages",
+            "1. Show Vote Reminder After Voting",
+            true,
+            "Should the vote reminder be shown when you have already voted on the current level");
+    }
+
     private void ConfigPlayback(ConfigFile config)
     {
         ShowTimeline = config.Bind(

GraphQL/Queries/GetLevelVoteSummary.graphql

@@ -0,0 +1,21 @@
+query GetLevelVoteSummary($xxHash: String!, $steamId: BigInt!) {
+    voteCounts: votes(filter: { level: { xxHash: { equalTo: $xxHash } } }) {
+        groupedAggregates(groupBy: [VALUE]) {
+            keys
+            distinctCount {
+                userId
+            }
+        }
+    }
+    currentVote: votes(
+        first: 1
+        filter: {
+            level: { xxHash: { equalTo: $xxHash } }
+            user: { steamId: { equalTo: $steamId } }
+        }
+    ) {
+        nodes {
+            value
+        }
+    }
+}

Plugin.cs

@@ -115,6 +115,7 @@ private void ConfigureServices(IServiceCollection services)
         services.AddEagerService<DiscordService>();
         services.AddEagerService<UnhandledExceptionLoggerService>();
         services.AddEagerService<VotingService>();
+        services.AddSingleton<VotingGraphqlService>();
         services.AddSingleton<AssetService>();
         services.AddSingleton<GhostReaderFactory>();
         services.AddSingleton<GhostRecorderFactory>();

Voting/VoteReminderFormatter.cs

@@ -0,0 +1,37 @@
+using System.Globalization;
+
+namespace TNRD.Zeepkist.GTR.Voting;
+
+public static class VoteReminderFormatter
+{
+    public static bool ShouldShow(bool showAfterVoting, VoteSummary summary)
+    {
+        return showAfterVoting || !summary.CurrentVote.HasValue;
+    }
+
+    public static string Format(VoteSummary summary)
+    {
+        return
+            "<size=80%><color=#FFFF00>Cast your vote for ZeepCentraal:</color></size><br>" +
+            "<size=75%>" +
+            "<size=50%><i>(hated it)</i></size> " +
+            FormatChoice(summary, -2, "--", "#FF0000") + " " +
+            FormatChoice(summary, -1, "-", "#FF8000") + " " +
+            FormatChoice(summary, 0, "-+/+-", "#FFFF00") + " " +
+            FormatChoice(summary, 1, "+", "#80FF00") + " " +
+            FormatChoice(summary, 2, "++", "#00FF00") + " " +
+            "<size=50%><i>(loved it)</i></size>" +
+            "</size>";
+    }
+
+    private static string FormatChoice(VoteSummary summary, int voteValue, string label, string colour)
+    {
+        string choice = $"<b><color={colour}>{label}</color></b>";
+        if (summary.CurrentVote == voteValue)
+            choice = $"[{choice}]";
+
+        long? count = summary.GetCount(voteValue);
+        string countText = count?.ToString(CultureInfo.InvariantCulture) ?? "?";
+        return $"{choice} <size=50%>({countText})</size>";
+    }
+}

Voting/VoteSummary.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace TNRD.Zeepkist.GTR.Voting;
+
+public class VoteSummary
+{
+    private readonly IReadOnlyDictionary<int, long> _counts;
+
+    public static VoteSummary Unknown { get; } = new(null, null);
+
+    public int? CurrentVote { get; }
+    public bool CountsKnown => _counts != null;
+
+    public VoteSummary(IReadOnlyDictionary<int, long> counts, int? currentVote)
+    {
+        _counts = counts;
+        CurrentVote = currentVote is >= -2 and <= 2 ? currentVote : null;
+    }
+
+    public long? GetCount(int voteValue)
+    {
+        if (_counts == null)
+            return null;
+
+        return _counts.TryGetValue(voteValue, out long count) ? count : 0;
+    }
+}

Voting/VotingGraphqlService.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using StrawberryShake;
+using ZeepSDK.External.Cysharp.Threading.Tasks;
+using ZeepSDK.External.FluentResults;
+
+namespace TNRD.Zeepkist.GTR.Voting;
+
+public class VotingGraphqlService
+{
+    private readonly IGtrClient _gtrClient;
+
+    public VotingGraphqlService(IGtrClient gtrClient)
+    {
+        _gtrClient = gtrClient;
+    }
+
+    public async UniTask<Result<VoteSummary>> GetVoteSummary(string xxHash, ulong steamId,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            IOperationResult<IGetLevelVoteSummaryResult> result =
+                await _gtrClient.GetLevelVoteSummary.ExecuteAsync(
+                    xxHash,
+                    steamId.ToString(CultureInfo.InvariantCulture),
+                    cancellationToken);
+            result.EnsureNoErrors();
+
+            var counts = new Dictionary<int, long>
+            {
+                [-2] = 0,
+                [-1] = 0,
+                [0] = 0,
+                [1] = 0,
+                [2] = 0
+            };
+
+            IReadOnlyList<IGetLevelVoteSummary_VoteCounts_GroupedAggregates> groupedAggregates =
+                result.Data.VoteCounts?.GroupedAggregates;
+            if (groupedAggregates != null)
+            {
+                foreach (IGetLevelVoteSummary_VoteCounts_GroupedAggregates aggregate in groupedAggregates)
+                {
+                    string key = aggregate.Keys?.FirstOrDefault();
+                    string count = aggregate.DistinctCount?.UserId;
+                    if (int.TryParse(key, NumberStyles.Integer, CultureInfo.InvariantCulture, out int voteValue) &&
+                        voteValue is >= -2 and <= 2 &&
+                        long.TryParse(count, NumberStyles.Integer, CultureInfo.InvariantCulture, out long voteCount))
+                    {
+                        counts[voteValue] = voteCount;
+                    }
+                }
+            }
+
+            int? currentVote = result.Data.CurrentVote?.Nodes.FirstOrDefault()?.Value;
+            return Result.Ok(new VoteSummary(counts, currentVote));
+        }
+        catch (Exception e)
+        {
+            return Result.Fail(new ExceptionalError(e));
+        }
+    }
+}

Voting/VotingService.cs

@@ -1,13 +1,17 @@
 using System;
 using System.Net.Http;
+using System.Threading;
 using JetBrains.Annotations;
 using Microsoft.Extensions.Logging;
+using Steamworks;
 using TNRD.Zeepkist.GTR.Api;
+using TNRD.Zeepkist.GTR.Configuration;
 using TNRD.Zeepkist.GTR.Core;
 using TNRD.Zeepkist.GTR.PlayerLoop;
 using ZeepkistClient;
 using ZeepSDK.Chat;
 using ZeepSDK.External.Cysharp.Threading.Tasks;
+using ZeepSDK.External.FluentResults;
 using ZeepSDK.Level;
 using ZeepSDK.Messaging;
 using ZeepSDK.Multiplayer;
@@ -23,43 +27,79 @@ public class VotingService : IEagerService
     private readonly PlayerLoopService _playerLoopService;
     private readonly ILogger<VotingService> _logger;
     private readonly ApiHttpClient _apiHttpClient;
+    private readonly ConfigService _configService;
+    private readonly VotingGraphqlService _votingGraphqlService;
 
     private string _previousTimeLeft;
+    private int _reminderRequestVersion;
 
     public VotingService(PlayerLoopService playerLoopService, ILogger<VotingService> logger,
-        ApiHttpClient apiHttpClient)
+        ApiHttpClient apiHttpClient, ConfigService configService, VotingGraphqlService votingGraphqlService)
     {
         _playerLoopService = playerLoopService;
         _logger = logger;
         _apiHttpClient = apiHttpClient;
+        _configService = configService;
+        _votingGraphqlService = votingGraphqlService;
         _playerLoopService.SubscribeUpdate(OnUpdate);
     }
 
     private void OnUpdate()
     {
         if (!MultiplayerApi.IsPlayingOnline)
+        {
+            if (_previousTimeLeft != null)
+            {
+                _previousTimeLeft = null;
+                _reminderRequestVersion++;
+            }
             return;
+        }
 
         string currentTimeLeft = ZeepkistNetwork.CurrentLobby.timeLeftString;
 
         if (currentTimeLeft == TIME_LEFT && _previousTimeLeft != TIME_LEFT)
+            ShowVoteReminderAsync(++_reminderRequestVersion).Forget();
+
+        _previousTimeLeft = currentTimeLeft;
+    }
+
+    private async UniTaskVoid ShowVoteReminderAsync(int requestVersion)
+    {
+        string currentHash = LevelApi.CurrentHashV2?.Hash;
+        VoteSummary summary = VoteSummary.Unknown;
+
+        if (string.IsNullOrEmpty(currentHash))
         {
-            ChatApi.AddLocalMessage(
-                "<size=80%><color=#FFFF00>Cast your vote for ZeepCentraal:</color></size><br>" +
-                "<size=75%>" +
-                "<size=50%><i>(hated it)</i></size> " +
-                "<b><color=#FF0000>--</color></b> " +
-                "<b><color=#FF8000>-</color></b> " +
-                "<b><color=#FFFF00>-+</color>/<color=#FFFF00>+-</color></b> " +
-                "<b><color=#80FF00>+</color></b> " +
-                "<b><color=#00FF00>++</color></b> " +
-                "<size=50%><i>(loved it)</i></size>" +
-                "</size>"
-            );
+            _logger.LogError("Unable to get vote summary because current level hash is empty");
+        }
+        else
+        {
+            Result<VoteSummary> result = await _votingGraphqlService.GetVoteSummary(
+                currentHash,
+                SteamClient.SteamId.Value,
+                CancellationToken.None);
+            if (result.IsSuccess)
+            {
+                summary = result.Value;
+            }
+            else
+            {
+                _logger.LogError("Failed to get vote summary: {Result}", result);
+            }
+        }
 
+        if (requestVersion != _reminderRequestVersion ||
+            !MultiplayerApi.IsPlayingOnline ||
+            !string.Equals(currentHash, LevelApi.CurrentHashV2?.Hash, StringComparison.Ordinal))
+        {
+            return;
         }
 
-        _previousTimeLeft = currentTimeLeft;
+        if (!VoteReminderFormatter.ShouldShow(_configService.ShowVoteReminderAfterVoting.Value, summary))
+            return;
+
+        ChatApi.AddLocalMessage(VoteReminderFormatter.Format(summary));
     }
 
     private void OnVoteSuccess(string vote)

Zeepkist.GTR.Mod.Tests/VoteReminderFormatterTests.cs

@@ -0,0 +1,76 @@
+using TNRD.Zeepkist.GTR.Voting;
+using Xunit;
+
+namespace TNRD.Zeepkist.GTR.Tests;
+
+public class VoteReminderFormatterTests
+{
+    [Fact]
+    public void FormatsCountsAndHighlightsCurrentVote()
+    {
+        var summary = new VoteSummary(
+            new Dictionary<int, long>
+            {
+                [-2] = 0,
+                [-1] = 3,
+                [0] = 0,
+                [1] = 4,
+                [2] = 8
+            },
+            2);
+
+        string message = VoteReminderFormatter.Format(summary);
+
+        Assert.Contains("<size=50%>(3)</size>", message);
+        Assert.Contains("<size=50%>(8)</size>", message);
+        Assert.Contains("[<b><color=#00FF00>++</color></b>]", message);
+        Assert.DoesNotContain("[<b><color=#80FF00>+</color></b>]", message);
+    }
+
+    [Fact]
+    public void HighlightsEntireNeutralVoteLabel()
+    {
+        var summary = new VoteSummary(new Dictionary<int, long>(), 0);
+
+        string message = VoteReminderFormatter.Format(summary);
+
+        Assert.Contains("[<b><color=#FFFF00>-+/+-</color></b>]", message);
+    }
+
+    [Fact]
+    public void MissingKnownGroupsUseZeroCounts()
+    {
+        var summary = new VoteSummary(new Dictionary<int, long> { [2] = 8 }, null);
+
+        string message = VoteReminderFormatter.Format(summary);
+
+        Assert.Equal(4, CountOccurrences(message, "<size=50%>(0)</size>"));
+        Assert.Equal(1, CountOccurrences(message, "<size=50%>(8)</size>"));
+    }
+
+    [Fact]
+    public void UnknownSummaryUsesQuestionMarkCountsWithoutHighlight()
+    {
+        string message = VoteReminderFormatter.Format(VoteSummary.Unknown);
+
+        Assert.Equal(5, CountOccurrences(message, "<size=50%>(?)</size>"));
+        Assert.DoesNotContain("[<b>", message);
+    }
+
+    [Fact]
+    public void ReminderPolicyOnlyHidesConfirmedExistingVote()
+    {
+        var voted = new VoteSummary(new Dictionary<int, long>(), 1);
+        var unvoted = new VoteSummary(new Dictionary<int, long>(), null);
+
+        Assert.True(VoteReminderFormatter.ShouldShow(true, voted));
+        Assert.False(VoteReminderFormatter.ShouldShow(false, voted));
+        Assert.True(VoteReminderFormatter.ShouldShow(false, unvoted));
+        Assert.True(VoteReminderFormatter.ShouldShow(false, VoteSummary.Unknown));
+    }
+
+    private static int CountOccurrences(string value, string expected)
+    {
+        return value.Split(new[] { expected }, StringSplitOptions.None).Length - 1;
+    }
+}