pipe crawling camera lerp

Content.Shared/Atmos/Piping/Crawling/Components/PipeCrawlingComponent.cs

@@ -8,6 +8,9 @@ public sealed partial class PipeCrawlingComponent : Component
     [ViewVariables]
     public EntityUid CurrentPipe;
 
+    [ViewVariables]
+    public Direction TargetDirection;
+
     [ViewVariables]
     public TimeSpan NextMoveAttempt;
 

Content.Shared/Atmos/Piping/Crawling/Systems/SharedPipeCrawlingSystem.cs

@@ -1,21 +1,23 @@
 using Content.Shared.Atmos.Piping.Crawling.Components;
+using Content.Shared.Camera;
 using Content.Shared.Mobs.Systems;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Events;
 using Content.Shared.Movement.Systems;
 using Content.Shared.SubFloor;
 using Robust.Shared.Containers;
-using Robust.Shared.Physics;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Timing;
+using System.Numerics;
 
 namespace Content.Shared.Atmos.Piping.Crawling.Systems;
 
 public abstract partial class SharedPipeCrawlingSystem : EntitySystem
 {
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly SharedContainerSystem _containers = default!;
+    [Dependency] private readonly SharedEyeSystem _eye = default!;
     [Dependency] private readonly SharedMoverController _movement = default!;
     [Dependency] private readonly SharedPhysicsSystem _physics = default!;
     [Dependency] private readonly SharedTransformSystem _xform = default!;
@@ -34,6 +36,7 @@ public override void Initialize()
         SubscribeLocalEvent<PipeCrawlingComponent, ComponentRemove>(OnRemoved);
 
         SubscribeLocalEvent<PipeCrawlingComponent, MoveInputEvent>(OnMove);
+        SubscribeLocalEvent<PipeCrawlingComponent, GetEyeOffsetEvent>(OnEyeOffset);
     }
 
     public override void Update(float frameTime)
@@ -55,33 +58,40 @@ public override void Update(float frameTime)
             (_, var sprintingVec) = _movement.GetVelocityInput(inputComp);
             var direction = sprintingVec.GetDir();
 
+            if (_mobState.IsIncapacitated(uid))
+                continue;
+
             if (component.NextMoveAttempt > _timing.CurTime)
             {
-                continue;
-            }
+                if (!pipeComp.ConnectedPipes.ContainsKey(direction))
+                    continue;
 
-            component.NextMoveAttempt += TimeSpan.FromSeconds(pipeCrawlerComp.PipeMoveSpeed ?? (1f / speedComp.BaseSprintSpeed) * CrawlSpeedMultiplier);
+                if (component.TargetDirection != direction)
+                {
+                    component.TargetDirection = direction;
+                    Dirty(uid, component);
+                }
 
-            if (_mobState.IsIncapacitated(uid))
+                _eye.SetOffset(uid, InterpEye(component, pipeCrawlerComp, speedComp));
                 continue;
+            }
+
+            component.NextMoveAttempt += GetNextMoveAttemptFrequency(pipeCrawlerComp, speedComp);
 
             // does the pipe has a connection to annother pipe in that direction
             if (!pipeComp.ConnectedPipes.ContainsKey(direction))
-            {
                 continue;
-            }
 
+            component.TargetDirection = direction;
             var newPipe = pipeComp.ConnectedPipes[direction];
 
-            if (_containers.TryGetContainer(component.CurrentPipe, PipeContainer, out var currentPipeContainer) &&
-                HasComp<PipeCrawlingPipeComponent>(component.CurrentPipe))
+            if (_containers.TryGetContainer(component.CurrentPipe, PipeContainer, out var currentPipeContainer) && HasComp<PipeCrawlingPipeComponent>(component.CurrentPipe))
             {
                 var newPipeCoords = Transform(newPipe).Coordinates;
                 _containers.Remove(uid, currentPipeContainer, destination: newPipeCoords, localRotation: direction.ToAngle());
             }
 
-            if (_containers.TryGetContainer(newPipe, PipeContainer, out var newPipeContainer) &&
-            HasComp<PipeCrawlingPipeComponent>(newPipe))
+            if (_containers.TryGetContainer(newPipe, PipeContainer, out var newPipeContainer) && HasComp<PipeCrawlingPipeComponent>(newPipe))
             {
                 _containers.Insert(uid, newPipeContainer);
             }
@@ -91,6 +101,22 @@ public override void Update(float frameTime)
         }
     }
 
+    private Vector2 InterpEye(PipeCrawlingComponent pipeCrawlingComp, CanEnterPipeCrawlingComponent pipeCrawlerComp, MovementSpeedModifierComponent speedComp)
+    {
+        var targetOffset = pipeCrawlingComp.TargetDirection.ToVec();
+        var frequency = GetNextMoveAttemptFrequency(pipeCrawlerComp, speedComp);
+        var nextMove = pipeCrawlingComp.NextMoveAttempt + frequency;
+        var timeElapsed = nextMove - _timing.CurTime;
+        var scalar = (float) (timeElapsed.TotalSeconds / frequency.TotalSeconds);
+
+        return Vector2.Multiply(targetOffset, scalar);
+    }
+
+    private TimeSpan GetNextMoveAttemptFrequency(CanEnterPipeCrawlingComponent pipeCrawlerComp, MovementSpeedModifierComponent speedComp)
+    {
+        return TimeSpan.FromSeconds(pipeCrawlerComp.PipeMoveSpeed ?? (1f / speedComp.BaseSprintSpeed) * CrawlSpeedMultiplier);
+    }
+
     private void OnInit(EntityUid uid, PipeCrawlingComponent component, ref ComponentInit args)
     {
         SetState(uid, component, true);
@@ -103,9 +129,6 @@ private void OnRemoved(EntityUid uid, PipeCrawlingComponent component, ref Compo
 
     private void SetState(EntityUid uid, PipeCrawlingComponent component, bool enabled)
     {
-        if (!TryComp<FixturesComponent>(uid, out var playerFixturesComp))
-            return;
-
         if (enabled)
         {
             var trayComp = EnsureComp<TrayScannerComponent>(uid);
@@ -125,6 +148,18 @@ private void SetState(EntityUid uid, PipeCrawlingComponent component, bool enabl
 
     private void OnMove(EntityUid uid, PipeCrawlingComponent component, ref MoveInputEvent args)
     {
-        component.IsMoving = (args.Entity.Comp.HeldMoveButtons & (MoveButtons.Down | MoveButtons.Left | MoveButtons.Up | MoveButtons.Right)) != 0x0;
+        component.IsMoving = (args.Entity.Comp.HeldMoveButtons & MoveButtons.AnyDirection) != 0;
+        Dirty(uid, component);
+    }
+
+    private void OnEyeOffset(EntityUid uid, PipeCrawlingComponent component, ref GetEyeOffsetEvent args)
+    {
+        if (!TryComp<CanEnterPipeCrawlingComponent>(uid, out var pipeCrawlerComp))
+            return;
+
+        if (!TryComp<MovementSpeedModifierComponent>(uid, out var speedComp))
+            return;
+
+        args.Offset += InterpEye(component, pipeCrawlerComp, speedComp);
     }
 }