Replay client (#15001)
This commit is contained in:
Leon Friedrich
GitHub
@@ -0,0 +1,9 @@
|
||||
namespace Content.Client.Replay.Spectator;
|
||||
|
||||
/// <summary>
|
||||
/// This component indicates that this entity currently has a replay spectator/observer attached to it.
|
||||
/// </summary>
|
||||
[RegisterComponent]
|
||||
public sealed class ReplaySpectatorComponent : Component
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
using Content.Shared.Hands;
|
||||
using Content.Shared.Interaction.Events;
|
||||
using Content.Shared.Inventory.Events;
|
||||
using Content.Shared.Item;
|
||||
using Content.Shared.Movement.Events;
|
||||
using Content.Shared.Physics.Pull;
|
||||
using Content.Shared.Throwing;
|
||||
|
||||
namespace Content.Client.Replay.Spectator;
|
||||
|
||||
public sealed partial class ReplaySpectatorSystem
|
||||
{
|
||||
private void InitializeBlockers()
|
||||
{
|
||||
// Block most interactions to avoid mispredicts
|
||||
// This **shouldn't** be required, but just in case.
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, UseAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, PickupAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, ThrowAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, InteractionAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, AttackAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, DropAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, IsEquippingAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, IsUnequippingAttemptEvent>(OnAttempt);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, UpdateCanMoveEvent>(OnUpdateCanMove);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, ChangeDirectionAttemptEvent>(OnUpdateCanMove);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, PullAttemptEvent>(OnPullAttempt);
|
||||
}
|
||||
|
||||
private void OnAttempt(EntityUid uid, ReplaySpectatorComponent component, CancellableEntityEventArgs args)
|
||||
{
|
||||
args.Cancel();
|
||||
}
|
||||
|
||||
private void OnUpdateCanMove(EntityUid uid, ReplaySpectatorComponent component, CancellableEntityEventArgs args)
|
||||
{
|
||||
args.Cancel();
|
||||
}
|
||||
|
||||
private void OnPullAttempt(EntityUid uid, ReplaySpectatorComponent component, PullAttemptEvent args)
|
||||
{
|
||||
args.Cancelled = true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
using Content.Shared.Movement.Components;
|
||||
using Robust.Shared.Input;
|
||||
using Robust.Shared.Input.Binding;
|
||||
using Robust.Shared.Map;
|
||||
using Robust.Shared.Players;
|
||||
|
||||
namespace Content.Client.Replay.Spectator;
|
||||
|
||||
// Partial class handles movement logic for observers.
|
||||
public sealed partial class ReplaySpectatorSystem
|
||||
{
|
||||
public DirectionFlag Direction;
|
||||
|
||||
/// <summary>
|
||||
/// Fallback speed if the observer ghost has no <see cref="MovementSpeedModifierComponent"/>.
|
||||
/// </summary>
|
||||
public const float DefaultSpeed = 12;
|
||||
|
||||
private void InitializeMovement()
|
||||
{
|
||||
var moveUpCmdHandler = new MoverHandler(this, DirectionFlag.North);
|
||||
var moveLeftCmdHandler = new MoverHandler(this, DirectionFlag.West);
|
||||
var moveRightCmdHandler = new MoverHandler(this, DirectionFlag.East);
|
||||
var moveDownCmdHandler = new MoverHandler(this, DirectionFlag.South);
|
||||
|
||||
CommandBinds.Builder
|
||||
.Bind(EngineKeyFunctions.MoveUp, moveUpCmdHandler)
|
||||
.Bind(EngineKeyFunctions.MoveLeft, moveLeftCmdHandler)
|
||||
.Bind(EngineKeyFunctions.MoveRight, moveRightCmdHandler)
|
||||
.Bind(EngineKeyFunctions.MoveDown, moveDownCmdHandler)
|
||||
.Register<ReplaySpectatorSystem>();
|
||||
}
|
||||
|
||||
private void ShutdownMovement()
|
||||
{
|
||||
CommandBinds.Unregister<ReplaySpectatorSystem>();
|
||||
}
|
||||
|
||||
// Normal mover code works via physics. Replays don't do prediction/physics. You can fudge it by relying on the
|
||||
// fact that only local-player physics is currently predicted, but instead I've just added crude mover logic here.
|
||||
// This just runs on frame updates, no acceleration or friction here.
|
||||
public override void FrameUpdate(float frameTime)
|
||||
{
|
||||
if (_replayPlayback.Replay == null)
|
||||
return;
|
||||
|
||||
if (_player.LocalPlayer?.ControlledEntity is not { } player)
|
||||
return;
|
||||
|
||||
if (Direction == DirectionFlag.None)
|
||||
{
|
||||
if (TryComp(player, out InputMoverComponent? cmp))
|
||||
_mover.LerpRotation(cmp, frameTime);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!player.IsClientSide() || !HasComp<ReplaySpectatorComponent>(player))
|
||||
{
|
||||
// Player is trying to move -> behave like the ghost-on-move component.
|
||||
SpawnObserverGhost(new EntityCoordinates(player, default), true);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!TryComp(player, out InputMoverComponent? mover))
|
||||
return;
|
||||
|
||||
_mover.LerpRotation(mover, frameTime);
|
||||
|
||||
var effectiveDir = Direction;
|
||||
if ((Direction & DirectionFlag.North) != 0)
|
||||
effectiveDir &= ~DirectionFlag.South;
|
||||
|
||||
if ((Direction & DirectionFlag.East) != 0)
|
||||
effectiveDir &= ~DirectionFlag.West;
|
||||
|
||||
var query = GetEntityQuery<TransformComponent>();
|
||||
var xform = query.GetComponent(player);
|
||||
var pos = _transform.GetWorldPosition(xform, query);
|
||||
|
||||
if (!xform.ParentUid.IsValid())
|
||||
{
|
||||
// Were they sitting on a grid as it was getting deleted?
|
||||
SetObserverPosition(default);
|
||||
return;
|
||||
}
|
||||
|
||||
// A poor mans grid-traversal system. Should also interrupt ghost-following.
|
||||
_transform.SetGridId(player, xform, null);
|
||||
_transform.AttachToGridOrMap(player);
|
||||
|
||||
var parentRotation = _mover.GetParentGridAngle(mover, query);
|
||||
var localVec = effectiveDir.AsDir().ToAngle().ToWorldVec();
|
||||
var worldVec = parentRotation.RotateVec(localVec);
|
||||
var speed = CompOrNull<MovementSpeedModifierComponent>(player)?.BaseSprintSpeed ?? DefaultSpeed;
|
||||
var delta = worldVec * frameTime * speed;
|
||||
_transform.SetWorldPositionRotation(xform, pos + delta, delta.ToWorldAngle(), query);
|
||||
}
|
||||
|
||||
private sealed class MoverHandler : InputCmdHandler
|
||||
{
|
||||
private readonly ReplaySpectatorSystem _sys;
|
||||
private readonly DirectionFlag _dir;
|
||||
|
||||
public MoverHandler(ReplaySpectatorSystem sys, DirectionFlag dir)
|
||||
{
|
||||
_sys = sys;
|
||||
_dir = dir;
|
||||
}
|
||||
|
||||
public override bool HandleCmdMessage(ICommonSession? session, InputCmdMessage message)
|
||||
{
|
||||
if (message is not FullInputCmdMessage full)
|
||||
return false;
|
||||
|
||||
if (full.State == BoundKeyState.Down)
|
||||
_sys.Direction |= _dir;
|
||||
else
|
||||
_sys.Direction &= ~_dir;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
281
Content.Client/Replay/Spectator/ReplaySpectatorSystem.cs
Normal file
281
Content.Client/Replay/Spectator/ReplaySpectatorSystem.cs
Normal file
@@ -0,0 +1,281 @@
|
||||
using System.Linq;
|
||||
using Content.Client.Replay.UI;
|
||||
using Content.Shared.Movement.Components;
|
||||
using Content.Shared.Movement.Systems;
|
||||
using Content.Shared.Verbs;
|
||||
using Robust.Client;
|
||||
using Robust.Client.GameObjects;
|
||||
using Robust.Client.Player;
|
||||
using Robust.Client.Replays.Playback;
|
||||
using Robust.Client.State;
|
||||
using Robust.Shared.Console;
|
||||
using Robust.Shared.Map;
|
||||
using Robust.Shared.Map.Components;
|
||||
using Robust.Shared.Utility;
|
||||
|
||||
namespace Content.Client.Replay.Spectator;
|
||||
|
||||
/// <summary>
|
||||
/// This system handles spawning replay observer ghosts and maintaining their positions when traveling through time.
|
||||
/// It also blocks most normal interactions, just in case.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// E.g., if an observer is on a grid, and then jumps forward or backward in time to a point where the grid does not
|
||||
/// exist, where should the observer go? This attempts to maintain their position and eye rotation or just re-spawns
|
||||
/// them as needed.
|
||||
/// </remarks>
|
||||
public sealed partial class ReplaySpectatorSystem : EntitySystem
|
||||
{
|
||||
[Dependency] private readonly IPlayerManager _player = default!;
|
||||
[Dependency] private readonly IConsoleHost _conHost = default!;
|
||||
[Dependency] private readonly IStateManager _stateMan = default!;
|
||||
[Dependency] private readonly TransformSystem _transform = default!;
|
||||
[Dependency] private readonly SharedMoverController _mover = default!;
|
||||
[Dependency] private readonly IBaseClient _client = default!;
|
||||
[Dependency] private readonly SharedContentEyeSystem _eye = default!;
|
||||
[Dependency] private readonly IReplayPlaybackManager _replayPlayback = default!;
|
||||
|
||||
private ObserverData? _oldPosition;
|
||||
|
||||
public override void Initialize()
|
||||
{
|
||||
base.Initialize();
|
||||
|
||||
SubscribeLocalEvent<GetVerbsEvent<AlternativeVerb>>(OnGetAlternativeVerbs);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, EntityTerminatingEvent>(OnTerminating);
|
||||
SubscribeLocalEvent<ReplaySpectatorComponent, PlayerDetachedEvent>(OnDetached);
|
||||
|
||||
InitializeBlockers();
|
||||
_conHost.RegisterCommand("observe", ObserveCommand);
|
||||
|
||||
_replayPlayback.BeforeSetTick += OnBeforeSetTick;
|
||||
_replayPlayback.AfterSetTick += OnAfterSetTick;
|
||||
_replayPlayback.ReplayPlaybackStarted += OnPlaybackStarted;
|
||||
_replayPlayback.ReplayPlaybackStopped += OnPlaybackStopped;
|
||||
}
|
||||
|
||||
private void OnPlaybackStarted()
|
||||
{
|
||||
InitializeMovement();
|
||||
SetObserverPosition(default);
|
||||
}
|
||||
|
||||
private void OnAfterSetTick()
|
||||
{
|
||||
if (_oldPosition != null)
|
||||
SetObserverPosition(_oldPosition.Value);
|
||||
_oldPosition = null;
|
||||
}
|
||||
|
||||
public override void Shutdown()
|
||||
{
|
||||
base.Shutdown();
|
||||
_conHost.UnregisterCommand("observe");
|
||||
_replayPlayback.BeforeSetTick -= OnBeforeSetTick;
|
||||
_replayPlayback.AfterSetTick -= OnAfterSetTick;
|
||||
_replayPlayback.ReplayPlaybackStarted -= OnPlaybackStarted;
|
||||
_replayPlayback.ReplayPlaybackStopped -= OnPlaybackStopped;
|
||||
}
|
||||
|
||||
private void OnPlaybackStopped()
|
||||
{
|
||||
ShutdownMovement();
|
||||
}
|
||||
|
||||
private void OnBeforeSetTick()
|
||||
{
|
||||
_oldPosition = GetObserverPosition();
|
||||
}
|
||||
|
||||
private void OnDetached(EntityUid uid, ReplaySpectatorComponent component, PlayerDetachedEvent args)
|
||||
{
|
||||
if (uid.IsClientSide())
|
||||
QueueDel(uid);
|
||||
else
|
||||
RemCompDeferred(uid, component);
|
||||
}
|
||||
|
||||
public void SetObserverPosition(ObserverData observer)
|
||||
{
|
||||
if (Exists(observer.Entity) && Transform(observer.Entity).MapID != MapId.Nullspace)
|
||||
{
|
||||
_player.LocalPlayer!.AttachEntity(observer.Entity, EntityManager, _client);
|
||||
return;
|
||||
}
|
||||
|
||||
if (observer.Local != null && observer.Local.Value.Coords.IsValid(EntityManager))
|
||||
{
|
||||
var newXform = SpawnObserverGhost(observer.Local.Value.Coords, false);
|
||||
newXform.LocalRotation = observer.Local.Value.Rot;
|
||||
}
|
||||
else if (observer.World != null && observer.World.Value.Coords.IsValid(EntityManager))
|
||||
{
|
||||
var newXform = SpawnObserverGhost(observer.World.Value.Coords, true);
|
||||
newXform.LocalRotation = observer.World.Value.Rot;
|
||||
}
|
||||
else if (TryFindFallbackSpawn(out var coords))
|
||||
{
|
||||
var newXform = SpawnObserverGhost(coords, true);
|
||||
newXform.LocalRotation = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
Logger.Error("Failed to find a suitable observer spawn point");
|
||||
return;
|
||||
}
|
||||
|
||||
if (observer.Eye != null && TryComp(_player.LocalPlayer?.ControlledEntity, out InputMoverComponent? newMover))
|
||||
{
|
||||
newMover.RelativeEntity = observer.Eye.Value.Ent;
|
||||
newMover.TargetRelativeRotation = newMover.RelativeRotation = observer.Eye.Value.Rot;
|
||||
}
|
||||
}
|
||||
|
||||
private bool TryFindFallbackSpawn(out EntityCoordinates coords)
|
||||
{
|
||||
var uid = EntityQuery<MapGridComponent>().OrderByDescending(x => x.LocalAABB.Size.LengthSquared).FirstOrDefault()?.Owner;
|
||||
coords = new EntityCoordinates(uid ?? default, default);
|
||||
return uid != null;
|
||||
}
|
||||
|
||||
public struct ObserverData
|
||||
{
|
||||
// TODO REPLAYS handle ghost-following.
|
||||
public EntityUid Entity;
|
||||
public (EntityCoordinates Coords, Angle Rot)? Local;
|
||||
public (EntityCoordinates Coords, Angle Rot)? World;
|
||||
public (EntityUid? Ent, Angle Rot)? Eye;
|
||||
}
|
||||
|
||||
public ObserverData GetObserverPosition()
|
||||
{
|
||||
var obs = new ObserverData();
|
||||
if (_player.LocalPlayer?.ControlledEntity is { } player && TryComp(player, out TransformComponent? xform) && xform.MapUid != null)
|
||||
{
|
||||
obs.Local = (xform.Coordinates, xform.LocalRotation);
|
||||
obs.World = (new(xform.MapUid.Value, xform.WorldPosition), xform.WorldRotation);
|
||||
|
||||
if (TryComp(player, out InputMoverComponent? mover))
|
||||
obs.Eye = (mover.RelativeEntity, mover.TargetRelativeRotation);
|
||||
|
||||
obs.Entity = player;
|
||||
}
|
||||
|
||||
return obs;
|
||||
}
|
||||
|
||||
private void OnTerminating(EntityUid uid, ReplaySpectatorComponent component, ref EntityTerminatingEvent args)
|
||||
{
|
||||
if (uid != _player.LocalPlayer?.ControlledEntity)
|
||||
return;
|
||||
|
||||
var xform = Transform(uid);
|
||||
if (xform.MapUid == null || Terminating(xform.MapUid.Value))
|
||||
return;
|
||||
|
||||
SpawnObserverGhost(new EntityCoordinates(xform.MapUid.Value, default), true);
|
||||
}
|
||||
|
||||
private void OnGetAlternativeVerbs(GetVerbsEvent<AlternativeVerb> ev)
|
||||
{
|
||||
if (_replayPlayback.Replay == null)
|
||||
return;
|
||||
|
||||
var verb = new AlternativeVerb
|
||||
{
|
||||
Priority = 100,
|
||||
Act = () =>
|
||||
{
|
||||
SpectateEntity(ev.Target);
|
||||
},
|
||||
|
||||
Text = "Observe",
|
||||
Icon = new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/VerbIcons/vv.svg.192dpi.png"))
|
||||
};
|
||||
|
||||
ev.Verbs.Add(verb);
|
||||
}
|
||||
|
||||
public void SpectateEntity(EntityUid target)
|
||||
{
|
||||
if (_player.LocalPlayer == null)
|
||||
return;
|
||||
|
||||
var old = _player.LocalPlayer.ControlledEntity;
|
||||
|
||||
if (old == target)
|
||||
{
|
||||
// un-visit
|
||||
SpawnObserverGhost(Transform(target).Coordinates, true);
|
||||
return;
|
||||
}
|
||||
|
||||
_player.LocalPlayer.AttachEntity(target, EntityManager, _client);
|
||||
EnsureComp<ReplaySpectatorComponent>(target);
|
||||
|
||||
if (old == null)
|
||||
return;
|
||||
|
||||
if (old.Value.IsClientSide())
|
||||
Del(old.Value);
|
||||
else
|
||||
RemComp<ReplaySpectatorComponent>(old.Value);
|
||||
|
||||
_stateMan.RequestStateChange<ReplaySpectateEntityState>();
|
||||
}
|
||||
|
||||
public TransformComponent SpawnObserverGhost(EntityCoordinates coords, bool gridAttach)
|
||||
{
|
||||
if (_player.LocalPlayer == null)
|
||||
throw new InvalidOperationException();
|
||||
|
||||
var old = _player.LocalPlayer.ControlledEntity;
|
||||
|
||||
var ent = Spawn("MobObserver", coords);
|
||||
_eye.SetMaxZoom(ent, Vector2.One * 5);
|
||||
EnsureComp<ReplaySpectatorComponent>(ent);
|
||||
|
||||
var xform = Transform(ent);
|
||||
|
||||
if (gridAttach)
|
||||
_transform.AttachToGridOrMap(ent);
|
||||
|
||||
_player.LocalPlayer.AttachEntity(ent, EntityManager, _client);
|
||||
|
||||
if (old != null)
|
||||
{
|
||||
if (old.Value.IsClientSide())
|
||||
QueueDel(old.Value);
|
||||
else
|
||||
RemComp<ReplaySpectatorComponent>(old.Value);
|
||||
}
|
||||
|
||||
_stateMan.RequestStateChange<ReplayGhostState>();
|
||||
|
||||
return xform;
|
||||
}
|
||||
|
||||
private void ObserveCommand(IConsoleShell shell, string argStr, string[] args)
|
||||
{
|
||||
if (args.Length == 0)
|
||||
{
|
||||
if (_player.LocalPlayer?.ControlledEntity is { } current)
|
||||
SpawnObserverGhost(new EntityCoordinates(current, default), true);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!EntityUid.TryParse(args[0], out var uid))
|
||||
{
|
||||
shell.WriteError(Loc.GetString("cmd-parse-failure-uid", ("arg", args[0])));
|
||||
return;
|
||||
}
|
||||
|
||||
if (!TryComp(uid, out TransformComponent? xform))
|
||||
{
|
||||
shell.WriteError(Loc.GetString("cmd-parse-failure-entity-exist", ("arg", args[0])));
|
||||
return;
|
||||
}
|
||||
|
||||
SpectateEntity(uid);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user