{
Broadcast = true,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
});
}
{
BreakOnDamage = false,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
};
var started = _doAfterSystem.TryStartDoAfter(doAfterEventArgs);
{
BreakOnDamage = true,
BreakOnMove = true,
- NeedHand = false
+ NeedHand = false,
};
_doAfterSystem.TryStartDoAfter(doAfterArgs);
/// <param name="component">The ensnaring component</param>
public void TryFree(EntityUid target, EntityUid user, EntityUid ensnare, EnsnaringComponent component)
{
- //Don't do anything if they don't have the ensnareable component.
+ // Don't do anything if they don't have the ensnareable component.
if (!HasComp<EnsnareableComponent>(target))
return;
BreakOnMove = breakOnMove,
BreakOnDamage = false,
NeedHand = true,
- BlockDuplicate = true,
+ BreakOnDropItem = false,
};
if (!_doAfter.TryStartDoAfter(doAfterEventArgs))
var cleanDelay = cleanForensicsEntity.Comp.CleanDelay;
var doAfterArgs = new DoAfterArgs(EntityManager, user, cleanDelay, new CleanForensicsDoAfterEvent(), cleanForensicsEntity, target: target, used: cleanForensicsEntity)
{
- BreakOnHandChange = true,
NeedHand = true,
BreakOnDamage = true,
BreakOnMove = true,
{
BreakOnDamage = true,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
+ BreakOnDropItem = false,
};
_doAfter.TryStartDoAfter(doAfterArgs);
{
BreakOnDamage = true,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
};
_doAfterSystem.TryStartDoAfter(doAfter);
return true;
DistanceThreshold = SharedInteractionSystem.InteractionRange,
BreakOnDamage = true,
BreakOnMove = true,
- BreakOnHandChange = false,
- NeedHand = true
+ NeedHand = true,
},
out var doAfterId);
{
BreakOnDamage = true,
BreakOnMove = true,
- BreakOnHandChange = false,
NeedHand = true
},
out var doAfterId);
{
DistanceThreshold = SharedInteractionSystem.InteractionRange,
BreakOnDamage = true,
- BreakOnHandChange = false,
NeedHand = true
},
out var doAfterId);
{
BreakOnDamage = true,
BreakOnMove = true,
- BreakOnHandChange = false,
- NeedHand = true
+ NeedHand = true,
},
out var doAfterId);
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, delay, new ReclaimerDoAfterEvent(), reclaimer, target: args.Target, used: args.Used)
{
NeedHand = true,
- BreakOnMove = true
+ BreakOnMove = true,
});
}
return _doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.DoAfterDuration, new DefibrillatorZapDoAfterEvent(),
uid, target, uid)
{
- BlockDuplicate = true,
- BreakOnHandChange = true,
NeedHand = true,
BreakOnMove = !component.AllowDoAfterMovement
});
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, uid.Comp.ScanDelay, new HealthAnalyzerDoAfterEvent(), uid, target: args.Target, used: uid)
{
NeedHand = true,
- BreakOnMove = true
+ BreakOnMove = true,
});
var msg = Loc.GetString("health-analyzer-popup-scan-target", ("user", Identity.Entity(args.User, EntityManager)));
{
BreakOnDamage = true,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
};
if (!_doAfter.TryStartDoAfter(doAfter))
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.StartTime, new GeneratorStartedEvent(), uid, uid)
{
- BreakOnDamage = true, BreakOnMove = true, RequireCanInteract = true,
- NeedHand = true
+ BreakOnDamage = true,
+ BreakOnMove = true,
+ NeedHand = true,
+ BreakOnDropItem = false,
});
}
{
BreakOnMove = true,
BreakOnDamage = true,
- NeedHand = false //No hands 'cause we be kickin'
+ NeedHand = false, //No hands 'cause we be kickin'
};
resistLockerComponent.IsResisting = true;
{
BreakOnMove = true,
BreakOnDamage = true,
- CancelDuplicate = true,
// multiple pipes can be sprayed at once just not the same one
DuplicateCondition = DuplicateConditions.SameTarget,
- NeedHand = true
+ NeedHand = true,
};
args.Handled = DoAfter.TryStartDoAfter(doAfterEventArgs);
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, delay, new StickyDoAfterEvent(), uid, target: target, used: uid)
{
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
});
}
else
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, delay, new StickyDoAfterEvent(), uid, target: uid)
{
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
});
}
else
BreakOnMove = true,
BreakOnDamage = true,
NeedHand = true,
- BreakOnHandChange = true
};
if (component.Stream == null)
/// <summary>
/// How long does the do_after require to complete
/// </summary>
- [DataField("delay", required: true)]
+ [DataField(required: true)]
public TimeSpan Delay;
/// <summary>
/// Applicable target (if relevant)
/// </summary>
[NonSerialized]
- [DataField("target")]
+ [DataField]
public EntityUid? Target;
public NetEntity? NetTarget;
/// <summary>
/// The event that will get raised when the DoAfter has finished. If null, this will simply raise a <see cref="SimpleDoAfterEvent"/>
/// </summary>
- [DataField("event", required: true)]
+ [DataField(required: true)]
public DoAfterEvent Event = default!;
/// <summary>
/// Entity which will receive the directed event. If null, no directed event will be raised.
/// </summary>
[NonSerialized]
- [DataField("eventTarget")]
+ [DataField]
public EntityUid? EventTarget;
public NetEntity? NetEventTarget;
/// <summary>
/// Should the DoAfter event broadcast? If this is false, then <see cref="EventTarget"/> should be a valid entity.
/// </summary>
- [DataField("broadcast")]
+ [DataField]
public bool Broadcast;
#endregion
/// <summary>
/// Whether or not this do after requires the user to have hands.
/// </summary>
- [DataField("needHand")]
+ [DataField]
public bool NeedHand;
/// <summary>
/// Whether we need to keep our active hand as is (i.e. can't change hand or change item). This also covers
/// requiring the hand to be free (if applicable). This does nothing if <see cref="NeedHand"/> is false.
/// </summary>
- [DataField("breakOnHandChange")]
+ [DataField]
public bool BreakOnHandChange = true;
+ /// <summary>
+ /// Whether the do-after should get interrupted if we drop the
+ /// active item we started the do-after with
+ /// This does nothing if <see cref="NeedHand"/> is false.
+ /// </summary>
+ [DataField]
+ public bool BreakOnDropItem = true;
+
/// <summary>
/// If do_after stops when the user or target moves
/// </summary>
/// <summary>
/// Threshold for user and target movement
/// </summary>
- [DataField("movementThreshold")]
+ [DataField]
public float MovementThreshold = 0.3f;
/// <summary>
/// Threshold for distance user from the used OR target entities.
/// </summary>
- [DataField("distanceThreshold")]
+ [DataField]
public float? DistanceThreshold;
/// <summary>
/// Whether damage will cancel the DoAfter. See also <see cref="DamageThreshold"/>.
/// </summary>
- [DataField("breakOnDamage")]
+ [DataField]
public bool BreakOnDamage;
/// <summary>
/// Threshold for user damage. This damage has to be dealt in a single event, not over time.
/// </summary>
- [DataField("damageThreshold")]
+ [DataField]
public FixedPoint2 DamageThreshold = 1;
/// <summary>
/// If true, this DoAfter will be canceled if the user can no longer interact with the target.
/// </summary>
- [DataField("requireCanInteract")]
+ [DataField]
public bool RequireCanInteract = true;
#endregion
/// Note that this will block even if the duplicate is cancelled because either DoAfter had
/// <see cref="CancelDuplicate"/> enabled.
/// </remarks>
- [DataField("blockDuplicate")]
+ [DataField]
public bool BlockDuplicate = true;
//TODO: User pref to not cancel on second use on specific doafters
/// If true, this will cancel any duplicate DoAfters when attempting to add a new DoAfter. See also
/// <see cref="DuplicateConditions"/>.
/// </summary>
- [DataField("cancelDuplicate")]
+ [DataField]
public bool CancelDuplicate = true;
/// <summary>
/// Note that both DoAfters may have their own conditions, and they will be considered duplicated if either set
/// of conditions is satisfied.
/// </remarks>
- [DataField("duplicateCondition")]
+ [DataField]
public DuplicateConditions DuplicateCondition = DuplicateConditions.All;
#endregion
Broadcast = other.Broadcast;
NeedHand = other.NeedHand;
BreakOnHandChange = other.BreakOnHandChange;
+ BreakOnDropItem = other.BreakOnDropItem;
BreakOnMove = other.BreakOnMove;
BreakOnWeightlessMove = other.BreakOnWeightlessMove;
MovementThreshold = other.MovementThreshold;
using Content.Shared.Gravity;
using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Physics;
using Robust.Shared.Utility;
[Dependency] private readonly IDynamicTypeFactory _factory = default!;
[Dependency] private readonly SharedGravitySystem _gravity = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
+ [Dependency] private readonly SharedHandsSystem _hands = default!;
private DoAfter[] _doAfters = Array.Empty<DoAfter>();
if (args.AttemptFrequency == AttemptFrequency.EveryTick && !TryAttemptEvent(doAfter))
return true;
+ // Check if the do-after requires hands to perform at first
+ // For example, you need hands to strip clothes off of someone
+ // This does not mean their hand needs to be empty.
if (args.NeedHand)
{
if (!handsQuery.TryGetComponent(args.User, out var hands) || hands.Count == 0)
return true;
- if (args.BreakOnHandChange && (hands.ActiveHand?.Name != doAfter.InitialHand
- || hands.ActiveHandEntity != doAfter.InitialItem))
- {
+ // If an item was in the user's hand to begin with,
+ // check if the user is no longer holding the item.
+ if (args.BreakOnDropItem && !_hands.IsHolding((args.User, hands), doAfter.InitialItem))
+ return true;
+
+ // If the user changes which hand is active at all, interrupt the do-after
+ if (args.BreakOnHandChange && hands.ActiveHand?.Name != doAfter.InitialHand)
return true;
- }
}
if (args.RequireCanInteract && !_actionBlocker.CanInteract(args.User, args.Target))
// For this we need to stay on the same hand slot and need the same item in that hand slot
// (or if there is no item there we need to keep it free).
- if (args.NeedHand && args.BreakOnHandChange)
+ if (args.NeedHand && (args.BreakOnHandChange || args.BreakOnDropItem))
{
if (!TryComp(args.User, out HandsComponent? handsComponent))
return false;
target,
itemUid)
{
- BlockDuplicate = true,
- BreakOnHandChange = true,
BreakOnMove = true,
- CancelDuplicate = true,
- RequireCanInteract = true,
- NeedHand = true
+ NeedHand = true,
};
_doAfter.TryStartDoAfter(args);
target,
removedItem.Value)
{
- BlockDuplicate = true,
- BreakOnHandChange = true,
BreakOnMove = true,
- CancelDuplicate = true,
- RequireCanInteract = true,
- NeedHand = true
+ NeedHand = true,
};
_doAfter.TryStartDoAfter(args);
return _doAfter.TryStartDoAfter(
new DoAfterArgs(EntityManager, user, lockComp.LockTime, new LockDoAfter(), uid, uid)
{
- BreakOnDamage = true, BreakOnMove = true, RequireCanInteract = true,
- NeedHand = true
+ BreakOnDamage = true,
+ BreakOnMove = true,
+ NeedHand = true,
+ BreakOnDropItem = false,
});
}
return _doAfter.TryStartDoAfter(
new DoAfterArgs(EntityManager, user, lockComp.LockTime, new UnlockDoAfter(), uid, uid)
{
- BreakOnDamage = true, BreakOnMove = true, RequireCanInteract = true,
- NeedHand = true
+ BreakOnDamage = true,
+ BreakOnMove = true,
+ NeedHand = true,
+ BreakOnDropItem = false,
});
}
{
BreakOnMove = true,
BreakOnDamage = true,
- NeedHand = true //What, are you going to read with your eyes only??
+ NeedHand = true, //What, are you going to read with your eyes only??
};
_doAfter.TryStartDoAfter(doAfterEventArgs);
_doAfter.TryStartDoAfter(
new DoAfterArgs(EntityManager, args.User, component.ApplyFultonDuration, ev, args.Target, args.Target, args.Used)
{
- CancelDuplicate = true,
MovementThreshold = 0.5f,
BreakOnMove = true,
Broadcast = true,
{
BreakOnMove = true,
BreakOnDamage = true,
- NeedHand = true
+ NeedHand = true,
};
if (!DoAfter.TryStartDoAfter(doAfterEventArgs, out var id))
return;
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, userUid, delay, new DumpableDoAfterEvent(), storageUid, target: targetUid, used: storageUid)
{
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
});
}
{
BreakOnDamage = true,
BreakOnMove = true,
- NeedHand = true
+ NeedHand = true,
};
_doAfterSystem.TryStartDoAfter(doAfterArgs);
{
BreakOnMove = true,
BreakOnDamage = true,
- NeedHand = true
+ NeedHand = true,
};
if (!_doAfter.TryStartDoAfter(doAfterArgs))
{
BreakOnMove = true,
BreakOnDamage = false,
- NeedHand = true
+ NeedHand = true,
});
}
projects / space-station-14.git / commitdiff