Localization support for any prototypes

Robust.Shared/Localization/ILocalizationManager.cs

@@ -2,6 +2,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using JetBrains.Annotations;
+using Linguini.Bundle;
+using Linguini.Syntax.Ast;
+using Robust.Shared.ContentPack;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
 
 namespace Robust.Shared.Localization
@@ -122,6 +126,16 @@ public interface ILocalizationManager
         ///     Gets localization data for an entity prototype.
         /// </summary>
         EntityLocData GetEntityData(string prototypeId);
+
+        /// <summary>
+        ///     Gets localization data for a prototype.
+        /// </summary>
+        PrototypeLocData GetPrototypeData(Type kind, string prototypeId);
+
+        /// <summary>
+        ///     Gets localization data for a prototype.
+        /// </summary>
+        PrototypeLocData GetPrototypeData<T>(string prototypeId) where T : class, IPrototype, ILocalizedPrototype;
     }
 
     internal interface ILocalizationManagerInternal : ILocalizationManager

Robust.Shared/Localization/LocalizationManager.Prototypes.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Linguini.Bundle.Errors;
+using Robust.Shared.Prototypes;
+
+namespace Robust.Shared.Localization;
+
+internal sealed partial class LocalizationManager
+{
+    // Concurrent dict so that multiple threads "reading" .Name won't cause a concurrent write issue
+    // when the cache gets populated.
+    private readonly ConcurrentDictionary<string, PrototypeLocData> _prototypeCache = new();
+
+    private void FlushPrototypeCache()
+    {
+        _logSawmill.Debug("Flushing entity localization cache.");
+        _entityCache.Clear();
+    }
+
+    // Flush caches conservatively on prototype/localization changes.
+    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
+    {
+        if (args.ByType.ContainsKey(typeof(EntityPrototype)))
+            FlushEntityCache();
+
+        FlushPrototypeCache();
+    }
+
+    private PrototypeLocData CalcInheritingPrototypeLoc<T>(string prototypeId) where T : class, IPrototype, IInheritingPrototype, ILocalizedPrototype
+    {
+        return CalcInheritingPrototypeLoc(typeof(T), prototypeId);
+    }
+
+    private PrototypeLocData CalcInheritingPrototypeLoc(Type kind, string prototypeId)
+    {
+        string? name = null;
+        string? desc = null;
+
+        foreach (var prototype in _prototype.EnumerateParents(kind, prototypeId, true))
+        {
+            var lproto = (ILocalizedPrototype)prototype;
+            var locId = $"{lproto.CustomLocalizationPrefix}-{prototypeId}";
+
+            if (TryGetMessage(locId, out var bundle, out var msg))
+            {
+                // Localization override exists.
+                var msgAttrs = msg.Attributes;
+
+                if (name == null && msg.Value != null)
+                {
+                    // Only set name if the value isn't empty.
+                    // So that you can override *only* a desc.
+                    name = bundle.FormatPattern(msg.Value, null, out var fmtErr);
+                    WriteWarningForErrs(fmtErr, locId);
+                }
+
+                if (msgAttrs.Count != 0)
+                {
+                    var allErrors = new List<FluentError>();
+                    if (desc == null
+                        && !bundle.TryGetMsg(locId, "desc", null, out var err1, out desc))
+                    {
+                        desc = null;
+                        allErrors.AddRange(err1);
+                    }
+
+                    WriteWarningForErrs(allErrors, locId);
+                }
+            }
+
+            name ??= lproto.SetName;
+            desc ??= lproto.SetDesc;
+        }
+
+        return new PrototypeLocData(
+            name ?? "",
+            desc ?? "");
+    }
+
+    private PrototypeLocData CalcPrototypeLoc<T>(string prototypeId) where T : class, IPrototype, ILocalizedPrototype
+    {
+        return CalcPrototypeLoc(typeof(T), prototypeId);
+    }
+
+    private PrototypeLocData CalcPrototypeLoc(Type kind, string prototypeId)
+    {
+        string? name = null;
+        string? desc = null;
+
+        // Return empty strings if no prototype found
+        if (!_prototype.TryIndex(kind, prototypeId, out var prototype))
+            return new PrototypeLocData("", "");
+
+        var lproto = (ILocalizedPrototype)prototype;
+        var locId = $"{lproto.CustomLocalizationPrefix}-{prototypeId}";
+
+        if (!TryGetMessage(locId, out var bundle, out var msg)
+            || msg.Value == null)
+            return new PrototypeLocData(lproto.SetName ?? "", lproto.SetDesc ?? "");
+
+        name = bundle.FormatPattern(msg.Value, null, out var fmtErr);
+
+        if (!bundle.TryGetMsg(locId, "desc", null, out var err1, out desc))
+        {
+            return new PrototypeLocData(name ?? "", lproto.SetDesc ?? "");
+        }
+
+        return new PrototypeLocData(name ?? "", desc);
+    }
+
+    public PrototypeLocData GetPrototypeData(Type kind, string prototypeId)
+    {
+        if (kind.IsAssignableTo(typeof(IInheritingPrototype)))
+            return _prototypeCache.GetOrAdd(prototypeId, (id, t) => t.CalcInheritingPrototypeLoc(kind, id), this);
+        return _prototypeCache.GetOrAdd(prototypeId, (id, t) => t.CalcPrototypeLoc(kind, id), this);
+    }
+
+    public PrototypeLocData GetPrototypeData<T>(string prototypeId) where T: class, IPrototype, ILocalizedPrototype
+    {
+        return GetPrototypeData(typeof(T), prototypeId);
+    }
+}

Robust.Shared/Localization/PrototypeLocData.cs

@@ -0,0 +1,10 @@
+namespace Robust.Shared.Localization;
+
+/// <summary>
+///     Contains based localized prototype data.
+/// </summary>
+/// <param name="Name">The localized name of the prototype.</param>
+/// <param name="Desc">The localized description of the prototype.</param>
+public record PrototypeLocData(
+    string Name,
+    string Desc);

Robust.Shared/Prototypes/IPrototype.cs

@@ -1,5 +1,6 @@
 using System;
 using JetBrains.Annotations;
+using Robust.Shared.Localization;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 using Robust.Shared.Serialization.TypeSerializers.Interfaces;
@@ -32,6 +33,20 @@ public interface IInheritingPrototype
         bool Abstract { get; }
     }
 
+    public interface ILocalizedPrototype
+    {
+
+        [DataField("name")] public string? SetName { get; }
+
+        [DataField("description")] public string? SetDesc { get; }
+
+        [ViewVariables] public string Name { get; }
+
+        [ViewVariables] public string Description { get; }
+
+        public string? CustomLocalizationPrefix { get; }
+    }
+
     public sealed class IdDataFieldAttribute : DataFieldAttribute
     {
         public const string Name = "id";