[Feature] Languages

Content.Client/Backmen/Language/LanguageMenuWindow.xaml

@@ -0,0 +1,18 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:ui="clr-namespace:Content.Client.UserInterface.Controls"
+               Title="{Loc language-menu-window-title}"
+               SetSize="300 300">
+    <BoxContainer Orientation="Vertical" SeparationOverride="4" MinWidth="150">
+        <PanelContainer Name="CurrentLanguageContainer" Access="Public" StyleClasses="PdaBorderRect">
+            <Label Name="CurrentLanguageLabel" Access="Public" Text="Current Language:" HorizontalExpand="True"></Label>
+        </PanelContainer>
+
+        <ui:HLine></ui:HLine>
+
+        <ScrollContainer HorizontalExpand="True" VerticalExpand="True" HScrollEnabled="False" VScrollEnabled="True" MinHeight="50">
+            <BoxContainer Name="OptionsList" Access="Public" HorizontalExpand="True" SeparationOverride="2" Orientation="Vertical">
+                <!-- The rest here is generated programmatically -->
+            </BoxContainer>
+        </ScrollContainer>
+    </BoxContainer>
+</DefaultWindow>

Content.Client/Backmen/Language/LanguageMenuWindow.xaml.cs

@@ -0,0 +1,147 @@
+using Content.Client.Backmen.Language.Systems;
+using Content.Shared.Backmen.Language;
+using Content.Shared.Backmen.Language.Events;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Backmen.Language;
+
+[GenerateTypedNameReferences]
+public sealed partial class LanguageMenuWindow : DefaultWindow, IEntityEventSubscriber
+{
+    private readonly LanguageSystem _clientLanguageSystem;
+    private readonly List<EntryState> _entries = new();
+
+
+    public LanguageMenuWindow()
+    {
+        RobustXamlLoader.Load(this);
+        _clientLanguageSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<LanguageSystem>();
+
+        _clientLanguageSystem.OnLanguagesChanged += OnUpdateState;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        _clientLanguageSystem.OnLanguagesChanged -= OnUpdateState;
+    }
+
+    protected override void Opened()
+    {
+        // Refresh the window when it gets opened.
+        // This actually causes two refreshes: one immediately, and one after the server sends a state message.
+        UpdateState(_clientLanguageSystem.CurrentLanguage, _clientLanguageSystem.SpokenLanguages);
+        _clientLanguageSystem.RequestStateUpdate();
+    }
+
+
+    private void OnUpdateState(object? sender, LanguagesUpdatedMessage args)
+    {
+        UpdateState(args.CurrentLanguage, args.Spoken);
+    }
+
+    public void UpdateState(string currentLanguage, List<ProtoId<LanguagePrototype>> spokenLanguages)
+    {
+        var langName = Loc.GetString($"language-{currentLanguage}-name");
+        CurrentLanguageLabel.Text = Loc.GetString("language-menu-current-language", ("language", langName));
+
+        OptionsList.RemoveAllChildren();
+        _entries.Clear();
+
+        foreach (var language in spokenLanguages)
+        {
+            AddLanguageEntry(language);
+        }
+
+        // Disable the button for the currently chosen language
+        foreach (var entry in _entries)
+        {
+            if (entry.button != null)
+                entry.button.Disabled = entry.language == currentLanguage;
+        }
+    }
+
+    private void AddLanguageEntry(string language)
+    {
+        var proto = _clientLanguageSystem.GetLanguagePrototype(language);
+        var state = new EntryState { language = language };
+
+        var container = new BoxContainer { Orientation = BoxContainer.LayoutOrientation.Vertical };
+
+        #region Header
+        var header = new BoxContainer
+        {
+            Orientation = BoxContainer.LayoutOrientation.Horizontal,
+            HorizontalExpand = true,
+            SeparationOverride = 2
+        };
+
+        var name = new Label
+        {
+            Text = proto?.Name ?? Loc.GetString("generic-error"),
+            MinWidth = 50,
+            HorizontalExpand = true
+        };
+
+        var button = new Button { Text = "Choose" };
+        button.OnPressed += _ => OnLanguageChosen(language);
+        state.button = button;
+
+        header.AddChild(name);
+        header.AddChild(button);
+
+        container.AddChild(header);
+        #endregion
+
+        #region Collapsible description
+        var body = new CollapsibleBody
+        {
+            HorizontalExpand = true,
+            Margin = new Thickness(4f, 4f)
+        };
+
+        var description = new RichTextLabel { HorizontalExpand = true };
+        description.SetMessage(proto?.Description ?? Loc.GetString("generic-error"));
+        body.AddChild(description);
+
+        var collapser = new Collapsible(Loc.GetString("language-menu-description-header"), body)
+        {
+            Orientation = BoxContainer.LayoutOrientation.Vertical,
+            HorizontalExpand = true
+        };
+
+        container.AddChild(collapser);
+        #endregion
+
+        // Before adding, wrap the new container in a PanelContainer to give it a distinct look
+        var wrapper = new PanelContainer();
+        wrapper.StyleClasses.Add("PdaBorderRect");
+
+        wrapper.AddChild(container);
+        OptionsList.AddChild(wrapper);
+
+        _entries.Add(state);
+    }
+
+
+    private void OnLanguageChosen(string id)
+    {
+        var proto = _clientLanguageSystem.GetLanguagePrototype(id);
+        if (proto == null)
+            return;
+
+        _clientLanguageSystem.RequestSetLanguage(proto);
+        UpdateState(id, _clientLanguageSystem.SpokenLanguages);
+    }
+
+
+    private struct EntryState
+    {
+        public string language;
+        public Button? button;
+    }
+}

Content.Client/Backmen/Language/Systems/LanguageSystem.cs

@@ -0,0 +1,82 @@
+using Content.Shared.Backmen.Language;
+using Content.Shared.Backmen.Language.Events;
+using Content.Shared.Backmen.Language.Systems;
+using Robust.Client;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Backmen.Language.Systems;
+
+/// <summary>
+///   Client-side language system.
+/// </summary>
+/// <remarks>
+///   Unlike the server, the client is not aware of other entities' languages; it's only notified about the entity that it posesses.
+///   Due to that, this system stores such information in a static manner.
+/// </remarks>
+public sealed class LanguageSystem : SharedLanguageSystem
+{
+    [Dependency] private readonly IBaseClient _client = default!;
+
+    /// <summary>
+    ///   The current language of the entity currently possessed by the player.
+    /// </summary>
+    public ProtoId<LanguagePrototype> CurrentLanguage { get; private set; } = default!;
+    /// <summary>
+    ///   The list of languages the currently possessed entity can speak.
+    /// </summary>
+    public List<ProtoId<LanguagePrototype>> SpokenLanguages { get; private set; } = new();
+    /// <summary>
+    ///   The list of languages the currently possessed entity can understand.
+    /// </summary>
+    public List<ProtoId<LanguagePrototype>> UnderstoodLanguages { get; private set; } = new();
+
+    public event EventHandler<LanguagesUpdatedMessage>? OnLanguagesChanged;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<LanguagesUpdatedMessage>(OnLanguagesUpdated);
+        _client.RunLevelChanged += OnRunLevelChanged;
+    }
+
+    private void OnLanguagesUpdated(LanguagesUpdatedMessage message)
+    {
+        // TODO this entire thing is horrible. If someone is willing to refactor this, LanguageSpeakerComponent should become shared with SendOnlyToOwner = true
+        // That way, this system will be able to use the existing networking infrastructure instead of relying on this makeshift... whatever this is.
+        CurrentLanguage = message.CurrentLanguage;
+        SpokenLanguages = message.Spoken;
+        UnderstoodLanguages = message.Understood;
+
+        OnLanguagesChanged?.Invoke(this, message);
+    }
+
+    private void OnRunLevelChanged(object? sender, RunLevelChangedEventArgs args)
+    {
+        // Request an update when entering a game
+        if (args.NewLevel == ClientRunLevel.InGame)
+            RequestStateUpdate();
+    }
+
+    /// <summary>
+    ///   Sends a network request to the server to update this system's state.
+    ///   The server may ignore the said request if the player is not possessing an entity.
+    /// </summary>
+    public void RequestStateUpdate()
+    {
+        RaiseNetworkEvent(new RequestLanguagesMessage());
+    }
+
+    public void RequestSetLanguage(LanguagePrototype language)
+    {
+        if (language.ID == CurrentLanguage)
+            return;
+
+        RaiseNetworkEvent(new LanguagesSetMessage(language.ID));
+
+        // May cause some minor desync...
+        // So to reduce the probability of desync, we replicate the change locally too
+        if (SpokenLanguages.Contains(language.ID))
+            CurrentLanguage = language.ID;
+    }
+}

Content.Client/Backmen/UserInterface/Systems/Language/LanguageMenuUIController.cs

@@ -0,0 +1,104 @@
+using Content.Client.Backmen.Language;
+using Content.Client.Backmen.Language.Systems;
+using Content.Client.Gameplay;
+using Content.Client.UserInterface.Controls;
+using Content.Client.UserInterface.Systems.MenuBar.Widgets;
+using Content.Shared.Input;
+using Robust.Client.UserInterface.Controllers;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Utility;
+using static Robust.Client.UserInterface.Controls.BaseButton;
+using JetBrains.Annotations;
+using Robust.Client.Input;
+
+namespace Content.Client.Backmen.UserInterface.Systems.Language;
+
+[UsedImplicitly]
+public sealed class LanguageMenuUIController :
+    UIController,
+    IOnStateEntered<GameplayState>,
+    IOnStateExited<GameplayState>,
+    IOnSystemChanged<LanguageSystem>
+{
+    [Dependency] private readonly IInputManager _input = default!;
+    public LanguageMenuWindow? LanguageWindow;
+
+    private MenuButton? LanguageButton =>
+        UIManager.GetActiveUIWidgetOrNull<GameTopMenuBar>()?.LanguageButton;
+
+    public void OnStateEntered(GameplayState state)
+    {
+        DebugTools.Assert(LanguageWindow == null);
+
+        LanguageWindow = UIManager.CreateWindow<LanguageMenuWindow>();
+        LayoutContainer.SetAnchorPreset(LanguageWindow, LayoutContainer.LayoutPreset.CenterTop);
+
+        LanguageWindow.OnClose += () =>
+        {
+            if (LanguageButton != null)
+                LanguageButton.Pressed = false;
+        };
+        LanguageWindow.OnOpen += () =>
+        {
+            if (LanguageButton != null)
+                LanguageButton.Pressed = true;
+        };
+    }
+
+
+    public void OnStateExited(GameplayState state)
+    {
+        if (LanguageWindow == null)
+            return;
+
+        LanguageWindow.Dispose();
+        LanguageWindow = null;
+    }
+
+    public void UnloadButton()
+    {
+        if (LanguageButton == null)
+            return;
+
+        LanguageButton.OnPressed -= LanguageButtonPressed;
+    }
+
+    public void LoadButton()
+    {
+        if (LanguageButton == null)
+            return;
+
+        LanguageButton.OnPressed += LanguageButtonPressed;
+    }
+
+    private void LanguageButtonPressed(ButtonEventArgs args)
+    {
+        ToggleWindow();
+    }
+
+    private void ToggleWindow()
+    {
+        if (LanguageWindow == null)
+            return;
+
+        LanguageButton?.SetClickPressed(!LanguageWindow.IsOpen);
+
+        if (LanguageWindow.IsOpen)
+            LanguageWindow.Close();
+        else
+            LanguageWindow.Open();
+    }
+
+    public void OnSystemLoaded(LanguageSystem system)
+    {
+        _input.SetInputCommand(ContentKeyFunctions.OpenLanguageMenu,
+            InputCmdHandler.FromDelegate(_ => ToggleWindow()));
+    }
+
+    public void OnSystemUnloaded(LanguageSystem system)
+    {
+        LanguageWindow?.Dispose();
+        CommandBinds.Unregister<LanguageMenuUIController>();
+    }
+}

Content.Client/Input/ContentContexts.cs

@@ -61,6 +61,7 @@ public static void SetupContexts(IInputContextContainer contexts)
             human.AddFunction(ContentKeyFunctions.UseItemInHand);
             human.AddFunction(ContentKeyFunctions.AltUseItemInHand);
             human.AddFunction(ContentKeyFunctions.OpenCharacterMenu);
+            human.AddFunction(ContentKeyFunctions.OpenLanguageMenu); //backmen: languages
             human.AddFunction(ContentKeyFunctions.OpenEmotesMenu);
             human.AddFunction(ContentKeyFunctions.ActivateItemInWorld);
             human.AddFunction(ContentKeyFunctions.ThrowItemInHand);

Content.Client/Options/UI/Tabs/KeyRebindTab.xaml.cs

@@ -240,6 +240,7 @@ void HandleToggleAutoGetUp(BaseButton.ButtonToggledEventArgs args) // WD EDIT
             AddButton(ContentKeyFunctions.OpenCraftingMenu);
             AddButton(ContentKeyFunctions.OpenGuidebook);
             AddButton(ContentKeyFunctions.OpenInventoryMenu);
+            AddButton(ContentKeyFunctions.OpenLanguageMenu); //backmen: languages
             AddButton(ContentKeyFunctions.OpenAHelp);
             AddButton(ContentKeyFunctions.OpenActionsMenu);
             AddButton(ContentKeyFunctions.OpenEmotesMenu);

Content.Client/UserInterface/Systems/MenuBar/GameTopMenuBarUIController.cs

@@ -1,3 +1,4 @@
+using Content.Client.Backmen.UserInterface.Systems.Language;
 using Content.Client.UserInterface.Systems.Actions;
 using Content.Client.UserInterface.Systems.Admin;
 using Content.Client.UserInterface.Systems.Bwoink;
@@ -24,6 +25,7 @@ public sealed class GameTopMenuBarUIController : UIController
     [Dependency] private readonly SandboxUIController _sandbox = default!;
     [Dependency] private readonly GuidebookUIController _guidebook = default!;
     [Dependency] private readonly EmotesUIController _emotes = default!;
+    [Dependency] private readonly LanguageMenuUIController _language = default!;
 
     private GameTopMenuBar? GameTopMenuBar => UIManager.GetActiveUIWidgetOrNull<GameTopMenuBar>();
 
@@ -47,6 +49,7 @@ public void UnloadButtons()
         _action.UnloadButton();
         _sandbox.UnloadButton();
         _emotes.UnloadButton();
+        _language.UnloadButton();
     }
 
     public void LoadButtons()
@@ -60,5 +63,6 @@ public void LoadButtons()
         _action.LoadButton();
         _sandbox.LoadButton();
         _emotes.LoadButton();
+        _language.LoadButton();
     }
 }