423 lines
16 KiB
C#
423 lines
16 KiB
C#
using Content.Shared.ActionBlocker;
|
|
using Content.Shared.Buckle.Components;
|
|
using Content.Shared.Climbing.Events;
|
|
using Content.Shared.DoAfter;
|
|
using Content.Shared.Hands;
|
|
using Content.Shared.Hands.Components;
|
|
using Content.Shared.Interaction.Events;
|
|
using Content.Shared.Inventory.VirtualItem;
|
|
using Content.Shared.Item;
|
|
using Content.Shared.Mind.Components;
|
|
using Content.Shared.Mobs;
|
|
using Content.Shared.Movement.Events;
|
|
using Content.Shared.Movement.Pulling.Components;
|
|
using Content.Shared.Movement.Pulling.Events;
|
|
using Content.Shared.Movement.Pulling.Systems;
|
|
using Content.Shared.Movement.Systems;
|
|
using Content.Shared.Nyanotrasen.Item.PseudoItem;
|
|
using Content.Shared.Popups;
|
|
using Content.Shared.Pulling;
|
|
using Content.Shared.Resist;
|
|
using Content.Shared.Standing;
|
|
using Content.Shared.Storage;
|
|
using Content.Shared.Stunnable;
|
|
using Content.Shared.Throwing;
|
|
using Content.Shared.Verbs;
|
|
using Robust.Shared.Map.Components;
|
|
using Robust.Shared.Network;
|
|
using Robust.Shared.Physics.Components;
|
|
using System.Numerics;
|
|
using Content.Shared._DV.Polymorph;
|
|
using Content.Shared.Hands.EntitySystems;
|
|
|
|
namespace Content.Shared._DV.Carrying;
|
|
|
|
public sealed class CarryingSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
|
|
[Dependency] private readonly CarryingSlowdownSystem _slowdown = default!;
|
|
[Dependency] private readonly INetManager _net = default!;
|
|
[Dependency] private readonly MovementSpeedModifierSystem _movementSpeed = default!;
|
|
[Dependency] private readonly PullingSystem _pulling = default!;
|
|
[Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
|
|
[Dependency] private readonly SharedPopupSystem _popup = default!;
|
|
[Dependency] private readonly SharedPseudoItemSystem _pseudoItem = default!;
|
|
[Dependency] private readonly SharedTransformSystem _transform = default!;
|
|
[Dependency] private readonly StandingStateSystem _standingState = default!;
|
|
[Dependency] private readonly SharedVirtualItemSystem _virtualItem = default!;
|
|
[Dependency] private readonly SharedHandsSystem _hands = default!;
|
|
|
|
private EntityQuery<PhysicsComponent> _physicsQuery;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
_physicsQuery = GetEntityQuery<PhysicsComponent>();
|
|
|
|
SubscribeLocalEvent<CarriableComponent, GetVerbsEvent<AlternativeVerb>>(AddCarryVerb);
|
|
SubscribeLocalEvent<CarryingComponent, GetVerbsEvent<InnateVerb>>(AddInsertCarriedVerb);
|
|
SubscribeLocalEvent<CarryingComponent, VirtualItemDeletedEvent>(OnVirtualItemDeleted);
|
|
SubscribeLocalEvent<CarryingComponent, BeforeThrowEvent>(OnThrow);
|
|
SubscribeLocalEvent<CarryingComponent, EntParentChangedMessage>(OnParentChanged);
|
|
SubscribeLocalEvent<CarryingComponent, MobStateChangedEvent>(OnMobStateChanged);
|
|
SubscribeLocalEvent<CarryingComponent, DownedEvent>(OnDowned);
|
|
SubscribeLocalEvent<CarryingComponent, BeforePolymorphedEvent>(OnBeforePolymorphed);
|
|
SubscribeLocalEvent<BeingCarriedComponent, InteractionAttemptEvent>(OnInteractionAttempt);
|
|
SubscribeLocalEvent<BeingCarriedComponent, UpdateCanMoveEvent>(OnMoveAttempt);
|
|
SubscribeLocalEvent<BeingCarriedComponent, StandAttemptEvent>(OnStandAttempt);
|
|
SubscribeLocalEvent<BeingCarriedComponent, GettingInteractedWithAttemptEvent>(OnInteractedWith);
|
|
SubscribeLocalEvent<BeingCarriedComponent, PullAttemptEvent>(OnPullAttempt);
|
|
SubscribeLocalEvent<BeingCarriedComponent, StartClimbEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, BuckledEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, UnbuckledEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, StrappedEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, UnstrappedEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, EscapeInventoryEvent>(OnDrop);
|
|
SubscribeLocalEvent<BeingCarriedComponent, ComponentRemove>(OnRemoved);
|
|
SubscribeLocalEvent<CarriableComponent, CarryDoAfterEvent>(OnDoAfter);
|
|
}
|
|
|
|
private void AddCarryVerb(Entity<CarriableComponent> ent, ref GetVerbsEvent<AlternativeVerb> args)
|
|
{
|
|
var user = args.User;
|
|
var target = args.Target;
|
|
if (!args.CanInteract || !args.CanAccess || user == target)
|
|
return;
|
|
|
|
if (!CanCarry(user, ent))
|
|
return;
|
|
|
|
args.Verbs.Add(new AlternativeVerb()
|
|
{
|
|
Act = () => StartCarryDoAfter(user, ent),
|
|
Text = Loc.GetString("carry-verb"),
|
|
Priority = 2
|
|
});
|
|
}
|
|
|
|
private void AddInsertCarriedVerb(Entity<CarryingComponent> ent, ref GetVerbsEvent<InnateVerb> args)
|
|
{
|
|
// If the person is carrying someone, and the carried person is a pseudo-item, and the target entity is a storage,
|
|
// then add an action to insert the carried entity into the target
|
|
// AKA put carried felenid into a duffelbag
|
|
if (args.Using is not {} carried || !args.CanAccess || !TryComp<PseudoItemComponent>(carried, out var pseudoItem))
|
|
return;
|
|
|
|
var target = args.Target;
|
|
if (!TryComp<StorageComponent>(target, out var storageComp))
|
|
return;
|
|
|
|
if (!_pseudoItem.CheckItemFits((carried, pseudoItem), (target, storageComp)))
|
|
return;
|
|
|
|
args.Verbs.Add(new InnateVerb()
|
|
{
|
|
Act = () =>
|
|
{
|
|
DropCarried(ent, carried);
|
|
_pseudoItem.TryInsert(target, carried, pseudoItem, storageComp);
|
|
},
|
|
Text = Loc.GetString("action-name-insert-other", ("target", carried)),
|
|
Priority = 2
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Since the carried entity is stored as 2 virtual items, when deleted we want to drop them.
|
|
/// </summary>
|
|
private void OnVirtualItemDeleted(Entity<CarryingComponent> ent, ref VirtualItemDeletedEvent args)
|
|
{
|
|
if (HasComp<CarriableComponent>(args.BlockingEntity))
|
|
DropCarried(ent, args.BlockingEntity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Basically using virtual item passthrough to throw the carried person. A new age!
|
|
/// Maybe other things besides throwing should use virt items like this...
|
|
/// </summary>
|
|
private void OnThrow(Entity<CarryingComponent> ent, ref BeforeThrowEvent args)
|
|
{
|
|
if (!TryComp<VirtualItemComponent>(args.ItemUid, out var virtItem) || !HasComp<CarriableComponent>(virtItem.BlockingEntity))
|
|
return;
|
|
|
|
var carried = virtItem.BlockingEntity;
|
|
args.ItemUid = carried;
|
|
|
|
args.ThrowSpeed = 5f * MassContest(ent, carried);
|
|
}
|
|
|
|
private void OnParentChanged(Entity<CarryingComponent> ent, ref EntParentChangedMessage args)
|
|
{
|
|
var xform = Transform(ent);
|
|
if (xform.MapUid != args.OldMapId)
|
|
return;
|
|
|
|
// Do not drop the carried entity if the new parent is a grid
|
|
if (xform.ParentUid == xform.GridUid)
|
|
return;
|
|
|
|
DropCarried(ent, ent.Comp.Carried);
|
|
}
|
|
|
|
private void OnMobStateChanged(Entity<CarryingComponent> ent, ref MobStateChangedEvent args)
|
|
{
|
|
DropCarried(ent, ent.Comp.Carried);
|
|
}
|
|
|
|
private void OnDowned(Entity<CarryingComponent> ent, ref DownedEvent args)
|
|
{
|
|
DropCarried(ent, ent.Comp.Carried);
|
|
}
|
|
|
|
private void OnBeforePolymorphed(Entity<CarryingComponent> ent, ref BeforePolymorphedEvent args)
|
|
{
|
|
if (HasComp<MindContainerComponent>(ent.Comp.Carried))
|
|
DropCarried(ent, ent.Comp.Carried);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Only let the person being carried interact with their carrier and things on their person.
|
|
/// </summary>
|
|
private void OnInteractionAttempt(Entity<BeingCarriedComponent> ent, ref InteractionAttemptEvent args)
|
|
{
|
|
if (args.Target is not {} target)
|
|
return;
|
|
|
|
var targetParent = Transform(target).ParentUid;
|
|
|
|
var carrier = ent.Comp.Carrier;
|
|
if (target != carrier && targetParent != carrier && targetParent != ent.Owner)
|
|
args.Cancelled = true;
|
|
}
|
|
|
|
private void OnMoveAttempt(Entity<BeingCarriedComponent> ent, ref UpdateCanMoveEvent args)
|
|
{
|
|
args.Cancel();
|
|
}
|
|
|
|
private void OnStandAttempt(Entity<BeingCarriedComponent> ent, ref StandAttemptEvent args)
|
|
{
|
|
args.Cancel();
|
|
}
|
|
|
|
private void OnInteractedWith(Entity<BeingCarriedComponent> ent, ref GettingInteractedWithAttemptEvent args)
|
|
{
|
|
if (args.Uid != ent.Comp.Carrier)
|
|
args.Cancelled = true;
|
|
}
|
|
|
|
private void OnPullAttempt(Entity<BeingCarriedComponent> ent, ref PullAttemptEvent args)
|
|
{
|
|
args.Cancelled = true;
|
|
}
|
|
|
|
private void OnDrop<TEvent>(Entity<BeingCarriedComponent> ent, ref TEvent args) // Augh
|
|
{
|
|
DropCarried(ent.Comp.Carrier, ent);
|
|
}
|
|
|
|
private void OnRemoved(Entity<BeingCarriedComponent> ent, ref ComponentRemove args)
|
|
{
|
|
/*
|
|
This component has been removed for whatever reason, so just make sure that the
|
|
carrier is cleaned up.
|
|
*/
|
|
if (!TryComp<CarryingComponent>(ent.Comp.Carrier, out var carryingComponent))
|
|
// This carrier has probably already been cleaned, no reason to try again
|
|
return;
|
|
|
|
CleanupCarrier(ent.Comp.Carrier, ent);
|
|
}
|
|
|
|
private void OnDoAfter(Entity<CarriableComponent> ent, ref CarryDoAfterEvent args)
|
|
{
|
|
if (args.Handled || args.Cancelled)
|
|
return;
|
|
|
|
if (!CanCarry(args.Args.User, ent))
|
|
return;
|
|
|
|
Carry(args.Args.User, ent);
|
|
args.Handled = true;
|
|
}
|
|
|
|
private void StartCarryDoAfter(EntityUid carrier, Entity<CarriableComponent> carried)
|
|
{
|
|
TimeSpan length = GetPickupDuration(carrier, carried);
|
|
|
|
if (length.TotalSeconds >= 9f)
|
|
{
|
|
_popup.PopupClient(Loc.GetString("carry-too-heavy"), carried, carrier, PopupType.SmallCaution);
|
|
return;
|
|
}
|
|
|
|
if (!HasComp<KnockedDownComponent>(carried))
|
|
length *= 2f;
|
|
|
|
var ev = new CarryDoAfterEvent();
|
|
var args = new DoAfterArgs(EntityManager, carrier, length, ev, carried, target: carried)
|
|
{
|
|
BreakOnMove = true,
|
|
NeedHand = true
|
|
};
|
|
|
|
_doAfter.TryStartDoAfter(args);
|
|
|
|
// Show a popup to the person getting picked up
|
|
_popup.PopupEntity(Loc.GetString("carry-started", ("carrier", carrier)), carried, carried);
|
|
}
|
|
|
|
private void Carry(EntityUid carrier, EntityUid carried)
|
|
{
|
|
if (TryComp<PullableComponent>(carried, out var carriedPullable))
|
|
_pulling.TryStopPull(carried, carriedPullable);
|
|
|
|
if (TryComp<PullableComponent>(carrier, out var carrierPullable))
|
|
_pulling.TryStopPull(carrier, carrierPullable);
|
|
|
|
var carrierXform = Transform(carrier);
|
|
var xform = Transform(carried);
|
|
_transform.AttachToGridOrMap(carrier, carrierXform);
|
|
_transform.AttachToGridOrMap(carried, xform);
|
|
_transform.SetParent(carried, xform, carrier, carrierXform);
|
|
|
|
var carryingComp = EnsureComp<CarryingComponent>(carrier);
|
|
carryingComp.Carried = carried;
|
|
Dirty(carrier, carryingComp);
|
|
var carriedComp = EnsureComp<BeingCarriedComponent>(carried);
|
|
carriedComp.Carrier = carrier;
|
|
Dirty(carried, carriedComp);
|
|
EnsureComp<KnockedDownComponent>(carried);
|
|
|
|
ApplyCarrySlowdown(carrier, carried);
|
|
|
|
_actionBlocker.UpdateCanMove(carried);
|
|
|
|
if (_net.IsClient) // no spawning prediction
|
|
return;
|
|
|
|
_virtualItem.TrySpawnVirtualItemInHand(carried, carrier);
|
|
_virtualItem.TrySpawnVirtualItemInHand(carried, carrier);
|
|
}
|
|
|
|
public bool TryCarry(EntityUid carrier, Entity<CarriableComponent?> toCarry)
|
|
{
|
|
if (!Resolve(toCarry, ref toCarry.Comp, false))
|
|
return false;
|
|
|
|
if (!CanCarry(carrier, (toCarry, toCarry.Comp)))
|
|
return false;
|
|
|
|
// The second one means that carrier is a pseudo-item and is inside a bag.
|
|
if (HasComp<BeingCarriedComponent>(carrier) || HasComp<ItemComponent>(carrier))
|
|
return false;
|
|
|
|
if (GetPickupDuration(carrier, toCarry).TotalSeconds > 9f)
|
|
return false;
|
|
|
|
Carry(carrier, toCarry);
|
|
return true;
|
|
}
|
|
|
|
public void DropCarried(EntityUid carrier, EntityUid carried)
|
|
{
|
|
Drop(carried);
|
|
CleanupCarrier(carrier, carried);
|
|
}
|
|
|
|
private void CleanupCarrier(EntityUid carrier, EntityUid carried)
|
|
{
|
|
RemComp<CarryingComponent>(carrier); // get rid of this first so we don't recursively fire that event
|
|
RemComp<CarryingSlowdownComponent>(carrier);
|
|
_virtualItem.DeleteInHandsMatching(carrier, carried);
|
|
_movementSpeed.RefreshMovementSpeedModifiers(carrier);
|
|
}
|
|
|
|
private void Drop(EntityUid carried)
|
|
{
|
|
RemComp<BeingCarriedComponent>(carried);
|
|
RemComp<KnockedDownComponent>(carried); // TODO SHITMED: make sure this doesnt let you make someone with no legs walk
|
|
_actionBlocker.UpdateCanMove(carried);
|
|
Transform(carried).AttachToGridOrMap();
|
|
_standingState.Stand(carried);
|
|
}
|
|
|
|
private void ApplyCarrySlowdown(EntityUid carrier, EntityUid carried)
|
|
{
|
|
var massRatio = MassContest(carrier, carried);
|
|
|
|
if (massRatio == 0)
|
|
massRatio = 1;
|
|
|
|
var massRatioSq = Math.Pow(massRatio, 2);
|
|
var modifier = (1 - (0.15 / massRatioSq));
|
|
modifier = Math.Max(0.1, modifier);
|
|
_slowdown.SetModifier(carrier, (float) modifier);
|
|
}
|
|
|
|
public bool CanCarry(EntityUid carrier, Entity<CarriableComponent> carried)
|
|
{
|
|
return
|
|
carrier != carried.Owner &&
|
|
// can't carry multiple people, even if you have 4 hands it will break invariants when removing carryingcomponent for first carried person
|
|
!HasComp<CarryingComponent>(carrier) &&
|
|
// can't carry someone in a locker, buckled, etc
|
|
HasComp<MapGridComponent>(Transform(carrier).ParentUid) &&
|
|
// no tower of spacemen or stack overflow
|
|
!HasComp<BeingCarriedComponent>(carrier) &&
|
|
!HasComp<BeingCarriedComponent>(carried) &&
|
|
// finally check that there are enough free hands
|
|
TryComp<HandsComponent>(carrier, out var hands) && _hands.CountFreeHands((carrier, hands)) >= carried.Comp.FreeHandsRequired;
|
|
}
|
|
|
|
private float MassContest(EntityUid roller, EntityUid target)
|
|
{
|
|
if (!_physicsQuery.TryComp(roller, out var rollerPhysics) || !_physicsQuery.TryComp(target, out var targetPhysics))
|
|
return 1f;
|
|
|
|
if (targetPhysics.FixturesMass == 0)
|
|
return 1f;
|
|
|
|
return rollerPhysics.FixturesMass / targetPhysics.FixturesMass;
|
|
}
|
|
|
|
private TimeSpan GetPickupDuration(EntityUid carrier, EntityUid carried)
|
|
{
|
|
var length = TimeSpan.FromSeconds(3);
|
|
|
|
var mod = MassContest(carrier, carried);
|
|
if (mod != 0)
|
|
length /= mod;
|
|
|
|
return length;
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
var query = EntityQueryEnumerator<BeingCarriedComponent, TransformComponent>();
|
|
while (query.MoveNext(out var carried, out var comp, out var xform))
|
|
{
|
|
var carrier = comp.Carrier;
|
|
if (TerminatingOrDeleted(carrier))
|
|
{
|
|
RemCompDeferred<BeingCarriedComponent>(carried);
|
|
continue;
|
|
}
|
|
|
|
// SOMETIMES - when an entity is inserted into disposals, or a cryosleep chamber - it can get re-parented without a proper reparent event
|
|
// when this happens, it needs to be dropped because it leads to weird behavior
|
|
if (xform.ParentUid != carrier)
|
|
{
|
|
DropCarried(carrier, carried);
|
|
continue;
|
|
}
|
|
|
|
// Make sure the carried entity is always centered relative to the carrier, as gravity pulls can offset it otherwise
|
|
_transform.SetLocalPosition(carried, Vector2.Zero);
|
|
}
|
|
}
|
|
}
|