feat(2a): add EventEmbedRenderer + EN/FR event localization

Implements the pure event rendering layer: EventLocalizationCatalog with EN/FR
strings for cargo, helicopter, and Chinook events; IEventLocalizer/EventLocalizer
for localization; EventEmbedRenderer to build Discord embeds with grid references.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Events/Rendering/EventEmbedRenderer.cs

@@ -0,0 +1,35 @@
+using Discord;
+using RustPlusBot.Features.Events.Classifying;
+using RustPlusBot.Features.Events.Formatting;
+
+namespace RustPlusBot.Features.Events.Rendering;
+
+/// <summary>Renders one <see cref="RustMapEvent"/> as a Discord embed.</summary>
+/// <param name="localizer">The reply localizer.</param>
+internal sealed class EventEmbedRenderer(IEventLocalizer localizer)
+{
+    /// <summary>Renders the event for a guild culture.</summary>
+    /// <param name="evt">The event to render.</param>
+    /// <param name="culture">The guild culture ("en"/"fr").</param>
+    /// <returns>The built embed.</returns>
+    public Embed Render(RustMapEvent evt, string culture)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        var grid = GridReference.From(evt.X, evt.Y, evt.Dimensions);
+        var key = evt.Kind switch
+        {
+            MapEventKind.CargoEntered => "event.cargo.entered",
+            MapEventKind.CargoLeft => "event.cargo.left",
+            MapEventKind.HeliEntered => "event.heli.entered",
+            MapEventKind.HeliLeft => "event.heli.left",
+            MapEventKind.ChinookSpawned => "event.chinook.spawned",
+            _ => "event.chinook.spawned",
+        };
+
+        return new EmbedBuilder()
+            .WithAuthor(localizer.Get("event.title", culture))
+            .WithDescription(localizer.Get(key, culture, grid))
+            .WithTimestamp(evt.AtUtc)
+            .Build();
+    }
+}

src/RustPlusBot.Features.Events/Rendering/EventLocalizationCatalog.cs

@@ -0,0 +1,34 @@
+namespace RustPlusBot.Features.Events.Rendering;
+
+/// <summary>The in-memory string catalog for live events: culture -> (key -> value). English is the fallback.</summary>
+internal sealed class EventLocalizationCatalog
+{
+    /// <summary>culture -> key -> value.</summary>
+    public required IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> Strings { get; init; }
+
+    /// <summary>The built-in EN/FR catalog.</summary>
+    public static EventLocalizationCatalog Default { get; } = new()
+    {
+        Strings = new Dictionary<string, IReadOnlyDictionary<string, string>>(StringComparer.Ordinal)
+        {
+            ["en"] = new Dictionary<string, string>(StringComparer.Ordinal)
+            {
+                ["event.cargo.entered"] = "🚢 Cargo Ship entered at {0}",
+                ["event.cargo.left"] = "🚢 Cargo Ship left ({0})",
+                ["event.heli.entered"] = "🚁 Patrol Helicopter entered at {0}",
+                ["event.heli.left"] = "🚁 Patrol Helicopter left ({0})",
+                ["event.chinook.spawned"] = "🚁 Chinook spawned at {0}",
+                ["event.title"] = "Live event",
+            },
+            ["fr"] = new Dictionary<string, string>(StringComparer.Ordinal)
+            {
+                ["event.cargo.entered"] = "🚢 Cargo Ship arrivé en {0}",
+                ["event.cargo.left"] = "🚢 Cargo Ship parti ({0})",
+                ["event.heli.entered"] = "🚁 Hélicoptère de patrouille arrivé en {0}",
+                ["event.heli.left"] = "🚁 Hélicoptère de patrouille parti ({0})",
+                ["event.chinook.spawned"] = "🚁 Chinook apparu en {0}",
+                ["event.title"] = "Événement",
+            },
+        },
+    };
+}

src/RustPlusBot.Features.Events/Rendering/EventLocalizer.cs

@@ -0,0 +1,61 @@
+using System.Globalization;
+
+namespace RustPlusBot.Features.Events.Rendering;
+
+/// <summary>Dictionary-backed <see cref="IEventLocalizer"/> with English fallback and region normalization.</summary>
+/// <remarks>Duplicated from the command/workspace localizers; consolidate into a shared project in a future refactor.</remarks>
+/// <param name="catalog">The string catalog.</param>
+internal sealed class EventLocalizer(EventLocalizationCatalog catalog) : IEventLocalizer
+{
+    private const string FallbackCulture = "en";
+
+    /// <inheritdoc />
+    public string Get(string key, string culture)
+    {
+        var normalized = Normalize(culture);
+        if (catalog.Strings.TryGetValue(normalized, out var map) && map.TryGetValue(key, out var value))
+        {
+            return value;
+        }
+
+        if (catalog.Strings.TryGetValue(FallbackCulture, out var fallback) &&
+            fallback.TryGetValue(key, out var fallbackValue))
+        {
+            return fallbackValue;
+        }
+
+        return key;
+    }
+
+    /// <inheritdoc />
+    public string Get(string key, string culture, params object[] args)
+    {
+        var format = Get(key, culture);
+        var provider = ResolveFormatProvider(Normalize(culture));
+        return string.Format(provider, format, args);
+    }
+
+    private static string Normalize(string culture)
+    {
+        if (string.IsNullOrWhiteSpace(culture))
+        {
+            return FallbackCulture;
+        }
+
+        var dash = culture.IndexOf('-', StringComparison.Ordinal);
+        var primary = dash >= 0 ? culture[..dash] : culture;
+        return primary.ToLowerInvariant();
+    }
+
+    private static CultureInfo ResolveFormatProvider(string culture)
+    {
+        try
+        {
+            return CultureInfo.GetCultureInfo(culture);
+        }
+        catch (CultureNotFoundException)
+        {
+            return CultureInfo.InvariantCulture;
+        }
+    }
+}

src/RustPlusBot.Features.Events/Rendering/IEventLocalizer.cs

@@ -0,0 +1,16 @@
+namespace RustPlusBot.Features.Events.Rendering;
+
+/// <summary>Resolves localized live-event strings by key and culture, falling back to English.</summary>
+internal interface IEventLocalizer
+{
+    /// <summary>Gets the localized string for a key, or the key itself if not found.</summary>
+    /// <param name="key">The string key.</param>
+    /// <param name="culture">The BCP-47 culture tag (e.g. "en", "fr").</param>
+    string Get(string key, string culture);
+
+    /// <summary>Gets the localized, format-applied string.</summary>
+    /// <param name="key">The string key.</param>
+    /// <param name="culture">The BCP-47 culture tag.</param>
+    /// <param name="args">Format arguments.</param>
+    string Get(string key, string culture, params object[] args);
+}

tests/RustPlusBot.Features.Events.Tests/Rendering/EventEmbedRendererTests.cs

@@ -0,0 +1,37 @@
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Events.Classifying;
+using RustPlusBot.Features.Events.Rendering;
+
+namespace RustPlusBot.Features.Events.Tests.Rendering;
+
+public sealed class EventEmbedRendererTests
+{
+    private static readonly DateTimeOffset Now = new(2026, 6, 17, 12, 0, 0, TimeSpan.Zero);
+
+    private static EventEmbedRenderer Build() =>
+        new(new EventLocalizer(EventLocalizationCatalog.Default));
+
+    [Fact]
+    public void Cargo_entered_renders_english_with_grid()
+    {
+        var dims = new MapDimensions(4000u, 4000u, 500);
+        var embed = Build().Render(new RustMapEvent(MapEventKind.CargoEntered, 10f, 3990f, dims, Now), "en");
+
+        Assert.NotNull(embed.Description);
+        Assert.Contains("Cargo Ship entered", embed.Description, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Chinook_spawned_renders_french()
+    {
+        var embed = Build().Render(new RustMapEvent(MapEventKind.ChinookSpawned, 0f, 0f, null, Now), "fr");
+        Assert.Contains("Chinook apparu", embed.Description, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Null_dimensions_render_raw_coordinates()
+    {
+        var embed = Build().Render(new RustMapEvent(MapEventKind.HeliEntered, 1234f, 5678f, null, Now), "en");
+        Assert.Contains("(1234, 5678)", embed.Description, StringComparison.Ordinal);
+    }
+}

tests/RustPlusBot.Features.Events.Tests/Rendering/EventLocalizerTests.cs

@@ -0,0 +1,28 @@
+using RustPlusBot.Features.Events.Rendering;
+
+namespace RustPlusBot.Features.Events.Tests.Rendering;
+
+public sealed class EventLocalizerTests
+{
+    private static readonly EventLocalizer Sut = new(EventLocalizationCatalog.Default);
+
+    [Fact]
+    public void ReturnsFrench_WhenCultureFr() =>
+        Assert.Equal("🚁 Chinook apparu en {0}", Sut.Get("event.chinook.spawned", "fr"));
+
+    [Fact]
+    public void ReturnsEnglish_WhenCultureEn() =>
+        Assert.Equal("🚁 Chinook spawned at {0}", Sut.Get("event.chinook.spawned", "en"));
+
+    [Fact]
+    public void FallsBackToEnglish_WhenCultureUnknown() =>
+        Assert.Equal("🚁 Chinook spawned at {0}", Sut.Get("event.chinook.spawned", "xx"));
+
+    [Fact]
+    public void ReturnsKey_WhenKeyUnknown() =>
+        Assert.Equal("unknown.key", Sut.Get("unknown.key", "en"));
+
+    [Fact]
+    public void NormalizesRegion() =>
+        Assert.Equal("🚁 Chinook apparu en {0}", Sut.Get("event.chinook.spawned", "fr-FR"));
+}