tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Try fix collision mispredicts (#16298)

Browse Source
This commit is contained in:
Leon Friedrich
2023-05-13 02:02:50 +12:00
committed by GitHub
parent f1a81d9a8d
commit d228f971b0
11 changed files with 134 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
Content.Shared/Movement/Systems/SharedMoverController.Relay.cs
View File

@@ -1,7 +1,4 @@
using Content.Shared.Movement.Components;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
namespace Content.Shared.Movement.Systems;
@@ -9,136 +6,85 @@ public abstract partial class SharedMoverController
{
private void InitializeRelay()
{
SubscribeLocalEvent<RelayInputMoverComponent, ComponentGetState>(OnRelayGetState);
SubscribeLocalEvent<RelayInputMoverComponent, ComponentHandleState>(OnRelayHandleState);
SubscribeLocalEvent<RelayInputMoverComponent, ComponentShutdown>(OnRelayShutdown);
SubscribeLocalEvent<MovementRelayTargetComponent, ComponentGetState>(OnTargetRelayGetState);
SubscribeLocalEvent<MovementRelayTargetComponent, ComponentHandleState>(OnTargetRelayHandleState);
SubscribeLocalEvent<MovementRelayTargetComponent, ComponentShutdown>(OnTargetRelayShutdown);
SubscribeLocalEvent<MovementRelayTargetComponent, AfterAutoHandleStateEvent>(OnAfterRelayTargetState);
SubscribeLocalEvent<RelayInputMoverComponent, AfterAutoHandleStateEvent>(OnAfterRelayState);
}
private void OnAfterRelayTargetState(EntityUid uid, MovementRelayTargetComponent component, ref AfterAutoHandleStateEvent args)
{
Physics.UpdateIsPredicted(uid);
}
private void OnAfterRelayState(EntityUid uid, RelayInputMoverComponent component, ref AfterAutoHandleStateEvent args)
{
Physics.UpdateIsPredicted(uid);
}
/// <summary>
/// Sets the relay entity and marks the component as dirty. This only exists because people have previously
/// forgotten to Dirty(), so fuck you, you have to use this method now.
/// </summary>
public void SetRelay(EntityUid uid, EntityUid relayEntity, RelayInputMoverComponent? component = null)
public void SetRelay(EntityUid uid, EntityUid relayEntity)
{
if (!Resolve(uid, ref component) || component.RelayEntity == relayEntity)
return;
if (uid == relayEntity)
{
Logger.Error($"An entity attempted to relay movement to itself. Entity:{ToPrettyString(uid)}");
return;
}
if (TryComp<MovementRelayTargetComponent>(relayEntity, out var targetComp))
{
targetComp.Entities.Remove(uid);
var component = EnsureComp<RelayInputMoverComponent>(uid);
if (component.RelayEntity == relayEntity)
return;
if (targetComp.Entities.Count == 0)
RemComp<MovementRelayTargetComponent>(relayEntity);
if (TryComp(component.RelayEntity, out MovementRelayTargetComponent? oldTarget))
{
oldTarget.Source = EntityUid.Invalid;
RemComp(component.RelayEntity, oldTarget);
Physics.UpdateIsPredicted(component.RelayEntity);
}
var targetComp = EnsureComp<MovementRelayTargetComponent>(relayEntity);
if (TryComp(targetComp.Source, out RelayInputMoverComponent? oldRelay))
{
oldRelay.RelayEntity = EntityUid.Invalid;
RemComp(targetComp.Source, oldRelay);
Physics.UpdateIsPredicted(targetComp.Source);
}
Physics.UpdateIsPredicted(uid);
Physics.UpdateIsPredicted(relayEntity);
component.RelayEntity = relayEntity;
targetComp = EnsureComp<MovementRelayTargetComponent>(relayEntity);
targetComp.Entities.Add(uid);
DebugTools.Assert(targetComp.Entities.Count <= 1, "Multiple relayed movers are not supported at the moment");
targetComp.Source = uid;
Dirty(component);
Dirty(targetComp);
}
private void OnRelayShutdown(EntityUid uid, RelayInputMoverComponent component, ComponentShutdown args)
{
// If relay is removed then cancel all inputs.
if (!TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
Physics.UpdateIsPredicted(uid);
Physics.UpdateIsPredicted(component.RelayEntity);
if (TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
SetMoveInput(inputMover, MoveButtons.None);
if (Timing.ApplyingState)
return;
if (TryComp<MovementRelayTargetComponent>(component.RelayEntity, out var targetComp) &&
targetComp.LifeStage < ComponentLifeStage.Stopping)
{
targetComp.Entities.Remove(uid);
if (targetComp.Entities.Count == 0)
RemCompDeferred<MovementRelayTargetComponent>(component.RelayEntity.Value);
else
Dirty(targetComp);
}
SetMoveInput(inputMover, MoveButtons.None);
if (TryComp(component.RelayEntity, out MovementRelayTargetComponent? target) && target.LifeStage <= ComponentLifeStage.Running)
RemComp(component.RelayEntity, target);
}
private void OnRelayHandleState(EntityUid uid, RelayInputMoverComponent component, ref ComponentHandleState args)
{
if (args.Current is not RelayInputMoverComponentState state) return;
DebugTools.Assert(state.Entity != uid);
component.RelayEntity = state.Entity;
}
private void OnRelayGetState(EntityUid uid, RelayInputMoverComponent component, ref ComponentGetState args)
{
args.State = new RelayInputMoverComponentState()
{
Entity = component.RelayEntity,
};
}
#region Target Relay
private void OnTargetRelayShutdown(EntityUid uid, MovementRelayTargetComponent component, ComponentShutdown args)
{
if (component.Entities.Count == 0)
Physics.UpdateIsPredicted(uid);
Physics.UpdateIsPredicted(component.Source);
if (Timing.ApplyingState)
return;
var relayQuery = GetEntityQuery<RelayInputMoverComponent>();
foreach (var ent in component.Entities)
{
if (!relayQuery.TryGetComponent(ent, out var relay))
continue;
DebugTools.Assert(relay.RelayEntity == uid);
if (relay.RelayEntity != uid)
continue;
RemCompDeferred<RelayInputMoverComponent>(ent);
}
}
private void OnTargetRelayHandleState(EntityUid uid, MovementRelayTargetComponent component, ref ComponentHandleState args)
{
if (args.Current is not MovementRelayTargetComponentState state)
return;
component.Entities.Clear();
component.Entities.AddRange(state.Entities);
DebugTools.Assert(component.Entities.Count <= 1, "Multiple relayed movers are not supported at the moment");
}
private void OnTargetRelayGetState(EntityUid uid, MovementRelayTargetComponent component, ref ComponentGetState args)
{
args.State = new MovementRelayTargetComponentState(component.Entities);
}
#endregion
[Serializable, NetSerializable]
private sealed class RelayInputMoverComponentState : ComponentState
{
public EntityUid? Entity;
}
[Serializable, NetSerializable]
private sealed class MovementRelayTargetComponentState : ComponentState
{
public List<EntityUid> Entities;
public MovementRelayTargetComponentState(List<EntityUid> entities)
{
Entities = entities;
}
if (TryComp(component.Source, out RelayInputMoverComponent? relay) && relay.LifeStage <= ComponentLifeStage.Running)
RemComp(component.Source, relay);
}
}