Engine Update & EE Surgery

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -91,7 +91,7 @@ private void OnPlayerDetached(EntityUid uid, AlertsComponent component, LocalPla
         ClearAlerts?.Invoke(this, EventArgs.Empty);
     }
 
-    public void AlertClicked(AlertType alertType)
+    public void AlertClicked(ProtoId<AlertPrototype> alertType)
     {
         RaiseNetworkEvent(new ClickAlertEvent(alertType));
     }

Content.Client/Audio/AmbientSoundSystem.cs

@@ -303,7 +303,11 @@ private void ProcessNearbyAmbience(TransformComponent playerXform)
                     .WithMaxDistance(comp.Range);
 
                 var stream = _audio.PlayEntity(comp.Sound, Filter.Local(), uid, false, audioParams);
-                _playingSounds[comp] = (stream.Value.Entity, comp.Sound, key);
+
+                if (stream == null)
+                    continue;
+
+                _playingSounds[comp] = (stream!.Value.Entity, comp.Sound, key);
                 playingCount++;
 
                 if (_playingSounds.Count >= _maxAmbientCount)

Content.Client/Audio/ClientGlobalSoundSystem.cs

@@ -67,7 +67,7 @@ private void PlayAdminSound(AdminSoundEvent soundEvent)
         if(!_adminAudioEnabled) return;
 
         var stream = _audio.PlayGlobal(soundEvent.Filename, Filter.Local(), false, soundEvent.AudioParams);
-        _adminAudio.Add(stream.Value.Entity);
+        _adminAudio.Add(stream!.Value.Entity);
     }
 
     private void PlayStationEventMusic(StationEventMusicEvent soundEvent)
@@ -76,7 +76,7 @@ private void PlayStationEventMusic(StationEventMusicEvent soundEvent)
         if(!_eventAudioEnabled || _eventAudio.ContainsKey(soundEvent.Type)) return;
 
         var stream = _audio.PlayGlobal(soundEvent.Filename, Filter.Local(), false, soundEvent.AudioParams);
-        _eventAudio.Add(soundEvent.Type, stream.Value.Entity);
+        _eventAudio.Add(soundEvent.Type, stream!.Value.Entity);
     }
 
     private void PlayGameSound(GameGlobalSoundEvent soundEvent)

Content.Client/Audio/ContentAudioSystem.AmbientMusic.cs

@@ -210,7 +210,7 @@ private void UpdateAmbientMusic()
             track.ToString(),
             Filter.Local(),
             false,
-            AudioParams.Default.WithVolume(_musicProto.Sound.Params.Volume + _volumeSlider));
+            AudioParams.Default.WithVolume(_musicProto.Sound.Params.Volume + _volumeSlider))!;
 
         _ambientMusicStream = strim.Value.Entity;
 

Content.Client/Audio/ContentAudioSystem.LobbyMusic.cs

@@ -185,7 +185,11 @@ private void PlaySoundtrack(string soundtrackFilename)
             false,
             _lobbySoundtrackParams.WithVolume(_lobbySoundtrackParams.Volume + SharedAudioSystem.GainToVolume(_configManager.GetCVar(CCVars.LobbyMusicVolume)))
         );
-        if (playResult.Value.Entity == default)
+
+        if (playResult == null)
+            return;
+
+        if (playResult!.Value.Entity == default)
         {
             _sawmill.Warning(
                 $"Tried to play lobby soundtrack '{{Filename}}' using {nameof(SharedAudioSystem)}.{nameof(SharedAudioSystem.PlayGlobal)} but it returned default value of EntityUid!",

Content.Client/Body/Components/BrainComponent.cs

@@ -0,0 +1,3 @@
+namespace Content.Client.Body.Components;
+[RegisterComponent]
+public sealed partial class BrainComponent : Component { }

Content.Client/Body/Components/LungComponent.cs

@@ -0,0 +1,3 @@
+namespace Content.Client.Body.Components;
+[RegisterComponent]
+public sealed partial class LungComponent : Component { }

Content.Client/Body/Components/StomachComponent.cs

@@ -0,0 +1,3 @@
+namespace Content.Client.Body.Components;
+[RegisterComponent]
+public sealed partial class StomachComponent : Component { }

Content.Client/Body/Systems/BodySystem.cs

@@ -1,7 +1,72 @@
 using Content.Shared.Body.Systems;
+using Content.Shared.Body.Part;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Markings;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+using Content.Shared.Body.Components;
 
 namespace Content.Client.Body.Systems;
 
 public sealed class BodySystem : SharedBodySystem
 {
+    [Dependency] private readonly MarkingManager _markingManager = default!;
+
+    private void ApplyMarkingToPart(MarkingPrototype markingPrototype,
+        IReadOnlyList<Color>? colors,
+        bool visible,
+        SpriteComponent sprite)
+    {
+        for (var j = 0; j < markingPrototype.Sprites.Count; j++)
+        {
+            var markingSprite = markingPrototype.Sprites[j];
+
+            if (markingSprite is not SpriteSpecifier.Rsi rsi)
+                continue;
+
+            var layerId = $"{markingPrototype.ID}-{rsi.RsiState}";
+
+            if (!sprite.LayerMapTryGet(layerId, out _))
+            {
+                var layer = sprite.AddLayer(markingSprite, j + 1);
+                sprite.LayerMapSet(layerId, layer);
+                sprite.LayerSetSprite(layerId, rsi);
+            }
+
+            sprite.LayerSetVisible(layerId, visible);
+
+            if (!visible)
+                continue;
+
+            // Okay so if the marking prototype is modified but we load old marking data this may no longer be valid
+            // and we need to check the index is correct. So if that happens just default to white?
+            if (colors != null && j < colors.Count)
+                sprite.LayerSetColor(layerId, colors[j]);
+            else
+                sprite.LayerSetColor(layerId, Color.White);
+        }
+    }
+
+    protected override void ApplyPartMarkings(EntityUid target, BodyPartAppearanceComponent component)
+    {
+        if (!TryComp(target, out SpriteComponent? sprite))
+            return;
+
+        if (component.Color != null)
+            sprite.Color = component.Color.Value;
+
+        foreach (var (visualLayer, markingList) in component.Markings)
+            foreach (var marking in markingList)
+            {
+                if (!_markingManager.TryGetMarking(marking, out var markingPrototype))
+                    continue;
+
+                ApplyMarkingToPart(markingPrototype, marking.MarkingColors, marking.Visible, sprite);
+            }
+    }
+
+    protected override void RemoveBodyMarkings(EntityUid target, BodyPartAppearanceComponent partAppearance, HumanoidAppearanceComponent bodyAppearance)
+    {
+        return;
+    }
 }

Content.Client/Buckle/BuckleSystem.cs

@@ -3,6 +3,7 @@
 using Content.Shared.Buckle.Components;
 using Content.Shared.Rotation;
 using Robust.Client.GameObjects;
+using Robust.Shared.GameStates;
 
 namespace Content.Client.Buckle;
 
@@ -14,37 +15,77 @@ public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<BuckleComponent, AfterAutoHandleStateEvent>(OnBuckleAfterAutoHandleState);
         SubscribeLocalEvent<BuckleComponent, AppearanceChangeEvent>(OnAppearanceChange);
+        SubscribeLocalEvent<StrapComponent, MoveEvent>(OnStrapMoveEvent);
+        SubscribeLocalEvent<BuckleComponent, BuckledEvent>(OnBuckledEvent);
+        SubscribeLocalEvent<BuckleComponent, UnbuckledEvent>(OnUnbuckledEvent);
     }
 
-    private void OnBuckleAfterAutoHandleState(EntityUid uid, BuckleComponent component, ref AfterAutoHandleStateEvent args)
+     /// <summary>
+    /// Is the strap entity already rotated north? Lower the draw depth of the buckled entity.
+    /// </summary>
+    private void OnBuckledEvent(Entity<BuckleComponent> ent, ref BuckledEvent args)
     {
-        ActionBlocker.UpdateCanMove(uid);
-
-        if (!TryComp<SpriteComponent>(uid, out var ownerSprite))
+        if (!TryComp<SpriteComponent>(args.Strap, out var strapSprite) ||
+            !TryComp<SpriteComponent>(ent.Owner, out var buckledSprite))
             return;
 
-        // Adjust draw depth when the chair faces north so that the seat back is drawn over the player.
-        // Reset the draw depth when rotated in any other direction.
-        // TODO when ECSing, make this a visualizer
-        // This code was written before rotatable viewports were introduced, so hard-coding Direction.North
-        // and comparing it against LocalRotation now breaks this in other rotations. This is a FIXME, but
-        // better to get it working for most people before we look at a more permanent solution.
-        if (component is { Buckled: true, LastEntityBuckledTo: { } } &&
-            Transform(component.LastEntityBuckledTo.Value).LocalRotation.GetCardinalDir() == Direction.North &&
-            TryComp<SpriteComponent>(component.LastEntityBuckledTo, out var buckledSprite))
+        if (Transform(args.Strap.Owner).LocalRotation.GetCardinalDir() == Direction.North)
         {
-            component.OriginalDrawDepth ??= ownerSprite.DrawDepth;
-            ownerSprite.DrawDepth = buckledSprite.DrawDepth - 1;
+            ent.Comp.OriginalDrawDepth ??= buckledSprite.DrawDepth;
+            buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+        }
+    }
+
+    /// <summary>
+    /// Was the draw depth of the buckled entity lowered? Reset it upon unbuckling.
+    /// </summary>
+    private void OnUnbuckledEvent(Entity<BuckleComponent> ent, ref UnbuckledEvent args)
+    {
+        if (!TryComp<SpriteComponent>(ent.Owner, out var buckledSprite))
             return;
+
+        if (ent.Comp.OriginalDrawDepth.HasValue)
+        {
+            buckledSprite.DrawDepth = ent.Comp.OriginalDrawDepth.Value;
+            ent.Comp.OriginalDrawDepth = null;
         }
+    }
 
-        // If here, we're not turning north and should restore the saved draw depth.
-        if (component.OriginalDrawDepth.HasValue)
+    private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveEvent args)
+    {
+        // I'm moving this to the client-side system, but for the sake of posterity let's keep this comment:
+        // > This is mega cursed. Please somebody save me from Mr Buckle's wild ride
+
+        // The nice thing is its still true, this is quite cursed, though maybe not omega cursed anymore.
+        // This code is garbage, it doesn't work with rotated viewports. I need to finally get around to reworking
+        // sprite rendering for entity layers & direction dependent sorting.
+
+        if (args.NewRotation == args.OldRotation)
+            return;
+
+        if (!TryComp<SpriteComponent>(uid, out var strapSprite))
+            return;
+
+        var isNorth = Transform(uid).LocalRotation.GetCardinalDir() == Direction.North;
+        foreach (var buckledEntity in component.BuckledEntities)
         {
-            ownerSprite.DrawDepth = component.OriginalDrawDepth.Value;
-            component.OriginalDrawDepth = null;
+            if (!TryComp<BuckleComponent>(buckledEntity, out var buckle))
+                continue;
+
+            if (!TryComp<SpriteComponent>(buckledEntity, out var buckledSprite))
+                continue;
+
+            if (isNorth)
+            {
+                buckle.OriginalDrawDepth ??= buckledSprite.DrawDepth;
+                buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+            }
+            else if (buckle.OriginalDrawDepth.HasValue)
+            {
+                buckledSprite.DrawDepth = buckle.OriginalDrawDepth.Value;
+                buckle.OriginalDrawDepth = null;
+            }
         }
     }