Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Pulling rework v2 (#24936)

Browse Source 
* Pulling rework

Fixing up the FOUR systems managing pulling, all the shitcode, and also making it nicer ingame.

* More pulling cleanup

* stats

* More cleanup

* First draft

* More pulling

* weh

* Fix puller

* Pulling working

* Fix merge

* Dunked

* Self-merge time

* Fix hotkey

* Fix container changes

* oop

* Fix multi-pulling

* Move alerts cleanup.

* pulling fixes
This commit is contained in:
metalgearsloth
2024-03-19 14:30:56 +11:00
committed by GitHub
parent f8b54a06b7
commit c584f6444a
53 changed files with 797 additions and 1357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Content.Shared/Administration/AdminFrozenSystem.cs
View File

@@ -1,13 +1,10 @@
using Content.Shared.ActionBlocker;
using Content.Shared.Interaction.Events;
using Content.Shared.Item;
using Content.Shared.Movement;
using Content.Shared.Movement.Events;
using Content.Shared.Physics.Pull;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Pulling.Events;
using Content.Shared.Stunnable;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Events;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Throwing;
namespace Content.Shared.Administration;
@@ -15,7 +12,7 @@ namespace Content.Shared.Administration;
public sealed class AdminFrozenSystem : EntitySystem
{
[Dependency] private readonly ActionBlockerSystem _blocker = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
public override void Initialize()
{
@@ -45,9 +42,9 @@ public sealed class AdminFrozenSystem : EntitySystem
private void OnStartup(EntityUid uid, AdminFrozenComponent component, ComponentStartup args)
{
if (TryComp<SharedPullableComponent>(uid, out var pullable))
if (TryComp<PullableComponent>(uid, out var pullable))
{
_pulling.TryStopPull(pullable);
_pulling.TryStopPull(uid, pullable);
}
UpdateCanMove(uid, component, args);

10
Content.Shared/Buckle/SharedBuckleSystem.Buckle.cs
View File

@@ -10,7 +10,6 @@ using Content.Shared.Interaction;
using Content.Shared.Mobs.Components;
using Content.Shared.Movement.Events;
using Content.Shared.Popups;
using Content.Shared.Pulling.Components;
using Content.Shared.Standing;
using Content.Shared.Storage.Components;
using Content.Shared.Stunnable;
@@ -19,6 +18,7 @@ using Content.Shared.Verbs;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Robust.Shared.Utility;
using PullableComponent = Content.Shared.Movement.Pulling.Components.PullableComponent;
namespace Content.Shared.Buckle;
@@ -348,11 +348,11 @@ public abstract partial class SharedBuckleSystem
RaiseLocalEvent(ev.BuckledEntity, ref ev);
RaiseLocalEvent(ev.StrapEntity, ref ev);
if (TryComp<SharedPullableComponent>(buckleUid, out var ownerPullable))
if (TryComp<PullableComponent>(buckleUid, out var ownerPullable))
{
if (ownerPullable.Puller != null)
{
_pulling.TryStopPull(ownerPullable);
_pulling.TryStopPull(buckleUid, ownerPullable);
}
}
@@ -361,12 +361,12 @@ public abstract partial class SharedBuckleSystem
_physics.ResetDynamics(physics);
}
if (!buckleComp.PullStrap && TryComp<SharedPullableComponent>(strapUid, out var toPullable))
if (!buckleComp.PullStrap && TryComp<PullableComponent>(strapUid, out var toPullable))
{
if (toPullable.Puller == buckleUid)
{
// can't pull it and buckle to it at the same time
_pulling.TryStopPull(toPullable);
_pulling.TryStopPull(strapUid, toPullable);
}
}

3
Content.Shared/Buckle/SharedBuckleSystem.cs
View File

@@ -15,6 +15,7 @@ using Robust.Shared.Network;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using PullingSystem = Content.Shared.Movement.Pulling.Systems.PullingSystem;
namespace Content.Shared.Buckle;
@@ -35,7 +36,7 @@ public abstract partial class SharedBuckleSystem : EntitySystem
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly SharedJointSystem _joints = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly StandingStateSystem _standing = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;

15
Content.Shared/Construction/EntitySystems/AnchorableSystem.cs
View File

@@ -6,16 +6,15 @@ using Content.Shared.Coordinates.Helpers;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Popups;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Tools;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Content.Shared.Tag;
using Robust.Shared.Player;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
@@ -27,7 +26,7 @@ public sealed partial class AnchorableSystem : EntitySystem
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly SharedToolSystem _tool = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly TagSystem _tagSystem = default!;
@@ -132,9 +131,9 @@ public sealed partial class AnchorableSystem : EntitySystem
var rot = xform.LocalRotation;
xform.LocalRotation = Math.Round(rot / (Math.PI / 2)) * (Math.PI / 2);
if (TryComp<SharedPullableComponent>(uid, out var pullable) && pullable.Puller != null)
if (TryComp<PullableComponent>(uid, out var pullable) && pullable.Puller != null)
{
_pulling.TryStopPull(pullable);
_pulling.TryStopPull(uid, pullable);
}
// TODO: Anchoring snaps rn anyway!
@@ -175,7 +174,7 @@ public sealed partial class AnchorableSystem : EntitySystem
public void TryToggleAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
PullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref transform))
@@ -198,7 +197,7 @@ public sealed partial class AnchorableSystem : EntitySystem
private void TryAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
PullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable, ref transform))

14
Content.Shared/Cuffs/SharedCuffableSystem.cs
View File

@@ -21,9 +21,8 @@ using Content.Shared.Inventory.VirtualItem;
using Content.Shared.Item;
using Content.Shared.Mobs.Systems;
using Content.Shared.Movement.Events;
using Content.Shared.Physics.Pull;
using Content.Shared.Movement.Pulling.Events;
using Content.Shared.Popups;
using Content.Shared.Pulling.Components;
using Content.Shared.Pulling.Events;
using Content.Shared.Rejuvenate;
using Content.Shared.Stunnable;
@@ -36,6 +35,7 @@ using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Robust.Shared.Serialization;
using PullableComponent = Content.Shared.Movement.Pulling.Components.PullableComponent;
namespace Content.Shared.Cuffs
{
@@ -70,7 +70,7 @@ namespace Content.Shared.Cuffs
SubscribeLocalEvent<CuffableComponent, EntInsertedIntoContainerMessage>(OnCuffsInsertedIntoContainer);
SubscribeLocalEvent<CuffableComponent, RejuvenateEvent>(OnRejuvenate);
SubscribeLocalEvent<CuffableComponent, ComponentInit>(OnStartup);
SubscribeLocalEvent<CuffableComponent, StopPullingEvent>(HandleStopPull);
SubscribeLocalEvent<CuffableComponent, AttemptStopPullingEvent>(HandleStopPull);
SubscribeLocalEvent<CuffableComponent, UpdateCanMoveEvent>(HandleMoveAttempt);
SubscribeLocalEvent<CuffableComponent, IsEquippingAttemptEvent>(OnEquipAttempt);
SubscribeLocalEvent<CuffableComponent, IsUnequippingAttemptEvent>(OnUnequipAttempt);
@@ -182,7 +182,7 @@ namespace Content.Shared.Cuffs
private void OnBeingPulledAttempt(EntityUid uid, CuffableComponent component, BeingPulledAttemptEvent args)
{
if (!TryComp<SharedPullableComponent>(uid, out var pullable))
if (!TryComp<PullableComponent>(uid, out var pullable))
return;
if (pullable.Puller != null && !component.CanStillInteract) // If we are being pulled already and cuffed, we can't get pulled again.
@@ -214,19 +214,19 @@ namespace Content.Shared.Cuffs
private void HandleMoveAttempt(EntityUid uid, CuffableComponent component, UpdateCanMoveEvent args)
{
if (component.CanStillInteract || !EntityManager.TryGetComponent(uid, out SharedPullableComponent? pullable) || !pullable.BeingPulled)
if (component.CanStillInteract || !EntityManager.TryGetComponent(uid, out PullableComponent? pullable) || !pullable.BeingPulled)
return;
args.Cancel();
}
private void HandleStopPull(EntityUid uid, CuffableComponent component, StopPullingEvent args)
private void HandleStopPull(EntityUid uid, CuffableComponent component, AttemptStopPullingEvent args)
{
if (args.User == null || !Exists(args.User.Value))
return;
if (args.User.Value == uid && !component.CanStillInteract)
args.Cancel();
args.Cancelled = true;
}
private void AddUncuffVerb(EntityUid uid, CuffableComponent component, GetVerbsEvent<Verb> args)

2
Content.Shared/Follower/FollowerSystem.cs
View File

@@ -4,8 +4,8 @@ using Content.Shared.Follower.Components;
using Content.Shared.Ghost;
using Content.Shared.Hands;
using Content.Shared.Movement.Events;
using Content.Shared.Movement.Pulling.Events;
using Content.Shared.Movement.Systems;
using Content.Shared.Physics.Pull;
using Content.Shared.Tag;
using Content.Shared.Verbs;
using Robust.Shared.Containers;

39
Content.Shared/Friction/TileFrictionController.cs
View File

@@ -2,8 +2,8 @@ using System.Numerics;
using Content.Shared.CCVar;
using Content.Shared.Gravity;
using Content.Shared.Movement.Events;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Systems;
using Content.Shared.Pulling.Components;
using JetBrains.Annotations;
using Robust.Shared.Configuration;
using Robust.Shared.Map;
@@ -23,6 +23,12 @@ namespace Content.Shared.Friction
[Dependency] private readonly SharedMoverController _mover = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
private EntityQuery<TileFrictionModifierComponent> _frictionQuery;
private EntityQuery<TransformComponent> _xformQuery;
private EntityQuery<PullerComponent> _pullerQuery;
private EntityQuery<PullableComponent> _pullableQuery;
private EntityQuery<MapGridComponent> _gridQuery;
private float _stopSpeed;
private float _frictionModifier;
public const float DefaultFriction = 0.3f;
@@ -33,18 +39,17 @@ namespace Content.Shared.Friction
Subs.CVar(_configManager, CCVars.TileFrictionModifier, value => _frictionModifier = value, true);
Subs.CVar(_configManager, CCVars.StopSpeed, value => _stopSpeed = value, true);
_frictionQuery = GetEntityQuery<TileFrictionModifierComponent>();
_xformQuery = GetEntityQuery<TransformComponent>();
_pullerQuery = GetEntityQuery<PullerComponent>();
_pullableQuery = GetEntityQuery<PullableComponent>();
_gridQuery = GetEntityQuery<MapGridComponent>();
}
public override void UpdateBeforeMapSolve(bool prediction, PhysicsMapComponent mapComponent, float frameTime)
{
base.UpdateBeforeMapSolve(prediction, mapComponent, frameTime);
var frictionQuery = GetEntityQuery<TileFrictionModifierComponent>();
var xformQuery = GetEntityQuery<TransformComponent>();
var pullerQuery = GetEntityQuery<SharedPullerComponent>();
var pullableQuery = GetEntityQuery<SharedPullableComponent>();
var gridQuery = GetEntityQuery<MapGridComponent>();
foreach (var body in mapComponent.AwakeBodies)
{
var uid = body.Owner;
@@ -60,16 +65,16 @@ namespace Content.Shared.Friction
if (body.LinearVelocity.Equals(Vector2.Zero) && body.AngularVelocity.Equals(0f))
continue;
if (!xformQuery.TryGetComponent(uid, out var xform))
if (!_xformQuery.TryGetComponent(uid, out var xform))
{
Log.Error($"Unable to get transform for {ToPrettyString(uid)} in tilefrictioncontroller");
continue;
}
var surfaceFriction = GetTileFriction(uid, body, xform, gridQuery, frictionQuery);
var surfaceFriction = GetTileFriction(uid, body, xform);
var bodyModifier = 1f;
if (frictionQuery.TryGetComponent(uid, out var frictionComp))
if (_frictionQuery.TryGetComponent(uid, out var frictionComp))
{
bodyModifier = frictionComp.Modifier;
}
@@ -82,8 +87,8 @@ namespace Content.Shared.Friction
// If we're sandwiched between 2 pullers reduce friction
// Might be better to make this dynamic and check how many are in the pull chain?
// Either way should be much faster for now.
if (pullerQuery.TryGetComponent(uid, out var puller) && puller.Pulling != null &&
pullableQuery.TryGetComponent(uid, out var pullable) && pullable.BeingPulled)
if (_pullerQuery.TryGetComponent(uid, out var puller) && puller.Pulling != null &&
_pullableQuery.TryGetComponent(uid, out var pullable) && pullable.BeingPulled)
{
bodyModifier *= 0.2f;
}
@@ -163,9 +168,7 @@ namespace Content.Shared.Friction
private float GetTileFriction(
EntityUid uid,
PhysicsComponent body,
TransformComponent xform,
EntityQuery<MapGridComponent> gridQuery,
EntityQuery<TileFrictionModifierComponent> frictionQuery)
TransformComponent xform)
{
// TODO: Make IsWeightless event-based; we already have grid traversals tracked so just raise events
if (_gravity.IsWeightless(uid, body, xform))
@@ -175,9 +178,9 @@ namespace Content.Shared.Friction
return 0.0f;
// If not on a grid then return the map's friction.
if (!gridQuery.TryGetComponent(xform.GridUid, out var grid))
if (!_gridQuery.TryGetComponent(xform.GridUid, out var grid))
{
return frictionQuery.TryGetComponent(xform.MapUid, out var friction)
return _frictionQuery.TryGetComponent(xform.MapUid, out var friction)
? friction.Modifier
: DefaultFriction;
}
@@ -197,7 +200,7 @@ namespace Content.Shared.Friction
while (anc.MoveNext(out var tileEnt))
{
if (frictionQuery.TryGetComponent(tileEnt, out var friction))
if (_frictionQuery.TryGetComponent(tileEnt, out var friction))
return friction.Modifier;
}

10
Content.Shared/Interaction/SharedInteractionSystem.cs
View File

@@ -15,10 +15,10 @@ using Content.Shared.Inventory;
using Content.Shared.Inventory.Events;
using Content.Shared.Item;
using Content.Shared.Movement.Components;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Physics;
using Content.Shared.Popups;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Tag;
using Content.Shared.Timing;
using Content.Shared.Verbs;
@@ -60,7 +60,7 @@ namespace Content.Shared.Interaction
[Dependency] private readonly SharedVerbSystem _verbSystem = default!;
[Dependency] private readonly SharedPopupSystem _popupSystem = default!;
[Dependency] private readonly UseDelaySystem _useDelay = default!;
[Dependency] private readonly SharedPullingSystem _pullSystem = default!;
[Dependency] private readonly PullingSystem _pullSystem = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly TagSystem _tagSystem = default!;
@@ -185,10 +185,10 @@ namespace Content.Shared.Interaction
if (!InRangeUnobstructed(userEntity.Value, uid, popup: true))
return false;
if (!TryComp(uid, out SharedPullableComponent? pull))
if (!TryComp(uid, out PullableComponent? pull))
return false;
_pullSystem.TogglePull(userEntity.Value, pull);
_pullSystem.TogglePull(uid, userEntity.Value, pull);
return false;
}

39
Content.Shared/Movement/Pulling/Components/PullableComponent.cs Normal file
View File

@@ -0,0 +1,39 @@
using Robust.Shared.GameStates;
namespace Content.Shared.Movement.Pulling.Components;
/// <summary>
/// Specifies an entity as being pullable by an entity with <see cref="PullerComponent"/>
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(Systems.PullingSystem))]
public sealed partial class PullableComponent : Component
{
/// <summary>
/// The current entity pulling this component.
/// </summary>
[AutoNetworkedField, DataField]
public EntityUid? Puller;
/// <summary>
/// The pull joint.
/// </summary>
[AutoNetworkedField, DataField]
public string? PullJointId;
public bool BeingPulled => Puller != null;
/// <summary>
/// If the physics component has FixedRotation should we keep it upon being pulled
/// </summary>
[Access(typeof(Systems.PullingSystem), Other = AccessPermissions.ReadExecute)]
[ViewVariables(VVAccess.ReadWrite), DataField("fixedRotation")]
public bool FixedRotationOnPull;
/// <summary>
/// What the pullable's fixedrotation was set to before being pulled.
/// </summary>
[Access(typeof(Systems.PullingSystem), Other = AccessPermissions.ReadExecute)]
[AutoNetworkedField, DataField]
public bool PrevFixedRotation;
}

41
Content.Shared/Movement/Pulling/Components/PullerComponent.cs Normal file
View File

@@ -0,0 +1,41 @@
using Content.Shared.Movement.Pulling.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
namespace Content.Shared.Movement.Pulling.Components;
/// <summary>
/// Specifies an entity as being able to pull another entity with <see cref="PullableComponent"/>
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(PullingSystem))]
public sealed partial class PullerComponent : Component
{
// My raiding guild
/// <summary>
/// Next time the puller can throw what is being pulled.
/// Used to avoid spamming it for infinite spin + velocity.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
public TimeSpan NextThrow;
[DataField]
public TimeSpan ThrowCooldown = TimeSpan.FromSeconds(1);
// Before changing how this is updated, please see SharedPullerSystem.RefreshMovementSpeed
public float WalkSpeedModifier => Pulling == default ? 1.0f : 0.95f;
public float SprintSpeedModifier => Pulling == default ? 1.0f : 0.95f;
/// <summary>
/// Entity currently being pulled if applicable.
/// </summary>
[AutoNetworkedField, DataField]
public EntityUid? Pulling;
/// <summary>
/// Does this entity need hands to be able to pull something?
/// </summary>
[DataField]
public bool NeedsHands = true;
}

13
Content.Shared/Movement/Pulling/Events/AttemptPullEvent.cs Normal file
View File

@@ -0,0 +1,13 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Movement.Pulling.Events;
/// <summary>
/// Raised directed on puller and pullable to determine if it can be pulled.
/// </summary>
public sealed class PullAttemptEvent : PullMessage
{
public PullAttemptEvent(EntityUid pullerUid, EntityUid pullableUid) : base(pullerUid, pullableUid) { }
public bool Cancelled { get; set; }
}

10
Content.Shared/Movement/Pulling/Events/AttemptStopPullingEvent.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace Content.Shared.Pulling.Events;
/// <summary>
/// Raised when a request is made to stop pulling an entity.
/// </summary>
public record struct AttemptStopPullingEvent(EntityUid? User = null)
{
public readonly EntityUid? User = User;
public bool Cancelled;
}

0
Content.Shared/Pulling/Events/BeingPulledAttemptEvent.cs → Content.Shared/Movement/Pulling/Events/BeingPulledAttemptEvent.cs
View File

13
Content.Shared/Movement/Pulling/Events/PullMessage.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace Content.Shared.Movement.Pulling.Events;
public abstract class PullMessage : EntityEventArgs
{
public readonly EntityUid PullerUid;
public readonly EntityUid PulledUid;
protected PullMessage(EntityUid pullerUid, EntityUid pulledUid)
{
PullerUid = pullerUid;
PulledUid = pulledUid;
}
}

9
Content.Shared/Movement/Pulling/Events/PullStartedMessage.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Content.Shared.Movement.Pulling.Events;
public sealed class PullStartedMessage : PullMessage
{
public PullStartedMessage(EntityUid pullerUid, EntityUid pullableUid) :
base(pullerUid, pullableUid)
{
}
}

13
Content.Shared/Movement/Pulling/Events/PullStoppedMessage.cs Normal file
View File

@@ -0,0 +1,13 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Movement.Pulling.Events;
/// <summary>
/// Raised directed on both puller and pullable.
/// </summary>
public sealed class PullStoppedMessage : PullMessage
{
public PullStoppedMessage(EntityUid pullerUid, EntityUid pulledUid) : base(pullerUid, pulledUid)
{
}
}

0
Content.Shared/Pulling/Events/StartPullAttemptEvent.cs → Content.Shared/Movement/Pulling/Events/StartPullAttemptEvent.cs
View File

492
Content.Shared/Movement/Pulling/Systems/PullingSystem.cs Normal file
View File

@@ -0,0 +1,492 @@
using System.Numerics;
using Content.Shared.ActionBlocker;
using Content.Shared.Administration.Logs;
using Content.Shared.Alert;
using Content.Shared.Buckle.Components;
using Content.Shared.Database;
using Content.Shared.Hands;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Input;
using Content.Shared.Interaction;
using Content.Shared.Movement.Events;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Events;
using Content.Shared.Movement.Systems;
using Content.Shared.Pulling.Events;
using Content.Shared.Throwing;
using Content.Shared.Verbs;
using Robust.Shared.Containers;
using Robust.Shared.Input.Binding;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
using Robust.Shared.Timing;
namespace Content.Shared.Movement.Pulling.Systems;
/// <summary>
/// Allows one entity to pull another behind them via a physics distance joint.
/// </summary>
public sealed class PullingSystem : EntitySystem
{
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly ActionBlockerSystem _blocker = default!;
[Dependency] private readonly AlertsSystem _alertsSystem = default!;
[Dependency] private readonly MovementSpeedModifierSystem _modifierSystem = default!;
[Dependency] private readonly SharedJointSystem _joints = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly SharedTransformSystem _xformSys = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
public override void Initialize()
{
base.Initialize();
UpdatesAfter.Add(typeof(SharedPhysicsSystem));
UpdatesOutsidePrediction = true;
SubscribeLocalEvent<PullableComponent, MoveInputEvent>(OnPullableMoveInput);
SubscribeLocalEvent<PullableComponent, CollisionChangeEvent>(OnPullableCollisionChange);
SubscribeLocalEvent<PullableComponent, JointRemovedEvent>(OnJointRemoved);
SubscribeLocalEvent<PullableComponent, GetVerbsEvent<Verb>>(AddPullVerbs);
SubscribeLocalEvent<PullableComponent, EntGotInsertedIntoContainerMessage>(OnPullableContainerInsert);
SubscribeLocalEvent<PullerComponent, EntGotInsertedIntoContainerMessage>(OnPullerContainerInsert);
SubscribeLocalEvent<PullerComponent, EntityUnpausedEvent>(OnPullerUnpaused);
SubscribeLocalEvent<PullerComponent, VirtualItemDeletedEvent>(OnVirtualItemDeleted);
SubscribeLocalEvent<PullerComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovespeed);
CommandBinds.Builder
.Bind(ContentKeyFunctions.MovePulledObject, new PointerInputCmdHandler(OnRequestMovePulledObject))
.Bind(ContentKeyFunctions.ReleasePulledObject, InputCmdHandler.FromDelegate(OnReleasePulledObject, handle: false))
.Register<PullingSystem>();
}
private void OnPullerContainerInsert(Entity<PullerComponent> ent, ref EntGotInsertedIntoContainerMessage args)
{
if (ent.Comp.Pulling == null) return;
if (!TryComp(ent.Comp.Pulling.Value, out PullableComponent? pulling))
return;
TryStopPull(ent.Comp.Pulling.Value, pulling, ent.Owner);
}
private void OnPullableContainerInsert(Entity<PullableComponent> ent, ref EntGotInsertedIntoContainerMessage args)
{
TryStopPull(ent.Owner, ent.Comp);
}
public override void Shutdown()
{
base.Shutdown();
CommandBinds.Unregister<PullingSystem>();
}
private void OnPullerUnpaused(EntityUid uid, PullerComponent component, ref EntityUnpausedEvent args)
{
component.NextThrow += args.PausedTime;
}
private void OnVirtualItemDeleted(EntityUid uid, PullerComponent component, VirtualItemDeletedEvent args)
{
// If client deletes the virtual hand then stop the pull.
if (component.Pulling == null)
return;
if (component.Pulling != args.BlockingEntity)
return;
if (EntityManager.TryGetComponent(args.BlockingEntity, out PullableComponent? comp))
{
TryStopPull(args.BlockingEntity, comp, uid);
}
}
private void AddPullVerbs(EntityUid uid, PullableComponent component, GetVerbsEvent<Verb> args)
{
if (!args.CanAccess || !args.CanInteract)
return;
// Are they trying to pull themselves up by their bootstraps?
if (args.User == args.Target)
return;
//TODO VERB ICONS add pulling icon
if (component.Puller == args.User)
{
Verb verb = new()
{
Text = Loc.GetString("pulling-verb-get-data-text-stop-pulling"),
Act = () => TryStopPull(uid, component, user: args.User),
DoContactInteraction = false // pulling handle its own contact interaction.
};
args.Verbs.Add(verb);
}
else if (CanPull(args.User, args.Target))
{
Verb verb = new()
{
Text = Loc.GetString("pulling-verb-get-data-text"),
Act = () => TryStartPull(args.User, args.Target),
DoContactInteraction = false // pulling handle its own contact interaction.
};
args.Verbs.Add(verb);
}
}
private void OnRefreshMovespeed(EntityUid uid, PullerComponent component, RefreshMovementSpeedModifiersEvent args)
{
args.ModifySpeed(component.WalkSpeedModifier, component.SprintSpeedModifier);
}
private void OnPullableMoveInput(EntityUid uid, PullableComponent component, ref MoveInputEvent args)
{
// If someone moves then break their pulling.
if (!component.BeingPulled)
return;
var entity = args.Entity;
if (!_blocker.CanMove(entity))
return;
TryStopPull(uid, component, user: uid);
}
private void OnPullableCollisionChange(EntityUid uid, PullableComponent component, ref CollisionChangeEvent args)
{
// IDK what this is supposed to be.
if (!_timing.ApplyingState && component.PullJointId != null && !args.CanCollide)
{
_joints.RemoveJoint(uid, component.PullJointId);
}
}
private void OnJointRemoved(EntityUid uid, PullableComponent component, JointRemovedEvent args)
{
// Just handles the joint getting nuked without going through pulling system (valid behavior).
// Not relevant / pullable state handle it.
if (component.Puller != args.OtherEntity ||
args.Joint.ID != component.PullJointId ||
_timing.ApplyingState)
{
return;
}
if (args.Joint.ID != component.PullJointId || component.Puller == null)
return;
StopPulling(uid, component);
}
/// <summary>
/// Forces pulling to stop and handles cleanup.
/// </summary>
private void StopPulling(EntityUid pullableUid, PullableComponent pullableComp)
{
if (!_timing.ApplyingState)
{
if (TryComp<PhysicsComponent>(pullableUid, out var pullablePhysics))
{
_physics.SetFixedRotation(pullableUid, pullableComp.PrevFixedRotation, body: pullablePhysics);
}
}
// No more joints with puller -> force stop pull.
if (TryComp<PullerComponent>(pullableComp.Puller, out var pullerComp))
{
var pullerUid = pullableComp.Puller.Value;
_alertsSystem.ClearAlert(pullerUid, AlertType.Pulling);
pullerComp.Pulling = null;
Dirty(pullableComp.Puller.Value, pullerComp);
// Messaging
var message = new PullStoppedMessage(pullerUid, pullableUid);
_modifierSystem.RefreshMovementSpeedModifiers(pullerUid);
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(pullerUid):user} stopped pulling {ToPrettyString(pullableUid):target}");
RaiseLocalEvent(pullerUid, message);
RaiseLocalEvent(pullableUid, message);
}
pullableComp.PullJointId = null;
pullableComp.Puller = null;
Dirty(pullableUid, pullableComp);
_alertsSystem.ClearAlert(pullableUid, AlertType.Pulled);
}
public bool IsPulled(EntityUid uid, PullableComponent? component = null)
{
return Resolve(uid, ref component, false) && component.BeingPulled;
}
private bool OnRequestMovePulledObject(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
if (session?.AttachedEntity is not { } player ||
!player.IsValid())
{
return false;
}
if (!TryComp<PullerComponent>(player, out var pullerComp))
return false;
var pulled = pullerComp.Pulling;
if (!HasComp<PullableComponent>(pulled))
return false;
if (_containerSystem.IsEntityInContainer(player))
return false;
// Cooldown buddy
if (_timing.CurTime < pullerComp.NextThrow)
return false;
pullerComp.NextThrow = _timing.CurTime + pullerComp.ThrowCooldown;
// Cap the distance
const float range = 2f;
var fromUserCoords = coords.WithEntityId(player, EntityManager);
var userCoords = new EntityCoordinates(player, Vector2.Zero);
if (!userCoords.InRange(EntityManager, _xformSys, fromUserCoords, range))
{
var userDirection = fromUserCoords.Position - userCoords.Position;
fromUserCoords = userCoords.Offset(userDirection.Normalized() * range);
}
Dirty(player, pullerComp);
_throwing.TryThrow(pulled.Value, fromUserCoords, user: player, strength: 4f, animated: false, recoil: false, playSound: false);
return false;
}
public bool IsPulling(EntityUid puller, PullerComponent? component = null)
{
return Resolve(puller, ref component, false) && component.Pulling != null;
}
private void OnReleasePulledObject(ICommonSession? session)
{
if (session?.AttachedEntity is not {Valid: true} player)
{
return;
}
if (!TryComp(player, out PullerComponent? pullerComp) ||
!TryComp(pullerComp.Pulling, out PullableComponent? pullableComp))
{
return;
}
TryStopPull(pullerComp.Pulling.Value, pullableComp, user: player);
}
public bool CanPull(EntityUid puller, EntityUid pullableUid, PullerComponent? pullerComp = null)
{
if (!Resolve(puller, ref pullerComp, false))
{
return false;
}
if (pullerComp.NeedsHands && !_handsSystem.TryGetEmptyHand(puller, out _))
{
return false;
}
if (!_blocker.CanInteract(puller, pullableUid))
{
return false;
}
if (!EntityManager.TryGetComponent<PhysicsComponent>(pullableUid, out var physics))
{
return false;
}
if (physics.BodyType == BodyType.Static)
{
return false;
}
if (puller == pullableUid)
{
return false;
}
if (!_containerSystem.IsInSameOrNoContainer(puller, pullableUid))
{
return false;
}
if (EntityManager.TryGetComponent(puller, out BuckleComponent? buckle))
{
// Prevent people pulling the chair they're on, etc.
if (buckle is { PullStrap: false, Buckled: true } && (buckle.LastEntityBuckledTo == pullableUid))
{
return false;
}
}
var getPulled = new BeingPulledAttemptEvent(puller, pullableUid);
RaiseLocalEvent(pullableUid, getPulled, true);
var startPull = new StartPullAttemptEvent(puller, pullableUid);
RaiseLocalEvent(puller, startPull, true);
return !startPull.Cancelled && !getPulled.Cancelled;
}
public bool TogglePull(EntityUid pullableUid, EntityUid pullerUid, PullableComponent pullable)
{
if (pullable.Puller == pullerUid)
{
return TryStopPull(pullableUid, pullable);
}
return TryStartPull(pullerUid, pullableUid, pullableComp: pullable);
}
public bool TogglePull(EntityUid pullerUid, PullerComponent puller)
{
if (!TryComp<PullableComponent>(puller.Pulling, out var pullable))
return false;
return TogglePull(puller.Pulling.Value, pullerUid, pullable);
}
public bool TryStartPull(EntityUid pullerUid, EntityUid pullableUid, EntityUid? user = null,
PullerComponent? pullerComp = null, PullableComponent? pullableComp = null)
{
if (!Resolve(pullerUid, ref pullerComp, false) ||
!Resolve(pullableUid, ref pullableComp, false))
{
return false;
}
if (pullerComp.Pulling == pullableUid)
return true;
if (!CanPull(pullerUid, pullableUid))
return false;
if (!EntityManager.TryGetComponent<PhysicsComponent>(pullerUid, out var pullerPhysics) ||
!EntityManager.TryGetComponent<PhysicsComponent>(pullableUid, out var pullablePhysics))
{
return false;
}
// Ensure that the puller is not currently pulling anything.
var oldPullable = pullerComp.Pulling;
if (oldPullable != null)
{
// Well couldn't stop the old one.
if (!TryStopPull(oldPullable.Value, pullableComp, user))
return false;
}
// Is the pullable currently being pulled by something else?
if (pullableComp.Puller != null)
{
// Uhhh
if (pullableComp.Puller == pullerUid)
return false;
if (!TryStopPull(pullableUid, pullableComp, pullerUid))
return false;
}
var pullAttempt = new PullAttemptEvent(pullerUid, pullableUid);
RaiseLocalEvent(pullerUid, pullAttempt);
if (pullAttempt.Cancelled)
return false;
RaiseLocalEvent(pullableUid, pullAttempt);
if (pullAttempt.Cancelled)
return false;
// Pulling confirmed
_interaction.DoContactInteraction(pullableUid, pullerUid);
// Use net entity so it's consistent across client and server.
pullableComp.PullJointId = $"pull-joint-{GetNetEntity(pullableUid)}";
pullerComp.Pulling = pullableUid;
pullableComp.Puller = pullerUid;
// joint state handling will manage its own state
if (!_timing.ApplyingState)
{
// Joint startup
var union = _physics.GetHardAABB(pullerUid).Union(_physics.GetHardAABB(pullableUid, body: pullablePhysics));
var length = Math.Max((float) union.Size.X, (float) union.Size.Y) * 0.75f;
var joint = _joints.CreateDistanceJoint(pullableUid, pullerUid, id: pullableComp.PullJointId);
joint.CollideConnected = false;
// This maximum has to be there because if the object is constrained too closely, the clamping goes backwards and asserts.
joint.MaxLength = Math.Max(1.0f, length);
joint.Length = length * 0.75f;
joint.MinLength = 0f;
joint.Stiffness = 1f;
_physics.SetFixedRotation(pullableUid, pullableComp.FixedRotationOnPull, body: pullablePhysics);
}
pullableComp.PrevFixedRotation = pullablePhysics.FixedRotation;
// Messaging
var message = new PullStartedMessage(pullerUid, pullableUid);
_alertsSystem.ShowAlert(pullerUid, AlertType.Pulling);
_alertsSystem.ShowAlert(pullableUid, AlertType.Pulled);
RaiseLocalEvent(pullerUid, message);
RaiseLocalEvent(pullableUid, message);
Dirty(pullerUid, pullerComp);
Dirty(pullableUid, pullableComp);
_adminLogger.Add(LogType.Action, LogImpact.Low,
$"{ToPrettyString(pullerUid):user} started pulling {ToPrettyString(pullableUid):target}");
return true;
}
public bool TryStopPull(EntityUid pullableUid, PullableComponent pullable, EntityUid? user = null)
{
var pullerUidNull = pullable.Puller;
if (pullerUidNull == null)
return false;
var msg = new AttemptStopPullingEvent(user);
RaiseLocalEvent(pullableUid, msg, true);
if (msg.Cancelled)
return false;
// Stop pulling confirmed!
if (!_timing.ApplyingState)
{
// Joint shutdown
if (pullable.PullJointId != null)
{
_joints.RemoveJoint(pullableUid, pullable.PullJointId);
pullable.PullJointId = null;
}
}
StopPulling(pullableUid, pullable);
return true;
}
}

8
Content.Shared/Movement/Systems/SharedMoverController.cs
View File

@@ -9,7 +9,6 @@ using Content.Shared.Maps;
using Content.Shared.Mobs.Systems;
using Content.Shared.Movement.Components;
using Content.Shared.Movement.Events;
using Content.Shared.Pulling.Components;
using Content.Shared.Tag;
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
@@ -23,6 +22,7 @@ using Robust.Shared.Physics.Controllers;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using PullableComponent = Content.Shared.Movement.Pulling.Components.PullableComponent;
namespace Content.Shared.Movement.Systems
{
@@ -53,7 +53,7 @@ namespace Content.Shared.Movement.Systems
protected EntityQuery<MovementSpeedModifierComponent> ModifierQuery;
protected EntityQuery<PhysicsComponent> PhysicsQuery;
protected EntityQuery<RelayInputMoverComponent> RelayQuery;
protected EntityQuery<SharedPullableComponent> PullableQuery;
protected EntityQuery<PullableComponent> PullableQuery;
protected EntityQuery<TransformComponent> XformQuery;
protected EntityQuery<CanMoveInAirComponent> CanMoveInAirQuery;
protected EntityQuery<NoRotateOnMoveComponent> NoRotateQuery;
@@ -85,7 +85,7 @@ namespace Content.Shared.Movement.Systems
RelayTargetQuery = GetEntityQuery<MovementRelayTargetComponent>();
PhysicsQuery = GetEntityQuery<PhysicsComponent>();
RelayQuery = GetEntityQuery<RelayInputMoverComponent>();
PullableQuery = GetEntityQuery<SharedPullableComponent>();
PullableQuery = GetEntityQuery<PullableComponent>();
XformQuery = GetEntityQuery<TransformComponent>();
NoRotateQuery = GetEntityQuery<NoRotateOnMoveComponent>();
CanMoveInAirQuery = GetEntityQuery<CanMoveInAirComponent>();
@@ -376,7 +376,7 @@ namespace Content.Shared.Movement.Systems
!otherCollider.CanCollide ||
((collider.CollisionMask & otherCollider.CollisionLayer) == 0 &&
(otherCollider.CollisionMask & collider.CollisionLayer) == 0) ||
(TryComp(otherCollider.Owner, out SharedPullableComponent? pullable) && pullable.BeingPulled))
(TryComp(otherCollider.Owner, out PullableComponent? pullable) && pullable.BeingPulled))
{
continue;
}

57
Content.Shared/Pulling/Components/PullableComponent.cs
View File

@@ -1,57 +0,0 @@
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
namespace Content.Shared.Pulling.Components
{
// Before you try to add another type than SharedPullingStateManagementSystem, consider the can of worms you may be opening!
[NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(SharedPullingStateManagementSystem))]
[RegisterComponent]
public sealed partial class SharedPullableComponent : Component
{
/// <summary>
/// The current entity pulling this component.
/// </summary>
[DataField, AutoNetworkedField]
public EntityUid? Puller { get; set; }
/// <summary>
/// The pull joint.
/// </summary>
[DataField, AutoNetworkedField]
public string? PullJointId { get; set; }
public bool BeingPulled => Puller != null;
[Access(typeof(SharedPullingStateManagementSystem), Other = AccessPermissions.ReadExecute)] // FIXME Friends
public EntityCoordinates? MovingTo { get; set; }
/// <summary>
/// If the physics component has FixedRotation should we keep it upon being pulled
/// </summary>
[Access(typeof(SharedPullingSystem), Other = AccessPermissions.ReadExecute)]
[ViewVariables(VVAccess.ReadWrite), DataField("fixedRotation")]
public bool FixedRotationOnPull { get; set; }
/// <summary>
/// What the pullable's fixedrotation was set to before being pulled.
/// </summary>
[Access(typeof(SharedPullingSystem), Other = AccessPermissions.ReadExecute)]
[ViewVariables]
public bool PrevFixedRotation;
}
/// <summary>
/// Raised when a request is made to stop pulling an entity.
/// </summary>
public sealed class StopPullingEvent : CancellableEntityEventArgs
{
public EntityUid? User { get; }
public StopPullingEvent(EntityUid? uid = null)
{
User = uid;
}
}
}

23
Content.Shared/Pulling/Components/SharedPullerComponent.cs
View File

@@ -1,23 +0,0 @@
using Robust.Shared.GameStates;
namespace Content.Shared.Pulling.Components
{
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(SharedPullingStateManagementSystem))]
public sealed partial class SharedPullerComponent : Component
{
// Before changing how this is updated, please see SharedPullerSystem.RefreshMovementSpeed
public float WalkSpeedModifier => Pulling == default ? 1.0f : 0.95f;
public float SprintSpeedModifier => Pulling == default ? 1.0f : 0.95f;
[DataField, AutoNetworkedField]
public EntityUid? Pulling { get; set; }
/// <summary>
/// Does this entity need hands to be able to pull something?
/// </summary>
[DataField("needsHands")]
public bool NeedsHands = true;
}
}

11
Content.Shared/Pulling/Events/PullAttemptEvent.cs
View File

@@ -1,11 +0,0 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Physics.Pull
{
public sealed class PullAttemptEvent : PullMessage
{
public PullAttemptEvent(PhysicsComponent puller, PhysicsComponent pulled) : base(puller, pulled) { }
public bool Cancelled { get; set; }
}
}

16
Content.Shared/Pulling/Events/PullMessage.cs
View File

@@ -1,16 +0,0 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Physics.Pull
{
public abstract class PullMessage : EntityEventArgs
{
public readonly PhysicsComponent Puller;
public readonly PhysicsComponent Pulled;
protected PullMessage(PhysicsComponent puller, PhysicsComponent pulled)
{
Puller = puller;
Pulled = pulled;
}
}
}

12
Content.Shared/Pulling/Events/PullStartedMessage.cs
View File

@@ -1,12 +0,0 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Physics.Pull
{
public sealed class PullStartedMessage : PullMessage
{
public PullStartedMessage(PhysicsComponent puller, PhysicsComponent pulled) :
base(puller, pulled)
{
}
}
}

11
Content.Shared/Pulling/Events/PullStoppedMessage.cs
View File

@@ -1,11 +0,0 @@
using Robust.Shared.Physics.Components;
namespace Content.Shared.Physics.Pull
{
public sealed class PullStoppedMessage : PullMessage
{
public PullStoppedMessage(PhysicsComponent puller, PhysicsComponent pulled) : base(puller, pulled)
{
}
}
}

6
Content.Shared/Pulling/PullableMoveMessage.cs
View File

@@ -1,6 +0,0 @@
namespace Content.Shared.Pulling
{
public sealed class PullableMoveMessage : EntityEventArgs
{
}
}

6
Content.Shared/Pulling/PullableStopMovingMessage.cs
View File

@@ -1,6 +0,0 @@
namespace Content.Shared.Pulling
{
public sealed class PullableStopMovingMessage : EntityEventArgs
{
}
}

28
Content.Shared/Pulling/Systems/SharedPullableSystem.cs
View File

@@ -1,28 +0,0 @@
using Content.Shared.ActionBlocker;
using Content.Shared.Mobs.Systems;
using Content.Shared.Pulling.Components;
using Content.Shared.Movement.Events;
namespace Content.Shared.Pulling.Systems
{
public sealed class SharedPullableSystem : EntitySystem
{
[Dependency] private readonly ActionBlockerSystem _blocker = default!;
[Dependency] private readonly MobStateSystem _mobState = default!;
[Dependency] private readonly SharedPullingSystem _pullSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<SharedPullableComponent, MoveInputEvent>(OnRelayMoveInput);
}
private void OnRelayMoveInput(EntityUid uid, SharedPullableComponent component, ref MoveInputEvent args)
{
var entity = args.Entity;
if (_mobState.IsIncapacitated(entity) || !_blocker.CanMove(entity)) return;
_pullSystem.TryStopPull(component);
}
}
}

90
Content.Shared/Pulling/Systems/SharedPullerSystem.cs
View File

@@ -1,90 +0,0 @@
using Content.Shared.Administration.Logs;
using Content.Shared.Alert;
using Content.Shared.Database;
using Content.Shared.Hands;
using Content.Shared.Movement.Systems;
using Content.Shared.Physics.Pull;
using Content.Shared.Pulling.Components;
using JetBrains.Annotations;
namespace Content.Shared.Pulling.Systems
{
[UsedImplicitly]
public sealed class SharedPullerSystem : EntitySystem
{
[Dependency] private readonly SharedPullingStateManagementSystem _why = default!;
[Dependency] private readonly SharedPullingSystem _pullSystem = default!;
[Dependency] private readonly MovementSpeedModifierSystem _movementSpeedModifierSystem = default!;
[Dependency] private readonly AlertsSystem _alertsSystem = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<SharedPullerComponent, PullStartedMessage>(PullerHandlePullStarted);
SubscribeLocalEvent<SharedPullerComponent, PullStoppedMessage>(PullerHandlePullStopped);
SubscribeLocalEvent<SharedPullerComponent, VirtualItemDeletedEvent>(OnVirtualItemDeleted);
SubscribeLocalEvent<SharedPullerComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovespeed);
SubscribeLocalEvent<SharedPullerComponent, ComponentShutdown>(OnPullerShutdown);
}
private void OnPullerShutdown(EntityUid uid, SharedPullerComponent component, ComponentShutdown args)
{
_why.ForceDisconnectPuller(component);
}
private void OnVirtualItemDeleted(EntityUid uid, SharedPullerComponent component, VirtualItemDeletedEvent args)
{
if (component.Pulling == null)
return;
if (component.Pulling == args.BlockingEntity)
{
if (EntityManager.TryGetComponent<SharedPullableComponent>(args.BlockingEntity, out var comp))
{
_pullSystem.TryStopPull(comp, uid);
}
}
}
private void PullerHandlePullStarted(
EntityUid uid,
SharedPullerComponent component,
PullStartedMessage args)
{
if (args.Puller.Owner != uid)
return;
_alertsSystem.ShowAlert(component.Owner, AlertType.Pulling);
RefreshMovementSpeed(component);
}
private void PullerHandlePullStopped(
EntityUid uid,
SharedPullerComponent component,
PullStoppedMessage args)
{
if (args.Puller.Owner != uid)
return;
var euid = component.Owner;
if (_alertsSystem.IsShowingAlert(euid, AlertType.Pulling))
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(euid):user} stopped pulling {ToPrettyString(args.Pulled.Owner):target}");
_alertsSystem.ClearAlert(euid, AlertType.Pulling);
RefreshMovementSpeed(component);
}
private void OnRefreshMovespeed(EntityUid uid, SharedPullerComponent component, RefreshMovementSpeedModifiersEvent args)
{
args.ModifySpeed(component.WalkSpeedModifier, component.SprintSpeedModifier);
}
private void RefreshMovementSpeed(SharedPullerComponent component)
{
_movementSpeedModifierSystem.RefreshMovementSpeedModifiers(component.Owner);
}
}
}

196
Content.Shared/Pulling/Systems/SharedPullingStateManagementSystem.cs
View File

@@ -1,196 +0,0 @@
using Content.Shared.Physics.Pull;
using Content.Shared.Pulling.Components;
using JetBrains.Annotations;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Timing;
namespace Content.Shared.Pulling
{
/// <summary>
/// This is the core of pulling state management.
/// Because pulling state is such a mess to get right, all writes to pulling state must go through this class.
/// </summary>
[UsedImplicitly]
public sealed class SharedPullingStateManagementSystem : EntitySystem
{
[Dependency] private readonly SharedJointSystem _jointSystem = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly IGameTiming _timing = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<SharedPullableComponent, ComponentShutdown>(OnShutdown);
}
private void OnShutdown(EntityUid uid, SharedPullableComponent component, ComponentShutdown args)
{
if (component.Puller != null)
ForceRelationship(null, component);
}
// A WARNING:
// The following 2 functions are the most internal part of the pulling system's relationship management.
// They do not expect to be cancellable.
private void ForceDisconnect(SharedPullerComponent puller, SharedPullableComponent pullable)
{
var pullerPhysics = EntityManager.GetComponent<PhysicsComponent>(puller.Owner);
var pullablePhysics = EntityManager.GetComponent<PhysicsComponent>(pullable.Owner);
// MovingTo shutdown
ForceSetMovingTo(pullable, null);
// Joint shutdown
if (!_timing.ApplyingState && // During state-handling, joint component will handle its own state.
pullable.PullJointId != null &&
TryComp(puller.Owner, out JointComponent? jointComp))
{
if (jointComp.GetJoints.TryGetValue(pullable.PullJointId, out var j))
_jointSystem.RemoveJoint(j);
}
pullable.PullJointId = null;
// State shutdown
puller.Pulling = null;
pullable.Puller = null;
// Messaging
var message = new PullStoppedMessage(pullerPhysics, pullablePhysics);
RaiseLocalEvent(puller.Owner, message, broadcast: false);
if (Initialized(pullable.Owner))
RaiseLocalEvent(pullable.Owner, message, true);
// Networking
Dirty(puller);
Dirty(pullable);
}
public void ForceRelationship(SharedPullerComponent? puller, SharedPullableComponent? pullable)
{
if (_timing.ApplyingState)
return;
;
if (pullable != null && puller != null && (puller.Pulling == pullable.Owner))
{
// Already done
return;
}
// Start by disconnecting the pullable from whatever it is currently connected to.
var pullableOldPullerE = pullable?.Puller;
if (pullableOldPullerE != null)
{
ForceDisconnect(EntityManager.GetComponent<SharedPullerComponent>(pullableOldPullerE.Value), pullable!);
}
// Continue with the puller.
var pullerOldPullableE = puller?.Pulling;
if (pullerOldPullableE != null)
{
ForceDisconnect(puller!, EntityManager.GetComponent<SharedPullableComponent>(pullerOldPullableE.Value));
}
// And now for the actual connection (if any).
if (puller != null && pullable != null)
{
var pullerPhysics = EntityManager.GetComponent<PhysicsComponent>(puller.Owner);
var pullablePhysics = EntityManager.GetComponent<PhysicsComponent>(pullable.Owner);
pullable.PullJointId = $"pull-joint-{pullable.Owner}";
// State startup
puller.Pulling = pullable.Owner;
pullable.Puller = puller.Owner;
// joint state handling will manage its own state
if (!_timing.ApplyingState)
{
// Joint startup
var union = _physics.GetHardAABB(puller.Owner).Union(_physics.GetHardAABB(pullable.Owner, body: pullablePhysics));
var length = Math.Max(union.Size.X, union.Size.Y) * 0.75f;
var joint = _jointSystem.CreateDistanceJoint(pullablePhysics.Owner, pullerPhysics.Owner, id: pullable.PullJointId);
joint.CollideConnected = false;
// This maximum has to be there because if the object is constrained too closely, the clamping goes backwards and asserts.
joint.MaxLength = Math.Max(1.0f, length);
joint.Length = length * 0.75f;
joint.MinLength = 0f;
joint.Stiffness = 1f;
}
// Messaging
var message = new PullStartedMessage(pullerPhysics, pullablePhysics);
RaiseLocalEvent(puller.Owner, message, broadcast: false);
RaiseLocalEvent(pullable.Owner, message, true);
// Networking
Dirty(puller);
Dirty(pullable);
}
}
// For OnRemove use only.
public void ForceDisconnectPuller(SharedPullerComponent puller)
{
// DO NOT ADD ADDITIONAL LOGIC IN THIS FUNCTION. Do it in ForceRelationship.
ForceRelationship(puller, null);
}
// For OnRemove use only.
public void ForceDisconnectPullable(SharedPullableComponent pullable)
{
// DO NOT ADD ADDITIONAL LOGIC IN THIS FUNCTION. Do it in ForceRelationship.
ForceRelationship(null, pullable);
}
public void ForceSetMovingTo(SharedPullableComponent pullable, EntityCoordinates? movingTo)
{
if (_timing.ApplyingState)
return;
if (pullable.MovingTo == movingTo)
{
return;
}
// Don't allow setting a MovingTo if there's no puller.
// The other half of this guarantee (shutting down a MovingTo if the puller goes away) is enforced in ForceRelationship.
if (pullable.Puller == null && movingTo != null)
{
return;
}
pullable.MovingTo = movingTo;
Dirty(pullable);
if (movingTo == null)
{
RaiseLocalEvent(pullable.Owner, new PullableStopMovingMessage(), true);
}
else
{
RaiseLocalEvent(pullable.Owner, new PullableMoveMessage(), true);
}
}
/// <summary>
/// Changes if the entity needs a hand in order to be able to pull objects.
/// </summary>
public void ChangeHandRequirement(EntityUid uid, bool needsHands, SharedPullerComponent? comp)
{
if (!Resolve(uid, ref comp, false))
return;
comp.NeedsHands = needsHands;
Dirty(uid, comp);
}
}
}

239
Content.Shared/Pulling/Systems/SharedPullingSystem.Actions.cs
View File

@@ -1,239 +0,0 @@
using Content.Shared.ActionBlocker;
using Content.Shared.Administration.Logs;
using Content.Shared.Buckle.Components;
using Content.Shared.Database;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Physics.Pull;
using Content.Shared.Pulling.Components;
using Content.Shared.Pulling.Events;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Shared.Pulling
{
public abstract partial class SharedPullingSystem
{
[Dependency] private readonly ActionBlockerSystem _blocker = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly IGameTiming _timing = default!;
public bool CanPull(EntityUid puller, EntityUid pulled)
{
if (!EntityManager.TryGetComponent<SharedPullerComponent>(puller, out var comp))
{
return false;
}
if (comp.NeedsHands && !_handsSystem.TryGetEmptyHand(puller, out _))
{
return false;
}
if (!_blocker.CanInteract(puller, pulled))
{
return false;
}
if (!EntityManager.TryGetComponent<PhysicsComponent>(pulled, out var physics))
{
return false;
}
if (physics.BodyType == BodyType.Static)
{
return false;
}
if (puller == pulled)
{
return false;
}
if(_containerSystem.IsEntityInContainer(puller) || _containerSystem.IsEntityInContainer(pulled))
{
return false;
}
if (EntityManager.TryGetComponent(puller, out BuckleComponent? buckle))
{
// Prevent people pulling the chair they're on, etc.
if (buckle is { PullStrap: false, Buckled: true } && (buckle.LastEntityBuckledTo == pulled))
{
return false;
}
}
var getPulled = new BeingPulledAttemptEvent(puller, pulled);
RaiseLocalEvent(pulled, getPulled, true);
var startPull = new StartPullAttemptEvent(puller, pulled);
RaiseLocalEvent(puller, startPull, true);
return (!startPull.Cancelled && !getPulled.Cancelled);
}
public bool TogglePull(EntityUid puller, SharedPullableComponent pullable)
{
if (pullable.Puller == puller)
{
return TryStopPull(pullable);
}
return TryStartPull(puller, pullable.Owner);
}
// -- Core attempted actions --
public bool TryStopPull(SharedPullableComponent pullable, EntityUid? user = null)
{
if (_timing.ApplyingState)
return false;
if (!pullable.BeingPulled)
{
return false;
}
var msg = new StopPullingEvent(user);
RaiseLocalEvent(pullable.Owner, msg, true);
if (msg.Cancelled) return false;
// Stop pulling confirmed!
if (TryComp<PhysicsComponent>(pullable.Owner, out var pullablePhysics))
{
_physics.SetFixedRotation(pullable.Owner, pullable.PrevFixedRotation, body: pullablePhysics);
}
_pullSm.ForceRelationship(null, pullable);
return true;
}
public bool TryStartPull(EntityUid puller, EntityUid pullable)
{
if (!EntityManager.TryGetComponent(puller, out SharedPullerComponent? pullerComp))
{
return false;
}
if (!EntityManager.TryGetComponent(pullable, out SharedPullableComponent? pullableComp))
{
return false;
}
return TryStartPull(pullerComp, pullableComp);
}
// The main "start pulling" function.
public bool TryStartPull(SharedPullerComponent puller, SharedPullableComponent pullable)
{
if (_timing.ApplyingState)
return false;
if (puller.Pulling == pullable.Owner)
return true;
// Pulling a new object : Perform sanity checks.
if (!CanPull(puller.Owner, pullable.Owner))
{
return false;
}
if (!EntityManager.TryGetComponent<PhysicsComponent>(puller.Owner, out var pullerPhysics))
{
return false;
}
if (!EntityManager.TryGetComponent<PhysicsComponent>(pullable.Owner, out var pullablePhysics))
{
return false;
}
// Ensure that the puller is not currently pulling anything.
// If this isn't done, then it happens too late, and the start/stop messages go out of order,
// and next thing you know it thinks it's not pulling anything even though it is!
var oldPullable = puller.Pulling;
if (oldPullable != null)
{
if (EntityManager.TryGetComponent(oldPullable.Value, out SharedPullableComponent? oldPullableComp))
{
if (!TryStopPull(oldPullableComp))
{
return false;
}
}
else
{
Log.Warning("Well now you've done it, haven't you? Someone transferred pulling (onto {0}) while presently pulling something that has no Pullable component (on {1})!", pullable.Owner, oldPullable);
return false;
}
}
// Ensure that the pullable is not currently being pulled.
// Same sort of reasons as before.
var oldPuller = pullable.Puller;
if (oldPuller != null)
{
if (!TryStopPull(pullable))
{
return false;
}
}
// Continue with pulling process.
var pullAttempt = new PullAttemptEvent(pullerPhysics, pullablePhysics);
RaiseLocalEvent(puller.Owner, pullAttempt, broadcast: false);
if (pullAttempt.Cancelled)
{
return false;
}
RaiseLocalEvent(pullable.Owner, pullAttempt, true);
if (pullAttempt.Cancelled)
return false;
_interaction.DoContactInteraction(pullable.Owner, puller.Owner);
_pullSm.ForceRelationship(puller, pullable);
pullable.PrevFixedRotation = pullablePhysics.FixedRotation;
_physics.SetFixedRotation(pullable.Owner, pullable.FixedRotationOnPull, body: pullablePhysics);
_adminLogger.Add(LogType.Action, LogImpact.Low,
$"{ToPrettyString(puller.Owner):user} started pulling {ToPrettyString(pullable.Owner):target}");
return true;
}
public bool TryMoveTo(SharedPullableComponent pullable, EntityCoordinates to)
{
if (pullable.Puller == null)
{
return false;
}
if (!EntityManager.HasComponent<PhysicsComponent>(pullable.Owner))
{
return false;
}
_pullSm.ForceSetMovingTo(pullable, to);
return true;
}
public void StopMoveTo(SharedPullableComponent pullable)
{
_pullSm.ForceSetMovingTo(pullable, null);
}
}
}

243
Content.Shared/Pulling/Systems/SharedPullingSystem.cs
View File

@@ -1,243 +0,0 @@
using System.Diagnostics.CodeAnalysis;
using Content.Shared.Alert;
using Content.Shared.GameTicking;
using Content.Shared.Input;
using Content.Shared.Physics.Pull;
using Content.Shared.Pulling.Components;
using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Shared.Containers;
using Robust.Shared.Input.Binding;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
namespace Content.Shared.Pulling
{
[UsedImplicitly]
public abstract partial class SharedPullingSystem : EntitySystem
{
[Dependency] private readonly SharedPullingStateManagementSystem _pullSm = default!;
[Dependency] private readonly AlertsSystem _alertsSystem = default!;
[Dependency] private readonly SharedJointSystem _joints = default!;
/// <summary>
/// A mapping of pullers to the entity that they are pulling.
/// </summary>
private readonly Dictionary<EntityUid, EntityUid> _pullers =
new();
private readonly HashSet<SharedPullableComponent> _moving = new();
private readonly HashSet<SharedPullableComponent> _stoppedMoving = new();
public IReadOnlySet<SharedPullableComponent> Moving => _moving;
public override void Initialize()
{
base.Initialize();
UpdatesOutsidePrediction = true;
SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
SubscribeLocalEvent<PullStartedMessage>(OnPullStarted);
SubscribeLocalEvent<PullStoppedMessage>(OnPullStopped);
SubscribeLocalEvent<EntInsertedIntoContainerMessage>(HandleContainerInsert);
SubscribeLocalEvent<SharedPullableComponent, JointRemovedEvent>(OnJointRemoved);
SubscribeLocalEvent<SharedPullableComponent, CollisionChangeEvent>(OnPullableCollisionChange);
SubscribeLocalEvent<SharedPullableComponent, PullStartedMessage>(PullableHandlePullStarted);
SubscribeLocalEvent<SharedPullableComponent, PullStoppedMessage>(PullableHandlePullStopped);
SubscribeLocalEvent<SharedPullableComponent, GetVerbsEvent<Verb>>(AddPullVerbs);
CommandBinds.Builder
.Bind(ContentKeyFunctions.MovePulledObject, new PointerInputCmdHandler(HandleMovePulledObject))
.Register<SharedPullingSystem>();
}
private void OnPullableCollisionChange(EntityUid uid, SharedPullableComponent component, ref CollisionChangeEvent args)
{
if (component.PullJointId != null && !args.CanCollide)
{
_joints.RemoveJoint(uid, component.PullJointId);
}
}
private void OnJointRemoved(EntityUid uid, SharedPullableComponent component, JointRemovedEvent args)
{
if (component.Puller != args.OtherEntity)
return;
// Do we have some other join with our Puller?
// or alternatively:
// TODO track the relevant joint.
if (TryComp(uid, out JointComponent? joints))
{
foreach (var jt in joints.GetJoints.Values)
{
if (jt.BodyAUid == component.Puller || jt.BodyBUid == component.Puller)
return;
}
}
// No more joints with puller -> force stop pull.
_pullSm.ForceDisconnectPullable(component);
}
private void AddPullVerbs(EntityUid uid, SharedPullableComponent component, GetVerbsEvent<Verb> args)
{
if (!args.CanAccess || !args.CanInteract)
return;
// Are they trying to pull themselves up by their bootstraps?
if (args.User == args.Target)
return;
//TODO VERB ICONS add pulling icon
if (component.Puller == args.User)
{
Verb verb = new()
{
Text = Loc.GetString("pulling-verb-get-data-text-stop-pulling"),
Act = () => TryStopPull(component, args.User),
DoContactInteraction = false // pulling handle its own contact interaction.
};
args.Verbs.Add(verb);
}
else if (CanPull(args.User, args.Target))
{
Verb verb = new()
{
Text = Loc.GetString("pulling-verb-get-data-text"),
Act = () => TryStartPull(args.User, args.Target),
DoContactInteraction = false // pulling handle its own contact interaction.
};
args.Verbs.Add(verb);
}
}
// Raise a "you are being pulled" alert if the pulled entity has alerts.
private void PullableHandlePullStarted(EntityUid uid, SharedPullableComponent component, PullStartedMessage args)
{
if (args.Pulled.Owner != uid)
return;
_alertsSystem.ShowAlert(uid, AlertType.Pulled);
}
private void PullableHandlePullStopped(EntityUid uid, SharedPullableComponent component, PullStoppedMessage args)
{
if (args.Pulled.Owner != uid)
return;
_alertsSystem.ClearAlert(uid, AlertType.Pulled);
}
public bool IsPulled(EntityUid uid, SharedPullableComponent? component = null)
{
return Resolve(uid, ref component, false) && component.BeingPulled;
}
public override void Update(float frameTime)
{
base.Update(frameTime);
_moving.ExceptWith(_stoppedMoving);
_stoppedMoving.Clear();
}
public void Reset(RoundRestartCleanupEvent ev)
{
_pullers.Clear();
_moving.Clear();
_stoppedMoving.Clear();
}
private void OnPullStarted(PullStartedMessage message)
{
SetPuller(message.Puller.Owner, message.Pulled.Owner);
}
private void OnPullStopped(PullStoppedMessage message)
{
RemovePuller(message.Puller.Owner);
}
protected void OnPullableMove(EntityUid uid, SharedPullableComponent component, PullableMoveMessage args)
{
_moving.Add(component);
}
protected void OnPullableStopMove(EntityUid uid, SharedPullableComponent component, PullableStopMovingMessage args)
{
_stoppedMoving.Add(component);
}
// TODO: When Joint networking is less shitcodey fix this to use a dedicated joints message.
private void HandleContainerInsert(EntInsertedIntoContainerMessage message)
{
if (TryComp(message.Entity, out SharedPullableComponent? pullable))
{
TryStopPull(pullable);
}
if (TryComp(message.Entity, out SharedPullerComponent? puller))
{
if (puller.Pulling == null) return;
if (!TryComp(puller.Pulling.Value, out SharedPullableComponent? pulling))
return;
TryStopPull(pulling);
}
}
private bool HandleMovePulledObject(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
if (session?.AttachedEntity is not { } player ||
!player.IsValid())
return false;
if (!TryGetPulled(player, out var pulled))
return false;
if (!TryComp(pulled.Value, out SharedPullableComponent? pullable))
return false;
if (_containerSystem.IsEntityInContainer(player))
return false;
TryMoveTo(pullable, coords);
return false;
}
private void SetPuller(EntityUid puller, EntityUid pulled)
{
_pullers[puller] = pulled;
}
private bool RemovePuller(EntityUid puller)
{
return _pullers.Remove(puller);
}
public EntityUid GetPulled(EntityUid by)
{
return _pullers.GetValueOrDefault(by);
}
public bool TryGetPulled(EntityUid by, [NotNullWhen(true)] out EntityUid? pulled)
{
return (pulled = GetPulled(by)) != null;
}
public bool IsPulling(EntityUid puller)
{
return _pullers.ContainsKey(puller);
}
}
}

10
Content.Shared/Security/Systems/DeployableBarrierSystem.cs
View File

@@ -1,6 +1,6 @@
using Content.Shared.Lock;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Security.Components;
using Robust.Shared.Physics.Systems;
@@ -11,7 +11,7 @@ public sealed class DeployableBarrierSystem : EntitySystem
[Dependency] private readonly FixtureSystem _fixtures = default!;
[Dependency] private readonly SharedPointLightSystem _pointLight = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
@@ -54,8 +54,8 @@ public sealed class DeployableBarrierSystem : EntitySystem
_physics.SetHard(uid, fixture, false);
}
if (TryComp(uid, out SharedPullableComponent? pullable))
_pulling.TryStopPull(pullable);
if (TryComp(uid, out PullableComponent? pullable))
_pulling.TryStopPull(uid, pullable);
SharedPointLightComponent? pointLight = null;
if (_pointLight.ResolveLight(uid, ref pointLight))

16
Content.Shared/Teleportation/Systems/SharedPortalSystem.cs
View File

@@ -1,9 +1,9 @@
using System.Linq;
using Content.Shared.Ghost;
using Content.Shared.Movement.Pulling.Components;
using Content.Shared.Movement.Pulling.Systems;
using Content.Shared.Popups;
using Content.Shared.Projectiles;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Teleportation.Components;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
@@ -28,7 +28,7 @@ public abstract class SharedPortalSystem : EntitySystem
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
private const string PortalFixture = "portalFixture";
@@ -93,15 +93,15 @@ public abstract class SharedPortalSystem : EntitySystem
return;
// break pulls before portal enter so we dont break shit
if (TryComp<SharedPullableComponent>(subject, out var pullable) && pullable.BeingPulled)
if (TryComp<PullableComponent>(subject, out var pullable) && pullable.BeingPulled)
{
_pulling.TryStopPull(pullable);
_pulling.TryStopPull(subject, pullable);
}
if (TryComp<SharedPullerComponent>(subject, out var pulling)
&& pulling.Pulling != null && TryComp<SharedPullableComponent>(pulling.Pulling.Value, out var subjectPulling))
if (TryComp<PullerComponent>(subject, out var pullerComp)
&& TryComp<PullableComponent>(pullerComp.Pulling, out var subjectPulling))
{
_pulling.TryStopPull(subjectPulling);
_pulling.TryStopPull(subject, subjectPulling);
}
// if they came from another portal, just return and wait for them to exit the portal

33
Content.Shared/Throwing/ThrowingSystem.cs
View File

@@ -20,6 +20,11 @@ public sealed class ThrowingSystem : EntitySystem
{
public const float ThrowAngularImpulse = 5f;
/// <summary>
/// Speed cap on rotation in case of click-spam.
/// </summary>
public const float ThrowAngularCap = 3f * MathF.PI;
public const float PushbackDefault = 2f;
/// <summary>
@@ -42,15 +47,17 @@ public sealed class ThrowingSystem : EntitySystem
float strength = 1.0f,
EntityUid? user = null,
float pushbackRatio = PushbackDefault,
bool recoil = true,
bool animated = true,
bool playSound = true)
{
var thrownPos = Transform(uid).MapPosition;
var mapPos = coordinates.ToMap(EntityManager, _transform);
var thrownPos = _transform.GetMapCoordinates(uid);
var mapPos = _transform.ToMapCoordinates(coordinates);
if (mapPos.MapId != thrownPos.MapId)
return;
TryThrow(uid, mapPos.Position - thrownPos.Position, strength, user, pushbackRatio, playSound);
TryThrow(uid, mapPos.Position - thrownPos.Position, strength, user, pushbackRatio, recoil: recoil, animated: animated, playSound: playSound);
}
/// <summary>
@@ -65,6 +72,8 @@ public sealed class ThrowingSystem : EntitySystem
float strength = 1.0f,
EntityUid? user = null,
float pushbackRatio = PushbackDefault,
bool recoil = true,
bool animated = true,
bool playSound = true)
{
var physicsQuery = GetEntityQuery<PhysicsComponent>();
@@ -72,7 +81,6 @@ public sealed class ThrowingSystem : EntitySystem
return;
var projectileQuery = GetEntityQuery<ProjectileComponent>();
var tagQuery = GetEntityQuery<TagComponent>();
TryThrow(
uid,
@@ -82,8 +90,7 @@ public sealed class ThrowingSystem : EntitySystem
projectileQuery,
strength,
user,
pushbackRatio,
playSound);
pushbackRatio, recoil: recoil, animated: animated, playSound: playSound);
}
/// <summary>
@@ -101,6 +108,8 @@ public sealed class ThrowingSystem : EntitySystem
float strength = 1.0f,
EntityUid? user = null,
float pushbackRatio = PushbackDefault,
bool recoil = true,
bool animated = true,
bool playSound = true)
{
if (strength <= 0 || direction == Vector2Helpers.Infinity || direction == Vector2Helpers.NaN || direction == Vector2.Zero)
@@ -116,12 +125,17 @@ public sealed class ThrowingSystem : EntitySystem
if (projectileQuery.TryGetComponent(uid, out var proj) && !proj.OnlyCollideWhenShot)
return;
var comp = new ThrownItemComponent();
comp.Thrower = user;
var comp = new ThrownItemComponent
{
Thrower = user,
Animate = animated,
};
// Estimate time to arrival so we can apply OnGround status and slow it much faster.
var time = direction.Length() / strength;
comp.ThrownTime = _gameTiming.CurTime;
// TODO: This is a bandaid, don't do this.
// if you want to force landtime have the caller handle it or add a new method.
// did we launch this with something stronger than our hands?
if (TryComp<HandsComponent>(comp.Thrower, out var hands) && strength > hands.ThrowForceMultiplier)
comp.LandTime = comp.ThrownTime + TimeSpan.FromSeconds(time);
@@ -166,7 +180,8 @@ public sealed class ThrowingSystem : EntitySystem
if (user == null)
return;
_recoil.KickCamera(user.Value, -direction * 0.04f);
if (recoil)
_recoil.KickCamera(user.Value, -direction * 0.04f);
// Give thrower an impulse in the other direction
if (pushbackRatio != 0.0f &&

6
Content.Shared/Throwing/ThrownItemComponent.cs
View File

@@ -8,6 +8,12 @@ namespace Content.Shared.Throwing
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true), AutoGenerateComponentPause]
public sealed partial class ThrownItemComponent : Component
{
/// <summary>
/// Should the in-air throwing animation play.
/// </summary>
[DataField, AutoNetworkedField]
public bool Animate = true;
/// <summary>
/// The entity that threw this entity.
/// </summary>

7
Content.Shared/Throwing/ThrownItemSystem.cs
View File

@@ -3,8 +3,7 @@ using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.Gravity;
using Content.Shared.Physics;
using Content.Shared.Physics.Pull;
using Robust.Shared.GameStates;
using Content.Shared.Movement.Pulling.Events;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
@@ -85,8 +84,8 @@ namespace Content.Shared.Throwing
private void HandlePullStarted(PullStartedMessage message)
{
// TODO: this isn't directed so things have to be done the bad way
if (EntityManager.TryGetComponent(message.Pulled.Owner, out ThrownItemComponent? thrownItemComponent))
StopThrow(message.Pulled.Owner, thrownItemComponent);
if (EntityManager.TryGetComponent(message.PulledUid, out ThrownItemComponent? thrownItemComponent))
StopThrow(message.PulledUid, thrownItemComponent);
}
public void StopThrow(EntityUid uid, ThrownItemComponent thrownItemComponent)