rbertoche
diff --git a/‎Content.Client/Eye/EyeLerpingSystem.cs‎
Lines changed: 104 additions & 33 deletions b/‎Content.Client/Eye/EyeLerpingSystem.cs‎
Lines changed: 104 additions & 33 deletions
diff --git a/‎Content.Client/FlavorText/FlavorText.xaml‎
Lines changed: 5 additions & 0 deletions b/‎Content.Client/FlavorText/FlavorText.xaml‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎Content.Client/FlavorText/FlavorText.xaml.cs‎
Lines changed: 25 additions & 0 deletions b/‎Content.Client/FlavorText/FlavorText.xaml.cs‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎Content.Client/Lobby/LobbyState.cs‎
Lines changed: 3 additions & 1 deletion b/‎Content.Client/Lobby/LobbyState.cs‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎Content.Client/Preferences/UI/CharacterSetupGui.xaml.cs‎
Lines changed: 6 additions & 2 deletions b/‎Content.Client/Preferences/UI/CharacterSetupGui.xaml.cs‎
Lines changed: 6 additions & 2 deletions
diff --git a/‎Content.Client/Preferences/UI/HumanoidProfileEditor.xaml‎
Lines changed: 2 additions & 1 deletion b/‎Content.Client/Preferences/UI/HumanoidProfileEditor.xaml‎
Lines changed: 2 additions & 1 deletion
@@ -6,6 +6,7 @@
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Timing;
 
@@ -14,100 +15,154 @@ namespace Content.Client.Eye;
 public sealed class EyeLerpingSystem : EntitySystem
 {
     [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IGameTiming _gameTiming = default!;
 
-    private Angle? _lastGridAngle;
-    private Angle? _lerpTo;
-    private Angle _lerpStartRotation;
-    private float _accumulator;
-
     // How fast the camera rotates in radians / s
     private const float CameraRotateSpeed = MathF.PI;
 
     // Safety override
     private const float LerpTimeMax = 1.5f;
 
+    // Lerping information for the player's active eye.
+    private readonly EyeLerpInformation _playerActiveEye = new();
+
+    // Eyes other than the primary eye that are currently active.
+    private readonly Dictionary<EntityUid, EyeLerpInformation> _activeEyes = new();
+    private readonly List<EntityUid> _toRemove = new();
 
     public override void Initialize()
     {
         base.Initialize();
 
+        SubscribeLocalEvent<EyeComponent, ComponentShutdown>(OnEyeShutdown);
+
         UpdatesAfter.Add(typeof(TransformSystem));
         UpdatesAfter.Add(typeof(PhysicsSystem));
         UpdatesBefore.Add(typeof(EyeUpdateSystem));
     }
 
+    private void OnEyeShutdown(EntityUid uid, EyeComponent component, ComponentShutdown args)
+    {
+        RemoveEye(uid);
+    }
+
+    public void AddEye(EntityUid uid)
+    {
+        if (!_activeEyes.ContainsKey(uid))
+        {
+            _activeEyes.Add(uid, new());
+        }
+    }
+
+    public void RemoveEye(EntityUid uid)
+    {
+        if (_activeEyes.ContainsKey(uid))
+        {
+            _activeEyes.Remove(uid);
+        }
+    }
+
     public override void FrameUpdate(float frameTime)
     {
         if (!_gameTiming.IsFirstTimePredicted)
             return;
 
-        var currentEye = _eyeManager.CurrentEye;
+        // Always do this one.
+        LerpPlayerEye(frameTime);
+
+        foreach (var (entity, info) in _activeEyes)
+        {
+            LerpEntityEye(entity, info, frameTime);
+        }
+
+        if (_toRemove.Count != 0)
+        {
+            foreach (var entity in _toRemove)
+            {
+                RemoveEye(entity);
+            }
+
+            _toRemove.Clear();
+        }
+    }
 
+    private void LerpPlayerEye(float frameTime)
+    {
         if (_playerManager.LocalPlayer?.ControlledEntity is not {} mob || Deleted(mob))
             return;
 
         // We can't lerp if the mob can't move!
         if (!TryComp(mob, out IMoverComponent? mover))
             return;
 
-        var moverLastGridAngle = mover.LastGridAngle;
+        LerpEye(_eyeManager.CurrentEye, frameTime, mover.LastGridAngle, _playerActiveEye);
+    }
+
+    private void LerpEntityEye(EntityUid uid, EyeLerpInformation info, float frameTime)
+    {
+        if (!TryComp(uid, out TransformComponent? transform)
+            || !TryComp(uid, out EyeComponent? eye)
+            || eye.Eye == null
+            || !_mapManager.TryGetGrid(transform.GridID, out var grid))
+        {
+            _toRemove.Add(uid);
+            return;
+        }
+
+        LerpEye(eye.Eye, frameTime, grid.WorldRotation, info);
+    }
+
+    private void LerpEye(IEye eye, float frameTime, Angle lastAngle, EyeLerpInformation lerpInfo)
+    {
 
         // Let's not turn the camera into a washing machine when the game starts.
-        if (_lastGridAngle == null)
+        if (lerpInfo.LastGridAngle == null)
         {
-            _lastGridAngle = moverLastGridAngle;
-            currentEye.Rotation = -moverLastGridAngle;
+            lerpInfo.LastGridAngle = lastAngle;
+            eye.Rotation = -lastAngle;
             return;
         }
 
         // Check if the last lerp grid angle we have is not the same as the last mover grid angle...
-        if (!_lastGridAngle.Value.EqualsApprox(moverLastGridAngle))
+        if (!lerpInfo.LastGridAngle.Value.EqualsApprox(lastAngle))
         {
             // And now, we start lerping.
-            _lerpTo = moverLastGridAngle;
-            _lastGridAngle = moverLastGridAngle;
-            _lerpStartRotation = currentEye.Rotation;
-            _accumulator = 0f;
+            lerpInfo.LerpTo = lastAngle;
+            lerpInfo.LastGridAngle = lastAngle;
+            lerpInfo.LerpStartRotation = eye.Rotation;
+            lerpInfo.Accumulator = 0f;
         }
 
-        if (_lerpTo != null)
+        if (lerpInfo.LerpTo != null)
         {
-            _accumulator += frameTime;
+            lerpInfo.Accumulator += frameTime;
 
-            var lerpRot = -_lerpTo.Value.FlipPositive().Reduced();
-            var startRot = _lerpStartRotation.FlipPositive().Reduced();
+            var lerpRot = -lerpInfo.LerpTo.Value.FlipPositive().Reduced();
+            var startRot = lerpInfo.LerpStartRotation.FlipPositive().Reduced();
 
             var changeNeeded = Angle.ShortestDistance(startRot, lerpRot);
 
             if (changeNeeded.EqualsApprox(Angle.Zero))
             {
                 // Nothing to do here!
-                CleanupLerp();
+                lerpInfo.Cleanup(eye);
                 return;
             }
 
             // Get how much the camera should have moved by now. Make it faster depending on the change needed.
-            var changeRot = (CameraRotateSpeed * Math.Max(1f, Math.Abs(changeNeeded) * 0.75f)) * _accumulator * Math.Sign(changeNeeded);
+            var changeRot = (CameraRotateSpeed * Math.Max(1f, Math.Abs(changeNeeded) * 0.75f)) * lerpInfo.Accumulator * Math.Sign(changeNeeded);
 
             // How close is this from reaching the end?
             var percentage = (float)Math.Abs(changeRot / changeNeeded);
 
-            currentEye.Rotation = Angle.Lerp(startRot, lerpRot, percentage);
+            eye.Rotation = Angle.Lerp(startRot, lerpRot, percentage);
 
             // Either we have overshot, or we have taken way too long on this, emergency reset time
-            if (percentage >= 1.0f || _accumulator >= LerpTimeMax)
-            {
-                CleanupLerp();
-            }
-
-            void CleanupLerp()
+            if (percentage >= 1.0f || lerpInfo.Accumulator >= LerpTimeMax)
             {
-                currentEye.Rotation = -_lerpTo.Value;
-                _lerpStartRotation = currentEye.Rotation;
-                _lerpTo = null;
-                _accumulator = 0f;
+                lerpInfo.Cleanup(eye);
             }
         }
         else
@@ -117,7 +172,23 @@ void CleanupLerp()
             // ghosting, this system listening for attached mob changes, and the eye rotation being reset after our
             // changes back to zero because of an EyeComponent state coming from the server being applied.
             // At some point we'll need to come up with a solution for that. But for now, I just want to fix this.
-            currentEye.Rotation = -moverLastGridAngle;
+            eye.Rotation = -lastAngle;
+        }
+    }
+
+    private sealed class EyeLerpInformation
+    {
+        public Angle? LastGridAngle { get; set; }
+        public Angle? LerpTo { get; set; }
+        public Angle LerpStartRotation { get; set; }
+        public float Accumulator { get; set; }
+
+        public void Cleanup(IEye eye)
+        {
+            eye.Rotation = -LerpTo ?? Angle.Zero;
+            LerpStartRotation = eye.Rotation;
+            LerpTo = null;
+            Accumulator = 0;
         }
     }
 }
@@ -0,0 +1,5 @@
+<Control Name="CFlavorText" xmlns="https://spacestation14.io">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+        <LineEdit Name="CFlavorTextInput" Access="Public" MinSize="220 0" HorizontalExpand="True" />
+    </BoxContainer>
+</Control>
@@ -0,0 +1,25 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.FlavorText
+{
+    [GenerateTypedNameReferences]
+    public sealed partial class FlavorText : Control
+    {
+        public Action<string>? OnFlavorTextChanged;
+
+        public FlavorText()
+        {
+            RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+
+            CFlavorTextInput.OnTextChanged += _ => FlavorTextChanged();
+        }
+
+        public void FlavorTextChanged()
+        {
+            OnFlavorTextChanged?.Invoke(CFlavorTextInput.Text);
+        }
+    }
+}
@@ -18,6 +18,7 @@
 using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
@@ -42,6 +43,7 @@ public sealed class LobbyState : Robust.Client.State.State
         [Dependency] private readonly IClientPreferencesManager _preferencesManager = default!;
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly IVoteManager _voteManager = default!;
+        [Dependency] private readonly IConfigurationManager _configurationManager = default!;
 
         [ViewVariables] private CharacterSetupGui? _characterSetup;
         [ViewVariables] private LobbyGui? _lobby;
@@ -52,7 +54,7 @@ public override void Startup()
         {
             _gameTicker = EntitySystem.Get<ClientGameTicker>();
             _characterSetup = new CharacterSetupGui(_entityManager, _resourceCache, _preferencesManager,
-                _prototypeManager);
+                _prototypeManager, _configurationManager);
             LayoutContainer.SetAnchorPreset(_characterSetup, LayoutContainer.LayoutPreset.Wide);
 
             _lobby = new LobbyGui(_entityManager, _preferencesManager);
 
@@ -13,6 +13,7 @@
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
@@ -29,19 +30,22 @@ public sealed partial class CharacterSetupGui : Control
         private readonly IClientPreferencesManager _preferencesManager;
         private readonly IEntityManager _entityManager;
         private readonly IPrototypeManager _prototypeManager;
+        private readonly IConfigurationManager _configurationManager;
         private readonly Button _createNewCharacterButton;
         private readonly HumanoidProfileEditor _humanoidProfileEditor;
 
         public CharacterSetupGui(
             IEntityManager entityManager,
             IResourceCache resourceCache,
             IClientPreferencesManager preferencesManager,
-            IPrototypeManager prototypeManager)
+            IPrototypeManager prototypeManager,
+            IConfigurationManager configurationManager)
         {
             RobustXamlLoader.Load(this);
             _entityManager = entityManager;
             _prototypeManager = prototypeManager;
             _preferencesManager = preferencesManager;
+            _configurationManager = configurationManager;
 
             var panelTex = resourceCache.GetTexture("/Textures/Interface/Nano/button.svg.96dpi.png");
             var back = new StyleBoxTexture
@@ -64,7 +68,7 @@ public CharacterSetupGui(
                 args.Event.Handle();
             };
 
-            _humanoidProfileEditor = new HumanoidProfileEditor(preferencesManager, prototypeManager, entityManager);
+            _humanoidProfileEditor = new HumanoidProfileEditor(preferencesManager, prototypeManager, entityManager, configurationManager);
             _humanoidProfileEditor.OnProfileChanged += ProfileChanged;
             CharEditor.AddChild(_humanoidProfileEditor);
 
 
@@ -2,7 +2,8 @@
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:magicmirror="clr-namespace:Content.Client.CharacterAppearance"
          xmlns:prefUi="clr-namespace:Content.Client.Preferences.UI"
-         xmlns:markings="clr-namespace:Content.Client.Markings">
+         xmlns:markings="clr-namespace:Content.Client.Markings"
+         xmlns:flavorText="clr-namespace:Content.Client.FlavorText">
     <BoxContainer Orientation="Horizontal">
         <!-- Left side -->
         <BoxContainer Orientation="Vertical" Margin="10 10 10 10">