using Content.Shared.Movement.Systems;
using Content.Shared.Pulling.Components;
using Robust.Client.GameObjects;
+using Robust.Client.Physics;
using Robust.Client.Player;
-using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
-using Robust.Shared.Utility;
namespace Content.Client.Physics.Controllers
{
SubscribeLocalEvent<RelayInputMoverComponent, PlayerDetachedEvent>(OnRelayPlayerDetached);
SubscribeLocalEvent<InputMoverComponent, PlayerAttachedEvent>(OnPlayerAttached);
SubscribeLocalEvent<InputMoverComponent, PlayerDetachedEvent>(OnPlayerDetached);
+
+ SubscribeLocalEvent<InputMoverComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
+ SubscribeLocalEvent<MovementRelayTargetComponent, UpdateIsPredictedEvent>(OnUpdateRelayTargetPredicted);
+ SubscribeLocalEvent<SharedPullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
+ }
+
+ private void OnUpdatePredicted(EntityUid uid, InputMoverComponent component, ref UpdateIsPredictedEvent args)
+ {
+ // Enable prediction if an entity is controlled by the player
+ if (uid == _playerManager.LocalPlayer?.ControlledEntity)
+ args.IsPredicted = true;
+ }
+
+ private void OnUpdateRelayTargetPredicted(EntityUid uid, MovementRelayTargetComponent component, ref UpdateIsPredictedEvent args)
+ {
+ if (component.Source == _playerManager.LocalPlayer?.ControlledEntity)
+ args.IsPredicted = true;
+ }
+
+ private void OnUpdatePullablePredicted(EntityUid uid, SharedPullableComponent component, ref UpdateIsPredictedEvent args)
+ {
+ // Enable prediction if an entity is being pulled by the player.
+ // Disable prediction if an entity is being pulled by some non-player entity.
+
+ if (component.Puller == _playerManager.LocalPlayer?.ControlledEntity)
+ args.IsPredicted = true;
+ else if (component.Puller != null)
+ args.BlockPrediction = true;
+
+ // TODO recursive pulling checks?
+ // What if the entity is being pulled by a vehicle controlled by the player?
}
private void OnRelayPlayerAttached(EntityUid uid, RelayInputMoverComponent component, PlayerAttachedEvent args)
{
+ Physics.UpdateIsPredicted(uid);
+ Physics.UpdateIsPredicted(component.RelayEntity);
if (TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
SetMoveInput(inputMover, MoveButtons.None);
}
private void OnRelayPlayerDetached(EntityUid uid, RelayInputMoverComponent component, PlayerDetachedEvent args)
{
+ Physics.UpdateIsPredicted(uid);
+ Physics.UpdateIsPredicted(component.RelayEntity);
if (TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
SetMoveInput(inputMover, MoveButtons.None);
}
if (_playerManager.LocalPlayer?.ControlledEntity is not {Valid: true} player)
return;
- if (TryComp<RelayInputMoverComponent>(player, out var relayMover)
- && TryComp(relayMover.RelayEntity, out MovementRelayTargetComponent? targetComp))
- {
- DebugTools.Assert(targetComp.Entities.Count <= 1, "Multiple relayed movers are not supported at the moment");
- HandleClientsideMovement(relayMover.RelayEntity.Value, frameTime);
- }
+ if (TryComp<RelayInputMoverComponent>(player, out var relayMover))
+ HandleClientsideMovement(relayMover.RelayEntity, frameTime);
HandleClientsideMovement(player, frameTime);
}
var relayTargetQuery = GetEntityQuery<MovementRelayTargetComponent>();
var mobMoverQuery = GetEntityQuery<MobMoverComponent>();
var pullableQuery = GetEntityQuery<SharedPullableComponent>();
- var physicsQuery = GetEntityQuery<PhysicsComponent>();
var modifierQuery = GetEntityQuery<MovementSpeedModifierComponent>();
if (!moverQuery.TryGetComponent(player, out var mover) ||
return;
}
- // Essentially we only want to set our mob to predicted so every other entity we just interpolate
- // (i.e. only see what the server has sent us).
- // The exception to this is joints.
- body.Predict = true;
-
- // We set joints to predicted given these can affect how our mob moves.
- // I would only recommend disabling this if you make pulling not use joints anymore (someday maybe?)
-
- if (TryComp(player, out JointComponent? jointComponent))
- {
- foreach (var joint in jointComponent.GetJoints.Values)
- {
- if (physicsQuery.TryGetComponent(joint.BodyAUid, out var physics))
- physics.Predict = true;
-
- if (physicsQuery.TryGetComponent(joint.BodyBUid, out physics))
- physics.Predict = true;
- }
- }
-
- // If we're being pulled then we won't predict anything and will receive server lerps so it looks way smoother.
- if (pullableQuery.TryGetComponent(player, out var pullableComp))
- {
- if (pullableComp.Puller is {Valid: true} puller && TryComp<PhysicsComponent>(puller, out var pullerBody))
- {
- pullerBody.Predict = false;
- body.Predict = false;
-
- if (TryComp<SharedPullerComponent>(player, out var playerPuller) && playerPuller.Pulling != null &&
- physicsQuery.TryGetComponent(playerPuller.Pulling, out var pulledBody))
- {
- pulledBody.Predict = false;
- }
- }
- }
-
// Server-side should just be handled on its own so we'll just do this shizznit
HandleMobMovement(
player,
-using Content.Client.Clickable;
using Content.Client.Gameplay;
using Content.Shared.Weapons.Ranged.Systems;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Input;
+using Robust.Client.Physics;
using Robust.Client.State;
using Robust.Shared.Input;
using Robust.Shared.Map;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly IInputManager _inputManager = default!;
[Dependency] private readonly InputSystem _inputSystem = default!;
+ [Dependency] private readonly PhysicsSystem _physics = default!;
public bool Enabled { get; set; }
base.Initialize();
SubscribeNetworkEvent<PredictTetherEvent>(OnPredictTether);
SubscribeNetworkEvent<TetherGunToggleMessage>(OnTetherGun);
+ SubscribeLocalEvent<UpdateIsPredictedEvent>(OnUpdatePrediction);
+ }
+
+ private void OnUpdatePrediction(ref UpdateIsPredictedEvent ev)
+ {
+ if (ev.Uid == _dragging || ev.Uid == _tether)
+ ev.IsPredicted = true;
}
private void OnTetherGun(TetherGunToggleMessage ev)
private void OnPredictTether(PredictTetherEvent ev)
{
- if (_dragging != ev.Entity) return;
+ if (_dragging != ev.Entity || _tether == ev.Entity)
+ return;
+ var oldTether = _tether;
_tether = ev.Entity;
- }
-
- public override void FrameUpdate(float frameTime)
- {
- base.FrameUpdate(frameTime);
- if (!TryComp<PhysicsComponent>(_dragging, out var body)) return;
-
- body.Predict = true;
-
- if (TryComp<PhysicsComponent>(_tether, out var tetherBody))
- {
- tetherBody.Predict = true;
- }
+ _physics.UpdateIsPredicted(oldTether);
+ _physics.UpdateIsPredicted(_tether);
}
public override void Update(float frameTime)
return;
}
- body.Predict = true;
-
- if (TryComp<PhysicsComponent>(_tether, out var tetherBody))
- {
- tetherBody.Predict = true;
- }
-
if (_lastMousePosition.Value.Position.EqualsApprox(mousePos.Position)) return;
_lastMousePosition = mousePos;
{
if (_dragging == null) return;
+ var oldDrag = _dragging;
+ var oldTether = _tether;
RaiseNetworkEvent(new StopTetherEvent());
_dragging = null;
_lastMousePosition = null;
_tether = null;
+
+ _physics.UpdateIsPredicted(oldDrag);
+ _physics.UpdateIsPredicted(oldTether);
}
private void StartDragging(EntityUid uid, MapCoordinates coordinates)
Entity = _dragging!.Value,
Coordinates = coordinates,
});
+
+ _physics.UpdateIsPredicted(uid);
+
}
}
RemComp<RelayInputMoverComponent>(component.Mover.Value);
}
- var relay = EnsureComp<RelayInputMoverComponent>(args.Entity);
- _mover.SetRelay(args.Entity, uid, relay);
+ _mover.SetRelay(args.Entity, uid);
component.Mover = args.Entity;
}
return;
var rider = EnsureComp<MechPilotComponent>(pilot);
- var relay = EnsureComp<RelayInputMoverComponent>(pilot);
// Warning: this bypasses most normal interaction blocking components on the user, like drone laws and the like.
var irelay = EnsureComp<InteractionRelayComponent>(pilot);
- _mover.SetRelay(pilot, mech, relay);
+ _mover.SetRelay(pilot, mech);
_interaction.SetRelay(pilot, mech, irelay);
rider.Mech = mech;
Dirty(rider);
+using Content.Shared.Movement.Systems;
using Robust.Shared.GameStates;
namespace Content.Shared.Movement.Components;
-[RegisterComponent, NetworkedComponent]
-public sealed class MovementRelayTargetComponent : Component
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
+[Access(typeof(SharedMoverController))]
+public sealed partial class MovementRelayTargetComponent : Component
{
- // This really shouldn't be a list at the moment. Its just not supported.
- // Neither movement updating, nor HandleDirChange() support more than one mover.
- // Its currently possible for the direction to be set by one mover and the relative rotation to be set by a separate unrelated mover.
- // AAAAA
-
/// <summary>
- /// Entities that are relaying to us.
+ /// The entity that is relaying to this entity.
/// </summary>
- [ViewVariables] public readonly List<EntityUid> Entities = new();
+ [ViewVariables, AutoNetworkedField]
+ public EntityUid Source;
}
/// <summary>
/// Raises the engine movement inputs for a particular entity onto the designated entity
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
[Access(typeof(SharedMoverController))]
-public sealed class RelayInputMoverComponent : Component
+public sealed partial class RelayInputMoverComponent : Component
{
- [ViewVariables]
- public EntityUid? RelayEntity;
+ [ViewVariables, AutoNetworkedField]
+ public EntityUid RelayEntity;
}
private void SetupUser(EntityUid uid, JetpackComponent component)
{
var user = EnsureComp<JetpackUserComponent>(uid);
- var relay = EnsureComp<RelayInputMoverComponent>(uid);
- _mover.SetRelay(uid, component.Owner, relay);
+ _mover.SetRelay(uid, component.Owner);
user.Jetpack = component.Owner;
}
if (TryComp<InputMoverComponent>(entity, out var mover))
SetMoveInput(mover, MoveButtons.None);
- DebugTools.Assert(TryComp(relayMover.RelayEntity, out MovementRelayTargetComponent? targetComp) && targetComp.Entities.Count == 1,
- "Multiple relayed movers are not supported at the moment");
-
- if (relayMover.RelayEntity != null && !_mobState.IsIncapacitated(entity))
- HandleDirChange(relayMover.RelayEntity.Value, dir, subTick, state);
+ if (!_mobState.IsIncapacitated(entity))
+ HandleDirChange(relayMover.RelayEntity, dir, subTick, state);
return;
}
SetMoveInput(moverComp, MoveButtons.None);
}
- if (relayMover.RelayEntity == null) return;
-
- HandleRunChange(relayMover.RelayEntity.Value, subTick, walking);
+ HandleRunChange(relayMover.RelayEntity, subTick, walking);
return;
}
using Content.Shared.Movement.Components;
-using Robust.Shared.GameStates;
-using Robust.Shared.Serialization;
-using Robust.Shared.Utility;
namespace Content.Shared.Movement.Systems;
{
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))
+ var component = EnsureComp<RelayInputMoverComponent>(uid);
+ if (component.RelayEntity == relayEntity)
+ return;
+
+ if (TryComp(component.RelayEntity, out MovementRelayTargetComponent? oldTarget))
{
- targetComp.Entities.Remove(uid);
+ oldTarget.Source = EntityUid.Invalid;
+ RemComp(component.RelayEntity, oldTarget);
+ Physics.UpdateIsPredicted(component.RelayEntity);
+ }
- if (targetComp.Entities.Count == 0)
- RemComp<MovementRelayTargetComponent>(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))
- 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);
- }
+ Physics.UpdateIsPredicted(uid);
+ Physics.UpdateIsPredicted(component.RelayEntity);
- private void OnRelayHandleState(EntityUid uid, RelayInputMoverComponent component, ref ComponentHandleState args)
- {
- if (args.Current is not RelayInputMoverComponentState state) return;
+ if (TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
+ SetMoveInput(inputMover, MoveButtons.None);
- DebugTools.Assert(state.Entity != uid);
- component.RelayEntity = state.Entity;
- }
+ if (Timing.ApplyingState)
+ return;
- private void OnRelayGetState(EntityUid uid, RelayInputMoverComponent component, ref ComponentGetState args)
- {
- args.State = new RelayInputMoverComponentState()
- {
- Entity = component.RelayEntity,
- };
+ if (TryComp(component.RelayEntity, out MovementRelayTargetComponent? target) && target.LifeStage <= ComponentLifeStage.Running)
+ RemComp(component.RelayEntity, target);
}
- #region Target Relay
-
private void OnTargetRelayShutdown(EntityUid uid, MovementRelayTargetComponent component, ComponentShutdown args)
{
- if (component.Entities.Count == 0)
- return;
-
- var relayQuery = GetEntityQuery<RelayInputMoverComponent>();
-
- foreach (var ent in component.Entities)
- {
- if (!relayQuery.TryGetComponent(ent, out var relay))
- continue;
-
- DebugTools.Assert(relay.RelayEntity == uid);
+ Physics.UpdateIsPredicted(uid);
+ Physics.UpdateIsPredicted(component.Source);
- 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)
+ if (Timing.ApplyingState)
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);
}
}
{
[Dependency] private readonly IConfigurationManager _configManager = default!;
[Dependency] protected readonly IGameTiming Timing = default!;
+ [Dependency] protected readonly SharedPhysicsSystem Physics = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
EntityQuery<MovementSpeedModifierComponent> modifierQuery)
{
var canMove = mover.CanMove;
- if (relayTargetQuery.TryGetComponent(uid, out var relayTarget) && relayTarget.Entities.Count > 0)
+ if (relayTargetQuery.TryGetComponent(uid, out var relayTarget))
{
- DebugTools.Assert(relayTarget.Entities.Count <= 1, "Multiple relayed movers are not supported at the moment");
-
- var found = false;
- foreach (var ent in relayTarget.Entities)
+ if (_mobState.IsIncapacitated(relayTarget.Source) ||
+ !moverQuery.TryGetComponent(relayTarget.Source, out var relayedMover))
+ {
+ canMove = false;
+ }
+ else
{
- if (_mobState.IsIncapacitated(ent) || !moverQuery.TryGetComponent(ent, out var relayedMover))
- continue;
-
- found = true;
mover.RelativeEntity = relayedMover.RelativeEntity;
mover.RelativeRotation = relayedMover.RelativeRotation;
mover.TargetRelativeRotation = relayedMover.TargetRelativeRotation;
- break;
}
-
- // lets just hope that this is the same entity that set the movement keys/direction.
- canMove &= found;
}
// Update relative movement
// If we're a relay target then predict the sound for all relays.
if (relayTarget != null)
{
- foreach (var ent in relayTarget.Entities)
- {
- _audio.PlayPredicted(sound, uid, ent, audioParams);
- }
+ _audio.PlayPredicted(sound, uid, relayTarget.Source, audioParams);
}
else
{
Dirty(component);
Appearance.SetData(uid, VehicleVisuals.HideRider, true);
- var relay = EnsureComp<RelayInputMoverComponent>(args.BuckledEntity);
- _mover.SetRelay(args.BuckledEntity, uid, relay);
+ _mover.SetRelay(args.BuckledEntity, uid);
rider.Vehicle = uid;
// Update appearance stuff, add actions
projects / space-station-14.git / commitdiff