Languages

Content.Client/Input/ContentContexts.cs

@@ -55,6 +55,7 @@ public static void SetupContexts(IInputContextContainer contexts)
             human.AddFunction(ContentKeyFunctions.UseItemInHand);
             human.AddFunction(ContentKeyFunctions.AltUseItemInHand);
             human.AddFunction(ContentKeyFunctions.OpenCharacterMenu);
+            human.AddFunction(ContentKeyFunctions.OpenLanguageMenu);
             human.AddFunction(ContentKeyFunctions.ActivateItemInWorld);
             human.AddFunction(ContentKeyFunctions.ThrowItemInHand);
             human.AddFunction(ContentKeyFunctions.AltActivateItemInWorld);

Content.Client/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/Language/LanguageMenuWindow.xaml.cs

@@ -0,0 +1,134 @@
+using Content.Client.Language.Systems;
+using Content.Shared.Language;
+using Content.Shared.Language.Systems;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Console;
+using Robust.Shared.Utility;
+using Serilog;
+using static Content.Shared.Language.Systems.SharedLanguageSystem;
+
+namespace Content.Client.Language;
+
+[GenerateTypedNameReferences]
+public sealed partial class LanguageMenuWindow : DefaultWindow
+{
+    private readonly LanguageSystem _clientLanguageSystem;
+    private readonly List<EntryState> _entries = new();
+
+
+    public LanguageMenuWindow()
+    {
+        RobustXamlLoader.Load(this);
+        _clientLanguageSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<LanguageSystem>();
+    }
+
+    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();
+    }
+
+
+    public void UpdateState(string currentLanguage, List<string> 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)
+            _clientLanguageSystem.RequestSetLanguage(proto);
+    }
+
+
+    private struct EntryState
+    {
+        public string language;
+        public Button? button;
+    }
+}

Content.Client/Language/Systems/LanguageSystem.cs

@@ -0,0 +1,76 @@
+using Content.Shared.Language;
+using Content.Shared.Language.Events;
+using Content.Shared.Language.Systems;
+using Robust.Client;
+using Robust.Shared.Console;
+
+namespace Content.Client.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 string CurrentLanguage { get; private set; } = default!;
+    /// <summary>
+    ///   The list of languages the currently possessed entity can speak.
+    /// </summary>
+    public List<string> SpokenLanguages { get; private set; } = new();
+    /// <summary>
+    ///   The list of languages the currently possessed entity can understand.
+    /// </summary>
+    public List<string> UnderstoodLanguages { get; private set; } = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<LanguagesUpdatedMessage>(OnLanguagesUpdated);
+        _client.RunLevelChanged += OnRunLevelChanged;
+    }
+
+    private void OnLanguagesUpdated(LanguagesUpdatedMessage message)
+    {
+        CurrentLanguage = message.CurrentLanguage;
+        SpokenLanguages = message.Spoken;
+        UnderstoodLanguages = message.Understood;
+    }
+
+    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/Language/Systems/TranslatorImplanterSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared.Language.Systems;
+
+namespace Content.Client.Language.Systems;
+
+public sealed class TranslatorImplanterSystem : SharedTranslatorImplanterSystem
+{
+
+}

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

@@ -212,6 +212,7 @@ void AddCheckBox(string checkBoxName, bool currentState, Action<BaseButton.Butto
             AddButton(ContentKeyFunctions.OpenCraftingMenu);
             AddButton(ContentKeyFunctions.OpenGuidebook);
             AddButton(ContentKeyFunctions.OpenInventoryMenu);
+            AddButton(ContentKeyFunctions.OpenLanguageMenu);
             AddButton(ContentKeyFunctions.OpenAHelp);
             AddButton(ContentKeyFunctions.OpenActionsMenu);
             AddButton(ContentKeyFunctions.OpenEntitySpawnWindow);

Content.Client/UserInterface/Systems/Chat/Controls/ChatInputBox.cs

@@ -1,5 +1,6 @@
 using Content.Shared.Chat;
 using Content.Shared.Input;
+using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 
 namespace Content.Client.UserInterface.Systems.Chat.Controls;

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

@@ -0,0 +1,89 @@
+using Content.Client.Language;
+using Content.Client.Gameplay;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Input;
+using Content.Shared.Language.Events;
+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;
+
+namespace Content.Client.UserInterface.Systems.Language;
+
+[UsedImplicitly]
+public sealed class LanguageMenuUIController : UIController, IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>
+{
+    public LanguageMenuWindow? LanguageWindow;
+    private MenuButton? LanguageButton => UIManager.GetActiveUIWidgetOrNull<MenuBar.Widgets.GameTopMenuBar>()?.LanguageButton;
+
+    public override void Initialize()
+    {
+        SubscribeNetworkEvent((LanguagesUpdatedMessage message, EntitySessionEventArgs _) =>
+            LanguageWindow?.UpdateState(message.CurrentLanguage, message.Spoken));
+    }
+
+    public void OnStateEntered(GameplayState state)
+    {
+        DebugTools.Assert(LanguageWindow == null);
+
+        LanguageWindow = UIManager.CreateWindow<LanguageMenuWindow>();
+        LayoutContainer.SetAnchorPreset(LanguageWindow, LayoutContainer.LayoutPreset.CenterTop);
+
+        CommandBinds.Builder.Bind(ContentKeyFunctions.OpenLanguageMenu,
+            InputCmdHandler.FromDelegate(_ => ToggleWindow())).Register<LanguageMenuUIController>();
+    }
+
+    public void OnStateExited(GameplayState state)
+    {
+        if (LanguageWindow != null)
+        {
+            LanguageWindow.Dispose();
+            LanguageWindow = null;
+        }
+
+        CommandBinds.Unregister<LanguageMenuUIController>();
+    }
+
+    public void UnloadButton()
+    {
+        if (LanguageButton == null)
+            return;
+
+        LanguageButton.OnPressed -= LanguageButtonPressed;
+    }
+
+    public void LoadButton()
+    {
+        if (LanguageButton == null)
+            return;
+
+        LanguageButton.OnPressed += LanguageButtonPressed;
+
+        if (LanguageWindow == null)
+            return;
+
+        LanguageWindow.OnClose += () => LanguageButton.Pressed = false;
+        LanguageWindow.OnOpen += () => LanguageButton.Pressed = true;
+    }
+
+    private void LanguageButtonPressed(ButtonEventArgs args)
+    {
+        ToggleWindow();
+    }
+
+    private void ToggleWindow()
+    {
+        if (LanguageWindow == null)
+            return;
+
+        if (LanguageButton != null)
+            LanguageButton.SetClickPressed(!LanguageWindow.IsOpen);
+
+        if (LanguageWindow.IsOpen)
+            LanguageWindow.Close();
+        else
+            LanguageWindow.Open();
+    }
+}

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

@@ -9,6 +9,7 @@
 using Content.Client.UserInterface.Systems.MenuBar.Widgets;
 using Content.Client.UserInterface.Systems.Sandbox;
 using Robust.Client.UserInterface.Controllers;
+using Content.Client.UserInterface.Systems.Language;
 
 namespace Content.Client.UserInterface.Systems.MenuBar;
 
@@ -22,6 +23,7 @@ public sealed class GameTopMenuBarUIController : UIController
     [Dependency] private readonly ActionUIController _action = default!;
     [Dependency] private readonly SandboxUIController _sandbox = default!;
     [Dependency] private readonly GuidebookUIController _guidebook = default!;
+    [Dependency] private readonly LanguageMenuUIController _language = default!;
 
     private GameTopMenuBar? GameTopMenuBar => UIManager.GetActiveUIWidgetOrNull<GameTopMenuBar>();
 
@@ -44,6 +46,7 @@ public void UnloadButtons()
         _ahelp.UnloadButton();
         _action.UnloadButton();
         _sandbox.UnloadButton();
+        _language.UnloadButton();
     }
 
     public void LoadButtons()
@@ -56,5 +59,6 @@ public void LoadButtons()
         _ahelp.LoadButton();
         _action.LoadButton();
         _sandbox.LoadButton();
+        _language.LoadButton();
     }
 }