Imports updated vehicles & mechs

Content.Client/Buckle/BuckleSystem.cs

@@ -1,6 +1,7 @@
 using Content.Client.Rotation;
 using Content.Shared.Buckle;
 using Content.Shared.Buckle.Components;
+using Content.Shared.Movement.Systems;
 using Content.Shared.Rotation;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
@@ -12,6 +13,7 @@ internal sealed class BuckleSystem : SharedBuckleSystem
     [Dependency] private readonly RotationVisualizerSystem _rotationVisualizerSystem = default!;
     [Dependency] private readonly IEyeManager _eye = default!;
     [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -21,6 +23,15 @@ public override void Initialize()
         SubscribeLocalEvent<StrapComponent, MoveEvent>(OnStrapMoveEvent);
         SubscribeLocalEvent<BuckleComponent, BuckledEvent>(OnBuckledEvent);
         SubscribeLocalEvent<BuckleComponent, UnbuckledEvent>(OnUnbuckledEvent);
+        SubscribeLocalEvent<BuckleComponent, AttemptMobCollideEvent>(OnMobCollide);
+    }
+
+    private void OnMobCollide(Entity<BuckleComponent> ent, ref AttemptMobCollideEvent args)
+    {
+        if (ent.Comp.Buckled)
+        {
+            args.Cancelled = true;
+        }
     }
 
     private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveEvent args)
@@ -38,6 +49,9 @@ private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveE
         // Give some of the sprite rotations their own drawdepth, maybe as an offset within the rsi, or something like this
         // And we won't ever need to set the draw depth manually
 
+        if (!component.ModifyBuckleDrawDepth)
+            return;
+
         if (args.NewRotation == args.OldRotation)
             return;
 
@@ -59,11 +73,11 @@ private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveE
             {
                 // This will only assign if empty, it won't get overwritten by new depth on multiple calls, which do happen easily
                 buckle.OriginalDrawDepth ??= buckledSprite.DrawDepth;
-                buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+                _sprite.SetDrawDepth((buckledEntity, buckledSprite), strapSprite.DrawDepth - 1);
             }
             else if (buckle.OriginalDrawDepth.HasValue)
             {
-                buckledSprite.DrawDepth = buckle.OriginalDrawDepth.Value;
+                _sprite.SetDrawDepth((buckledEntity, buckledSprite), buckle.OriginalDrawDepth.Value);
                 buckle.OriginalDrawDepth = null;
             }
         }
@@ -75,6 +89,9 @@ private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveE
     /// </summary>
     private void OnBuckledEvent(Entity<BuckleComponent> ent, ref BuckledEvent args)
     {
+        if (!args.Strap.Comp.ModifyBuckleDrawDepth)
+            return;
+
         if (!TryComp<SpriteComponent>(args.Strap, out var strapSprite))
             return;
 
@@ -87,31 +104,40 @@ private void OnBuckledEvent(Entity<BuckleComponent> ent, ref BuckledEvent args)
             return;
 
         ent.Comp.OriginalDrawDepth ??= buckledSprite.DrawDepth;
-        buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+        _sprite.SetDrawDepth((ent.Owner, buckledSprite), 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 (!args.Strap.Comp.ModifyBuckleDrawDepth)
+            return;
+
         if (!TryComp<SpriteComponent>(ent.Owner, out var buckledSprite))
             return;
 
         if (!ent.Comp.OriginalDrawDepth.HasValue)
             return;
 
-        buckledSprite.DrawDepth = ent.Comp.OriginalDrawDepth.Value;
+        _sprite.SetDrawDepth((ent.Owner, buckledSprite), ent.Comp.OriginalDrawDepth.Value);
         ent.Comp.OriginalDrawDepth = null;
     }
 
     private void OnAppearanceChange(EntityUid uid, BuckleComponent component, ref AppearanceChangeEvent args)
     {
-        if (!TryComp<RotationVisualsComponent>(uid, out var rotVisuals)
-            || !Appearance.TryGetData<bool>(uid, BuckleVisuals.Buckled, out var buckled, args.Component)
-            || !buckled || args.Sprite == null)
+        if (!TryComp<RotationVisualsComponent>(uid, out var rotVisuals))
             return;
 
+        if (!Appearance.TryGetData<bool>(uid, BuckleVisuals.Buckled, out var buckled, args.Component) ||
+            !buckled ||
+            args.Sprite == null)
+        {
+            _rotationVisualizerSystem.SetHorizontalAngle((uid, rotVisuals), rotVisuals.DefaultRotation);
+            return;
+        }
+
         // Animate strapping yourself to something at a given angle
         // TODO: Dump this when buckle is better
         _rotationVisualizerSystem.AnimateSpriteRotation(uid, args.Sprite, rotVisuals.HorizontalRotation, 0.125f);

Content.Client/Eye/EyeLerpingSystem.cs

@@ -34,7 +34,7 @@ public override void Initialize()
         SubscribeLocalEvent<LerpingEyeComponent, LocalPlayerDetachedEvent>(OnDetached);
 
         UpdatesAfter.Add(typeof(TransformSystem));
-        UpdatesAfter.Add(typeof(PhysicsSystem));
+        UpdatesAfter.Add(typeof(Robust.Client.Physics.PhysicsSystem));
         UpdatesBefore.Add(typeof(SharedEyeSystem));
         UpdatesOutsidePrediction = true;
     }

Content.Client/NPC/NPCSteeringSystem.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using Content.Client.Physics.Controllers;
+using Content.Client.PhysicsSystem.Controllers;
 using Content.Shared.Movement.Components;
 using Content.Shared.NPC;
 using Content.Shared.NPC.Events;

Content.Client/Physics/Controllers/MoverController.cs

@@ -1,23 +1,23 @@
+using Content.Shared.Alert;
 using Content.Shared.CCVar;
+using Content.Shared.Friction;
 using Content.Shared.Movement.Components;
-using Content.Shared.Movement.Events;
 using Content.Shared.Movement.Pulling.Components;
 using Content.Shared.Movement.Systems;
-using Robust.Client.GameObjects;
 using Robust.Client.Physics;
 using Robust.Client.Player;
 using Robust.Shared.Configuration;
-using Robust.Shared.Physics.Components;
 using Robust.Shared.Player;
 using Robust.Shared.Timing;
 
-namespace Content.Client.Physics.Controllers;
+namespace Content.Client.PhysicsSystem.Controllers;
 
 public sealed class MoverController : SharedMoverController
 {
-    [Dependency] private readonly IConfigurationManager _config = default!;
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly AlertsSystem _alerts = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
 
     public override void Initialize()
     {
@@ -30,8 +30,6 @@ public override void Initialize()
         SubscribeLocalEvent<InputMoverComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
         SubscribeLocalEvent<MovementRelayTargetComponent, UpdateIsPredictedEvent>(OnUpdateRelayTargetPredicted);
         SubscribeLocalEvent<PullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
-
-        Subs.CVar(_config, CCVars.DefaultWalk, _ => RaiseNetworkEvent(new UpdateInputCVarsMessage()));
     }
 
     private void OnUpdatePredicted(Entity<InputMoverComponent> entity, ref UpdateIsPredictedEvent args)
@@ -63,16 +61,16 @@ private void OnUpdatePullablePredicted(Entity<PullableComponent> entity, ref Upd
 
     private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
     {
-        Physics.UpdateIsPredicted(entity.Owner);
-        Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+        PhysicsSystem.UpdateIsPredicted(entity.Owner);
+        PhysicsSystem.UpdateIsPredicted(entity.Comp.RelayEntity);
         if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
             SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
     }
 
     private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
     {
-        Physics.UpdateIsPredicted(entity.Owner);
-        Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+        PhysicsSystem.UpdateIsPredicted(entity.Owner);
+        PhysicsSystem.UpdateIsPredicted(entity.Comp.RelayEntity);
         if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
             SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
     }
@@ -102,43 +100,28 @@ public override void UpdateBeforeSolve(bool prediction, float frameTime)
 
     private void HandleClientsideMovement(EntityUid player, float frameTime)
     {
-        if (!MoverQuery.TryGetComponent(player, out var mover) ||
-            !XformQuery.TryGetComponent(player, out var xform))
-        {
-            return;
-        }
-
-        var physicsUid = player;
-        PhysicsComponent? body;
-        var xformMover = xform;
-
-        if (mover.ToParent && RelayQuery.HasComponent(xform.ParentUid))
-        {
-            if (!PhysicsQuery.TryGetComponent(xform.ParentUid, out body) ||
-                !XformQuery.TryGetComponent(xform.ParentUid, out xformMover))
-            {
-                return;
-            }
-
-            physicsUid = xform.ParentUid;
-        }
-        else if (!PhysicsQuery.TryGetComponent(player, out body))
+        if (!MoverQuery.TryGetComponent(player, out var mover))
         {
             return;
         }
 
         // Server-side should just be handled on its own so we'll just do this shizznit
-        HandleMobMovement(
-            player,
-            mover,
-            physicsUid,
-            body,
-            xformMover,
-            frameTime);
+        HandleMobMovement((player, mover), frameTime);
     }
 
     protected override bool CanSound()
     {
         return _timing is { IsFirstTimePredicted: true, InSimulation: true };
     }
+
+    public override void SetSprinting(Entity<InputMoverComponent> entity, ushort subTick, bool walking)
+    {
+        // Logger.Info($"[{_gameTiming.CurTick}/{subTick}] Sprint: {enabled}");
+        base.SetSprinting(entity, subTick, walking);
+
+        if (walking && _cfg.GetCVar(CCVars.ToggleWalk))
+            _alerts.ShowAlert(entity.Owner, WalkingAlert, showCooldown: false, autoRemove: false);
+        else
+            _alerts.ClearAlert(entity.Owner, WalkingAlert);
+    }
 }