feat(players): publish + relay PlayerStateChangedEvent from poll loop

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -449,6 +449,7 @@ private async Task PollMarkersAsync(
     {
         IReadOnlyList<MapMarkerSnapshot>? previous = null;
         var rigsInRadius = new HashSet<RigKind>();
+        var tracker = new TeamStateTracker();
         while (!ct.IsCancellationRequested)
         {
             var anyCh47 = false;
@@ -475,6 +476,15 @@ await eventBus.PublishAsync(
                 }
 
                 await DetectRigActivationsAsync(key, current, rigs, dims, rigsInRadius, ct).ConfigureAwait(false);
+
+                var team = await connection.GetTeamInfoAsync(_options.HeartbeatTimeout, ct).ConfigureAwait(false);
+                var transitions = tracker.Diff(team);
+                if (transitions.Count > 0)
+                {
+                    await eventBus.PublishAsync(
+                            new PlayerStateChangedEvent(key.Guild, key.Server, dims, transitions), ct)
+                        .ConfigureAwait(false);
+                }
             }
             catch (OperationCanceledException)
             {

src/RustPlusBot.Features.Players/Hosting/PlayersHostedService.cs

@@ -0,0 +1,73 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Players.Relaying;
+
+namespace RustPlusBot.Features.Players.Hosting;
+
+/// <summary>Consumes <see cref="PlayerStateChangedEvent"/> and relays each to #events + in-game chat.</summary>
+/// <param name="eventBus">The in-process event bus.</param>
+/// <param name="relay">Relays player transitions.</param>
+/// <param name="logger">The logger.</param>
+internal sealed partial class PlayersHostedService(
+    IEventBus eventBus,
+    PlayerEventRelay relay,
+    ILogger<PlayersHostedService> logger) : IHostedService, IDisposable
+{
+    private readonly CancellationTokenSource _cts = new();
+    private Task? _loop;
+
+    /// <inheritdoc />
+    public void Dispose() => _cts.Dispose();
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _loop = Task.Run(() => ConsumeAsync(_cts.Token), CancellationToken.None);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        await _cts.CancelAsync().ConfigureAwait(false);
+        if (_loop is not null)
+        {
+            try
+            {
+#pragma warning disable VSTHRD003 // Our own loop task, joined on stop.
+                await _loop.ConfigureAwait(false);
+#pragma warning restore VSTHRD003
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected on shutdown.
+            }
+        }
+    }
+
+    private async Task ConsumeAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await foreach (var evt in eventBus.SubscribeAsync<PlayerStateChangedEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                await relay.RelayAsync(evt, cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a faulting consumer must not crash the host.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogRelayLoopFaulted(logger, ex);
+        }
+    }
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Player relay loop faulted.")]
+    private static partial void LogRelayLoopFaulted(ILogger logger, Exception exception);
+}

src/RustPlusBot.Features.Players/PlayerEventServiceCollectionExtensions.cs

@@ -0,0 +1,28 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Features.Players.Hosting;
+using RustPlusBot.Features.Players.Posting;
+using RustPlusBot.Features.Players.Relaying;
+using RustPlusBot.Features.Players.Rendering;
+
+namespace RustPlusBot.Features.Players;
+
+/// <summary>DI registration for the team-presence-events feature.</summary>
+public static class PlayerEventServiceCollectionExtensions
+{
+    /// <summary>Registers the localizer, renderer, poster, relay, and hosted service.</summary>
+    /// <param name="services">The service collection to add to.</param>
+    /// <returns>The same service collection, for chaining.</returns>
+    public static IServiceCollection AddPlayers(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddSingleton(PlayerLocalizationCatalog.Default);
+        services.AddSingleton<IPlayerLocalizer, PlayerLocalizer>();
+        services.AddSingleton<PlayerEventRenderer>();
+        services.AddSingleton<IPlayerChannelPoster, DiscordPlayerChannelPoster>();
+        services.AddSingleton<PlayerEventRelay>();
+        services.AddHostedService<PlayersHostedService>();
+
+        return services;
+    }
+}

src/RustPlusBot.Host/Program.cs

@@ -11,6 +11,7 @@
 using RustPlusBot.Features.Connections;
 using RustPlusBot.Features.Events;
 using RustPlusBot.Features.Map;
+using RustPlusBot.Features.Players;
 using RustPlusBot.Features.Pairing;
 using RustPlusBot.Features.Workspace;
 using RustPlusBot.Host.Credentials;
@@ -68,6 +69,7 @@
     .ValidateOnStart();
 builder.Services.AddCommands();
 builder.Services.AddEvents();
+builder.Services.AddPlayers();
 builder.Services.AddOptions<MapOptions>()
     .Bind(builder.Configuration.GetSection("Map"))
     .Validate(static o => o.MapRefreshInterval > TimeSpan.Zero, "Map:MapRefreshInterval must be positive.")

src/RustPlusBot.Host/RustPlusBot.Host.csproj

@@ -25,5 +25,6 @@
     <ProjectReference Include="..\RustPlusBot.Features.Commands\RustPlusBot.Features.Commands.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Events\RustPlusBot.Features.Events.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Map\RustPlusBot.Features.Map.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Features.Players\RustPlusBot.Features.Players.csproj" />
   </ItemGroup>
 </Project>

tests/RustPlusBot.Features.Players.Tests/PlayerEventRegistrationTests.cs

@@ -0,0 +1,37 @@
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Players;
+using RustPlusBot.Features.Players.Hosting;
+using RustPlusBot.Features.Players.Relaying;
+using RustPlusBot.Features.Workspace.Locating;
+using RustPlusBot.Persistence.Workspace;
+
+namespace RustPlusBot.Features.Players.Tests;
+
+public sealed class PlayerEventRegistrationTests
+{
+    [Fact]
+    public void Services_resolve()
+    {
+        using var provider = BuildProvider();
+        Assert.Contains(provider.GetServices<IHostedService>(), h => h is PlayersHostedService);
+        Assert.NotNull(provider.GetRequiredService<PlayerEventRelay>());
+    }
+
+    private static ServiceProvider BuildProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddSingleton<IEventBus, InMemoryEventBus>();
+        services.AddSingleton(new DiscordSocketClient());
+        services.AddSingleton<IEventChannelLocator>(Substitute.For<IEventChannelLocator>());
+        services.AddScoped<IWorkspaceStore>(_ => Substitute.For<IWorkspaceStore>());
+        services.AddSingleton<ITeamChatSender>(Substitute.For<ITeamChatSender>());
+        services.AddPlayers();
+        return services.BuildServiceProvider(validateScopes: true);
+    }
+}