124 lines
4.2 KiB
C#
124 lines
4.2 KiB
C#
using System;
|
|
using Content.Shared.Movement.Components;
|
|
using Robust.Client.GameObjects;
|
|
using Robust.Client.Graphics;
|
|
using Robust.Client.Physics;
|
|
using Robust.Client.Player;
|
|
using Robust.Shared.GameObjects;
|
|
using Robust.Shared.IoC;
|
|
using Robust.Shared.Maths;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Client.Eye;
|
|
|
|
public sealed class EyeLerpingSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly IEyeManager _eyeManager = 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;
|
|
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
UpdatesAfter.Add(typeof(TransformSystem));
|
|
UpdatesAfter.Add(typeof(PhysicsSystem));
|
|
UpdatesBefore.Add(typeof(EyeUpdateSystem));
|
|
}
|
|
|
|
public override void FrameUpdate(float frameTime)
|
|
{
|
|
if (!_gameTiming.IsFirstTimePredicted)
|
|
return;
|
|
|
|
var currentEye = _eyeManager.CurrentEye;
|
|
|
|
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;
|
|
|
|
// Let's not turn the camera into a washing machine when the game starts.
|
|
if (_lastGridAngle == null)
|
|
{
|
|
_lastGridAngle = moverLastGridAngle;
|
|
currentEye.Rotation = -moverLastGridAngle;
|
|
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))
|
|
{
|
|
// And now, we start lerping.
|
|
_lerpTo = moverLastGridAngle;
|
|
_lastGridAngle = moverLastGridAngle;
|
|
_lerpStartRotation = currentEye.Rotation;
|
|
_accumulator = 0f;
|
|
}
|
|
|
|
if (_lerpTo != null)
|
|
{
|
|
_accumulator += frameTime;
|
|
|
|
var lerpRot = -_lerpTo.Value.FlipPositive().Reduced();
|
|
var startRot = _lerpStartRotation.FlipPositive().Reduced();
|
|
|
|
var changeNeeded = Angle.ShortestDistance(startRot, lerpRot);
|
|
|
|
if (changeNeeded.EqualsApprox(Angle.Zero))
|
|
{
|
|
// Nothing to do here!
|
|
CleanupLerp();
|
|
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);
|
|
|
|
// How close is this from reaching the end?
|
|
var percentage = (float)Math.Abs(changeRot / changeNeeded);
|
|
|
|
currentEye.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()
|
|
{
|
|
currentEye.Rotation = -_lerpTo.Value;
|
|
_lerpStartRotation = currentEye.Rotation;
|
|
_lerpTo = null;
|
|
_accumulator = 0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This makes it so rotating the camera manually is impossible...
|
|
// However, it is needed. Why? Because of a funny (hilarious, even) race condition involving
|
|
// 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;
|
|
}
|
|
}
|
|
}
|