[Dependency] private readonly IPlayerManager _player = default!;
[UISystemDependency] private readonly HandsSystem _handsSystem = default!;
+ [UISystemDependency] private readonly UseDelaySystem _useDelay = default!;
private readonly List<HandsContainer> _handsContainers = new();
private readonly Dictionary<string, int> _handContainerIndices = new();
foreach (var hand in container.GetButtons())
{
- if (!_entities.TryGetComponent(hand.Entity, out UseDelayComponent? useDelay) ||
- useDelay is not { DelayStartTime: var start, DelayEndTime: var end })
+ if (!_entities.TryGetComponent(hand.Entity, out UseDelayComponent? useDelay))
{
hand.CooldownDisplay.Visible = false;
continue;
}
+ var delay = _useDelay.GetLastEndingDelay((hand.Entity.Value, useDelay));
hand.CooldownDisplay.Visible = true;
- hand.CooldownDisplay.FromTime(start, end);
+ hand.CooldownDisplay.FromTime(delay.StartTime, delay.EndTime);
}
}
}
_audio.PlayPvs(entity.Comp.SpraySound, entity, entity.Comp.SpraySound.Params.WithVariation(0.125f));
- _useDelay.SetDelay((entity, useDelay), TimeSpan.FromSeconds(cooldownTime));
+ _useDelay.SetLength((entity, useDelay), TimeSpan.FromSeconds(cooldownTime));
_useDelay.TryResetDelay((entity, useDelay));
}
}
[Dependency] private readonly IPrototypeManager _prototype = default!;
[Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
- [Dependency] private readonly UseDelaySystem _useDelay = default!;
+
+ private const string OpenUiUseDelayID = "storage";
public override void Initialize()
{
SubscribeLocalEvent<StorageFillComponent, MapInitEvent>(OnStorageFillMapInit);
}
+ protected override void OnMapInit(Entity<StorageComponent> entity, ref MapInitEvent args)
+ {
+ base.OnMapInit(entity, ref args);
+
+ if (TryComp<UseDelayComponent>(entity, out var useDelay))
+ UseDelay.SetLength((entity, useDelay), entity.Comp.OpenUiCooldown, OpenUiUseDelayID);
+ }
+
private void AddUiVerb(EntityUid uid, StorageComponent component, GetVerbsEvent<ActivationVerb> args)
{
var silent = false;
return;
// prevent spamming bag open / honkerton honk sound
- silent |= TryComp<UseDelayComponent>(uid, out var useDelay) && _useDelay.IsDelayed((uid, useDelay));
+ silent |= TryComp<UseDelayComponent>(uid, out var useDelay) && UseDelay.IsDelayed((uid, useDelay), OpenUiUseDelayID);
if (!silent)
{
if (!storageComp.IsUiOpen)
_audio.PlayPvs(storageComp.StorageOpenSound, uid);
if (useDelay != null)
- _useDelay.TryResetDelay((uid, useDelay));
+ UseDelay.TryResetDelay((uid, useDelay), id: OpenUiUseDelayID);
}
Log.Debug($"Storage (UID {uid}) \"used\" by player session (UID {player.PlayerSession.AttachedEntity}).");
private readonly List<ItemSizePrototype> _sortedSizes = new();
private FrozenDictionary<string, ItemSizePrototype> _nextSmallest = FrozenDictionary<string, ItemSizePrototype>.Empty;
+ private const string QuickInsertUseDelayID = "quickInsert";
+
protected readonly List<string> CantFillReasons = [];
/// <inheritdoc />
_xformQuery = GetEntityQuery<TransformComponent>();
_prototype.PrototypesReloaded += OnPrototypesReloaded;
+ SubscribeLocalEvent<StorageComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<StorageComponent, ComponentGetState>(OnStorageGetState);
SubscribeLocalEvent<StorageComponent, ComponentHandleState>(OnStorageHandleState);
SubscribeLocalEvent<StorageComponent, ComponentInit>(OnComponentInit, before: new[] { typeof(SharedContainerSystem) });
UpdatePrototypeCache();
}
+ protected virtual void OnMapInit(Entity<StorageComponent> entity, ref MapInitEvent args)
+ {
+ if (TryComp<UseDelayComponent>(entity, out var useDelayComp))
+ UseDelay.SetLength((entity, useDelayComp), entity.Comp.QuickInsertCooldown, QuickInsertUseDelayID);
+ }
+
private void OnStorageGetState(EntityUid uid, StorageComponent component, ref ComponentGetState args)
{
var storedItems = new Dictionary<NetEntity, ItemStorageLocation>();
/// <returns></returns>
private void AfterInteract(EntityUid uid, StorageComponent storageComp, AfterInteractEvent args)
{
- if (args.Handled || !args.CanReach || !UseDelay.TryResetDelay(uid, checkDelayed: true))
+ if (args.Handled || !args.CanReach || !UseDelay.TryResetDelay(uid, checkDelayed: true, id: QuickInsertUseDelayID))
return;
// Pick up all entities in a radius around the clicked location.
[DataField]
public bool QuickInsert; // Can insert storables by clicking them with the storage entity
+ /// <summary>
+ /// Minimum delay between quick/area insert actions.
+ /// </summary>
+ /// <remarks>Used to prevent autoclickers spamming server with individual pickup actions.</remarks>
+ public TimeSpan QuickInsertCooldown = TimeSpan.FromSeconds(0.5);
+
+ /// <summary>
+ /// Minimum delay between UI open actions.
+ /// <remarks>Used to spamming opening sounds.</remarks>
+ /// </summary>
+ [DataField]
+ public TimeSpan OpenUiCooldown = TimeSpan.Zero;
+
[DataField]
public bool ClickInsert = true; // Can insert stuff by clicking the storage entity with it
using Robust.Shared.GameStates;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Robust.Shared.Serialization;
namespace Content.Shared.Timing;
/// <summary>
-/// Timer that creates a cooldown each time an object is activated/used
+/// Timer that creates a cooldown each time an object is activated/used.
+/// Can support additional, separate cooldown timers on the object by passing a unique ID with the system methods.
/// </summary>
-/// <remarks>
-/// Currently it only supports a single delay per entity, this means that for things that have two delay interactions they will share one timer, so this can cause issues. For example, the bible has a delay when opening the storage UI and when applying it's interaction effect, and they share the same delay.
-/// </remarks>
[RegisterComponent]
-[NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
+[NetworkedComponent, AutoGenerateComponentState]
[Access(typeof(UseDelaySystem))]
public sealed partial class UseDelayComponent : Component
{
- /// <summary>
- /// When the delay starts.
- /// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
- [AutoPausedField]
- public TimeSpan DelayStartTime;
-
- /// <summary>
- /// When the delay ends.
- /// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField]
- [AutoPausedField]
- public TimeSpan DelayEndTime;
+ [DataField, AutoNetworkedField]
+ public Dictionary<string, UseDelayInfo> Delays = [];
/// <summary>
- /// Default delay time
+ /// Default delay time.
/// </summary>
+ /// <remarks>
+ /// This is only used at MapInit and should not be expected
+ /// to reflect the length of the default delay after that.
+ /// Use <see cref="UseDelaySystem.TryGetDelayInfo"/> instead.
+ /// </remarks>
[DataField]
- [ViewVariables(VVAccess.ReadWrite)]
- [AutoNetworkedField]
public TimeSpan Delay = TimeSpan.FromSeconds(1);
}
+
+[Serializable, NetSerializable]
+[DataDefinition]
+public sealed partial class UseDelayInfo
+{
+ [DataField]
+ public TimeSpan Length { get; set; }
+ [DataField]
+ public TimeSpan StartTime { get; set; }
+ [DataField]
+ public TimeSpan EndTime { get; set; }
+
+ public UseDelayInfo(TimeSpan length, TimeSpan startTime = default, TimeSpan endTime = default)
+ {
+ Length = length;
+ StartTime = startTime;
+ EndTime = endTime;
+ }
+}
+using System.Diagnostics.CodeAnalysis;
using Robust.Shared.Timing;
namespace Content.Shared.Timing;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly MetaDataSystem _metadata = default!;
- public void SetDelay(Entity<UseDelayComponent> ent, TimeSpan delay)
+ private const string DefaultId = "default";
+
+ public override void Initialize()
{
- if (ent.Comp.Delay == delay)
- return;
+ base.Initialize();
+
+ SubscribeLocalEvent<UseDelayComponent, MapInitEvent>(OnMapInit);
+ SubscribeLocalEvent<UseDelayComponent, EntityUnpausedEvent>(OnUnpaused);
+ }
+
+ private void OnMapInit(Entity<UseDelayComponent> ent, ref MapInitEvent args)
+ {
+ // Set default delay length from the prototype
+ // This makes it easier for simple use cases that only need a single delay
+ SetLength(ent, ent.Comp.Delay, DefaultId);
+ }
+
+ private void OnUnpaused(Entity<UseDelayComponent> ent, ref EntityUnpausedEvent args)
+ {
+ // We have to do this manually, since it's not just a single field.
+ foreach (var entry in ent.Comp.Delays.Values)
+ {
+ entry.EndTime += args.PausedTime;
+ }
+ }
+
+ /// <summary>
+ /// Sets the length of the delay with the specified ID.
+ /// </summary>
+ public bool SetLength(Entity<UseDelayComponent> ent, TimeSpan length, string id = DefaultId)
+ {
+ if (ent.Comp.Delays.TryGetValue(id, out var entry))
+ {
+ if (entry.Length == length)
+ return true;
+
+ entry.Length = length;
+ }
+ else
+ {
+ ent.Comp.Delays.Add(id, new UseDelayInfo(length));
+ }
- ent.Comp.Delay = delay;
Dirty(ent);
+ return true;
}
/// <summary>
- /// Returns true if the entity has a currently active UseDelay.
+ /// Returns true if the entity has a currently active UseDelay with the specified ID.
/// </summary>
- public bool IsDelayed(Entity<UseDelayComponent> ent)
+ public bool IsDelayed(Entity<UseDelayComponent> ent, string id = DefaultId)
{
- return ent.Comp.DelayEndTime >= _gameTiming.CurTime;
+ if (!ent.Comp.Delays.TryGetValue(id, out var entry))
+ return false;
+
+ return entry.EndTime >= _gameTiming.CurTime;
}
/// <summary>
- /// Cancels the current delay.
+ /// Cancels the delay with the specified ID.
/// </summary>
- public void CancelDelay(Entity<UseDelayComponent> ent)
+ public void CancelDelay(Entity<UseDelayComponent> ent, string id = DefaultId)
{
- ent.Comp.DelayEndTime = _gameTiming.CurTime;
+ if (!ent.Comp.Delays.TryGetValue(id, out var entry))
+ return;
+
+ entry.EndTime = _gameTiming.CurTime;
Dirty(ent);
}
/// <summary>
- /// Resets the UseDelay entirely for this entity if possible.
+ /// Tries to get info about the delay with the specified ID. See <see cref="UseDelayInfo"/>.
/// </summary>
- /// <param name="checkDelayed">Check if the entity has an ongoing delay, return false if it does, return true if it does not.</param>
- public bool TryResetDelay(Entity<UseDelayComponent> ent, bool checkDelayed = false)
+ /// <param name="ent"></param>
+ /// <param name="info"></param>
+ /// <param name="id"></param>
+ /// <returns></returns>
+ public bool TryGetDelayInfo(Entity<UseDelayComponent> ent, [NotNullWhen(true)] out UseDelayInfo? info, string id = DefaultId)
{
- if (checkDelayed && IsDelayed(ent))
+ return ent.Comp.Delays.TryGetValue(id, out info);
+ }
+
+ /// <summary>
+ /// Returns info for the delay that will end farthest in the future.
+ /// </summary>
+ public UseDelayInfo GetLastEndingDelay(Entity<UseDelayComponent> ent)
+ {
+ var last = ent.Comp.Delays[DefaultId];
+ foreach (var entry in ent.Comp.Delays)
+ {
+ if (entry.Value.EndTime > last.EndTime)
+ last = entry.Value;
+ }
+ return last;
+ }
+
+ /// <summary>
+ /// Resets the delay with the specified ID for this entity if possible.
+ /// </summary>
+ /// <param name="checkDelayed">Check if the entity has an ongoing delay with the specified ID.
+ /// If it does, return false and don't reset it.
+ /// Otherwise reset it and return true.</param>
+ public bool TryResetDelay(Entity<UseDelayComponent> ent, bool checkDelayed = false, string id = DefaultId)
+ {
+ if (checkDelayed && IsDelayed(ent, id))
+ return false;
+
+ if (!ent.Comp.Delays.TryGetValue(id, out var entry))
return false;
var curTime = _gameTiming.CurTime;
- ent.Comp.DelayStartTime = curTime;
- ent.Comp.DelayEndTime = curTime - _metadata.GetPauseTime(ent) + ent.Comp.Delay;
+ entry.StartTime = curTime;
+ entry.EndTime = curTime - _metadata.GetPauseTime(ent) + entry.Length;
Dirty(ent);
return true;
}
- public bool TryResetDelay(EntityUid uid, bool checkDelayed = false, UseDelayComponent? component = null)
+ public bool TryResetDelay(EntityUid uid, bool checkDelayed = false, UseDelayComponent? component = null, string id = DefaultId)
{
if (!Resolve(uid, ref component, false))
return false;
- return TryResetDelay((uid, component), checkDelayed);
+ return TryResetDelay((uid, component), checkDelayed, id);
+ }
+
+ /// <summary>
+ /// Resets all delays on the entity.
+ /// </summary>
+ public void ResetAllDelays(Entity<UseDelayComponent> ent)
+ {
+ var curTime = _gameTiming.CurTime;
+ foreach (var entry in ent.Comp.Delays.Values)
+ {
+ entry.StartTime = curTime;
+ entry.EndTime = curTime - _metadata.GetPauseTime(ent) + entry.Length;
+ }
+ Dirty(ent);
}
}
projects / space-station-14.git / commitdiff