383 lines
13 KiB
C#
383 lines
13 KiB
C#
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Content.Shared.Damage;
|
|
using Content.Shared.Hands.Components;
|
|
using Content.Shared.Mobs;
|
|
using Content.Shared.Stunnable;
|
|
using Robust.Shared.GameStates;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Shared.DoAfter;
|
|
|
|
public abstract class SharedDoAfterSystem : EntitySystem
|
|
{
|
|
[Dependency] protected readonly IGameTiming GameTiming = default!;
|
|
|
|
// We cache the list as to not allocate every update tick...
|
|
private readonly Queue<DoAfter> _pending = new();
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
SubscribeLocalEvent<DoAfterComponent, DamageChangedEvent>(OnDamage);
|
|
SubscribeLocalEvent<DoAfterComponent, MobStateChangedEvent>(OnStateChanged);
|
|
SubscribeLocalEvent<DoAfterComponent, ComponentGetState>(OnDoAfterGetState);
|
|
}
|
|
|
|
private void Add(EntityUid entity, DoAfterComponent component, DoAfter doAfter)
|
|
{
|
|
doAfter.ID = component.RunningIndex;
|
|
doAfter.Delay = doAfter.EventArgs.Delay;
|
|
component.DoAfters.Add(component.RunningIndex, doAfter);
|
|
EnsureComp<ActiveDoAfterComponent>(entity);
|
|
component.RunningIndex++;
|
|
Dirty(component);
|
|
}
|
|
|
|
private void OnDoAfterGetState(EntityUid uid, DoAfterComponent component, ref ComponentGetState args)
|
|
{
|
|
args.State = new DoAfterComponentState(component.DoAfters);
|
|
}
|
|
|
|
private void Cancelled(DoAfterComponent component, DoAfter doAfter)
|
|
{
|
|
if (!component.DoAfters.TryGetValue(doAfter.ID, out var index))
|
|
return;
|
|
|
|
component.DoAfters.Remove(doAfter.ID);
|
|
|
|
if (component.DoAfters.Count == 0)
|
|
RemComp<ActiveDoAfterComponent>(component.Owner);
|
|
|
|
RaiseNetworkEvent(new CancelledDoAfterMessage(component.Owner, index.ID));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Call when the particular DoAfter is finished.
|
|
/// Client should be tracking this independently.
|
|
/// </summary>
|
|
private void Finished(DoAfterComponent component, DoAfter doAfter)
|
|
{
|
|
if (!component.DoAfters.ContainsKey(doAfter.ID))
|
|
return;
|
|
|
|
component.DoAfters.Remove(doAfter.ID);
|
|
|
|
if (component.DoAfters.Count == 0)
|
|
RemComp<ActiveDoAfterComponent>(component.Owner);
|
|
}
|
|
|
|
private void OnStateChanged(EntityUid uid, DoAfterComponent component, MobStateChangedEvent args)
|
|
{
|
|
if (args.NewMobState != MobState.Dead || args.NewMobState != MobState.Critical)
|
|
return;
|
|
|
|
foreach (var (_, doAfter) in component.DoAfters)
|
|
{
|
|
Cancel(uid, doAfter, component);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cancels DoAfter if it breaks on damage and it meets the threshold
|
|
/// </summary>
|
|
/// <param name="uid">The EntityUID of the user</param>
|
|
/// <param name="component"></param>
|
|
/// <param name="args"></param>
|
|
private void OnDamage(EntityUid uid, DoAfterComponent component, DamageChangedEvent args)
|
|
{
|
|
if (!args.InterruptsDoAfters || !args.DamageIncreased || args.DamageDelta == null)
|
|
return;
|
|
|
|
foreach (var doAfter in component.DoAfters.Values)
|
|
{
|
|
if (doAfter.EventArgs.BreakOnDamage && args.DamageDelta?.Total.Float() > doAfter.EventArgs.DamageThreshold)
|
|
Cancel(uid, doAfter, component);
|
|
}
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
foreach (var (_, comp) in EntityManager.EntityQuery<ActiveDoAfterComponent, DoAfterComponent>())
|
|
{
|
|
foreach (var doAfter in comp.DoAfters.Values.ToArray())
|
|
{
|
|
Run(comp.Owner, comp, doAfter);
|
|
|
|
switch (doAfter.Status)
|
|
{
|
|
case DoAfterStatus.Running:
|
|
break;
|
|
case DoAfterStatus.Cancelled:
|
|
_pending.Enqueue(doAfter);
|
|
break;
|
|
case DoAfterStatus.Finished:
|
|
_pending.Enqueue(doAfter);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
while (_pending.TryDequeue(out var doAfter))
|
|
{
|
|
if (doAfter.Status == DoAfterStatus.Cancelled)
|
|
{
|
|
Cancelled(comp, doAfter);
|
|
|
|
if (doAfter.Done != null)
|
|
doAfter.Done(true);
|
|
}
|
|
|
|
if (doAfter.Status == DoAfterStatus.Finished)
|
|
{
|
|
Finished(comp, doAfter);
|
|
|
|
if (doAfter.Done != null)
|
|
doAfter.Done(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tasks that are delayed until the specified time has passed
|
|
/// These can be potentially cancelled by the user moving or when other things happen.
|
|
/// </summary>
|
|
/// <param name="eventArgs"></param>
|
|
/// <returns></returns>
|
|
[Obsolete("Use the synchronous version instead, DoAfter")]
|
|
public async Task<DoAfterStatus> WaitDoAfter(DoAfterEventArgs eventArgs)
|
|
{
|
|
var doAfter = CreateDoAfter(eventArgs);
|
|
|
|
await doAfter.AsTask;
|
|
|
|
return doAfter.Status;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a DoAfter without waiting for it to finish. You can use events with this.
|
|
/// These can be potentially cancelled by the user moving or when other things happen.
|
|
/// Use this when you need to send extra data with the DoAfter
|
|
/// </summary>
|
|
/// <param name="eventArgs">The DoAfterEventArgs</param>
|
|
/// <param name="data">The extra data sent over </param>
|
|
public void DoAfter<T>(DoAfterEventArgs eventArgs, T data)
|
|
{
|
|
var doAfter = CreateDoAfter(eventArgs);
|
|
|
|
doAfter.Done = cancelled => { Send(data, cancelled, eventArgs); };
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a DoAfter without waiting for it to finish. You can use events with this.
|
|
/// These can be potentially cancelled by the user moving or when other things happen.
|
|
/// Use this if you don't have any extra data to send with the DoAfter
|
|
/// </summary>
|
|
/// <param name="eventArgs">The DoAfterEventArgs</param>
|
|
public void DoAfter(DoAfterEventArgs eventArgs)
|
|
{
|
|
var doAfter = CreateDoAfter(eventArgs);
|
|
|
|
doAfter.Done = cancelled => { Send(cancelled, eventArgs); };
|
|
}
|
|
|
|
private DoAfter CreateDoAfter(DoAfterEventArgs eventArgs)
|
|
{
|
|
// Setup
|
|
var doAfter = new DoAfter(eventArgs, EntityManager);
|
|
// Caller's gonna be responsible for this I guess
|
|
var doAfterComponent = Comp<DoAfterComponent>(eventArgs.User);
|
|
doAfter.ID = doAfterComponent.RunningIndex;
|
|
doAfter.StartTime = GameTiming.CurTime;
|
|
Add(eventArgs.User, doAfterComponent, doAfter);
|
|
return doAfter;
|
|
}
|
|
|
|
private void Run(EntityUid entity, DoAfterComponent comp, DoAfter doAfter)
|
|
{
|
|
switch (doAfter.Status)
|
|
{
|
|
case DoAfterStatus.Running:
|
|
break;
|
|
case DoAfterStatus.Cancelled:
|
|
case DoAfterStatus.Finished:
|
|
return;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
doAfter.Elapsed = GameTiming.CurTime - doAfter.StartTime;
|
|
|
|
if (IsFinished(doAfter))
|
|
{
|
|
if (!TryPostCheck(doAfter))
|
|
{
|
|
Cancel(entity, doAfter, comp);
|
|
}
|
|
else
|
|
{
|
|
doAfter.Tcs.SetResult(DoAfterStatus.Finished);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (IsCancelled(doAfter))
|
|
{
|
|
Cancel(entity, doAfter, comp);
|
|
}
|
|
}
|
|
|
|
private bool TryPostCheck(DoAfter doAfter)
|
|
{
|
|
return doAfter.EventArgs.PostCheck?.Invoke() != false;
|
|
}
|
|
|
|
private bool IsFinished(DoAfter doAfter)
|
|
{
|
|
var delay = TimeSpan.FromSeconds(doAfter.EventArgs.Delay);
|
|
|
|
if (doAfter.Elapsed <= delay)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool IsCancelled(DoAfter doAfter)
|
|
{
|
|
var eventArgs = doAfter.EventArgs;
|
|
var xForm = GetEntityQuery<TransformComponent>();
|
|
|
|
if (!Exists(eventArgs.User) || eventArgs.Target is { } target && !Exists(target))
|
|
return true;
|
|
|
|
if (eventArgs.CancelToken.IsCancellationRequested)
|
|
return true;
|
|
|
|
//TODO: Handle Inertia in space
|
|
if (eventArgs.BreakOnUserMove && !xForm.GetComponent(eventArgs.User).Coordinates
|
|
.InRange(EntityManager, doAfter.UserGrid, eventArgs.MovementThreshold))
|
|
return true;
|
|
|
|
if (eventArgs.Target != null && eventArgs.BreakOnTargetMove && !xForm.GetComponent(eventArgs.Target!.Value)
|
|
.Coordinates.InRange(EntityManager, doAfter.TargetGrid, eventArgs.MovementThreshold))
|
|
return true;
|
|
|
|
if (eventArgs.ExtraCheck != null && !eventArgs.ExtraCheck.Invoke())
|
|
return true;
|
|
|
|
if (eventArgs.BreakOnStun && HasComp<StunnedComponent>(eventArgs.User))
|
|
return true;
|
|
|
|
if (eventArgs.NeedHand)
|
|
{
|
|
if (!TryComp<SharedHandsComponent>(eventArgs.User, out var handsComp))
|
|
{
|
|
//TODO: Figure out active hand and item values
|
|
|
|
// If we had a hand but no longer have it that's still a paddlin'
|
|
if (doAfter.ActiveHand != null)
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
var currentActiveHand = handsComp.ActiveHand?.Name;
|
|
if (doAfter.ActiveHand != currentActiveHand)
|
|
return true;
|
|
|
|
var currentItem = handsComp.ActiveHandEntity;
|
|
if (doAfter.ActiveItem != currentItem)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (eventArgs.DistanceThreshold != null)
|
|
{
|
|
var userXform = xForm.GetComponent(eventArgs.User);
|
|
|
|
if (eventArgs.Target != null && !eventArgs.User.Equals(eventArgs.Target))
|
|
{
|
|
//recalculate Target location in case Target has also moved
|
|
var targetCoords = xForm.GetComponent(eventArgs.Target.Value).Coordinates;
|
|
if (!userXform.Coordinates.InRange(EntityManager, targetCoords, eventArgs.DistanceThreshold.Value))
|
|
return true;
|
|
}
|
|
|
|
if (eventArgs.Used != null)
|
|
{
|
|
var usedCoords = xForm.GetComponent(eventArgs.Used.Value).Coordinates;
|
|
if (!userXform.Coordinates.InRange(EntityManager, usedCoords, eventArgs.DistanceThreshold.Value))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void Cancel(EntityUid entity, DoAfter doAfter, DoAfterComponent? comp = null)
|
|
{
|
|
if (!Resolve(entity, ref comp, false))
|
|
return;
|
|
|
|
if (comp.CancelledDoAfters.ContainsKey(doAfter.ID))
|
|
return;
|
|
|
|
if (!comp.DoAfters.ContainsKey(doAfter.ID))
|
|
return;
|
|
|
|
doAfter.Cancelled = true;
|
|
doAfter.CancelledTime = GameTiming.CurTime;
|
|
|
|
var doAfterMessage = comp.DoAfters[doAfter.ID];
|
|
comp.CancelledDoAfters.Add(doAfter.ID, doAfterMessage);
|
|
|
|
if (doAfter.Status == DoAfterStatus.Running)
|
|
{
|
|
doAfter.Tcs.SetResult(DoAfterStatus.Cancelled);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send the DoAfter event, used where you don't need any extra data to send.
|
|
/// </summary>
|
|
/// <param name="cancelled"></param>
|
|
/// <param name="args"></param>
|
|
private void Send(bool cancelled, DoAfterEventArgs args)
|
|
{
|
|
var ev = new DoAfterEvent(cancelled, args);
|
|
|
|
RaiseDoAfterEvent(ev, args);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send the DoAfter event, used where you need extra data to send
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <param name="cancelled"></param>
|
|
/// <param name="args"></param>
|
|
/// <typeparam name="T"></typeparam>
|
|
private void Send<T>(T data, bool cancelled, DoAfterEventArgs args)
|
|
{
|
|
var ev = new DoAfterEvent<T>(data, cancelled, args);
|
|
|
|
RaiseDoAfterEvent(ev, args);
|
|
}
|
|
|
|
private void RaiseDoAfterEvent<TEvent>(TEvent ev, DoAfterEventArgs args) where TEvent : notnull
|
|
{
|
|
if (EntityManager.EntityExists(args.User) && args.RaiseOnUser)
|
|
RaiseLocalEvent(args.User, ev, args.Broadcast);
|
|
|
|
if (args.Target is { } target && EntityManager.EntityExists(target) && args.RaiseOnTarget)
|
|
RaiseLocalEvent(target, ev, args.Broadcast);
|
|
|
|
if (args.Used is { } used && EntityManager.EntityExists(used) && args.RaiseOnUsed)
|
|
RaiseLocalEvent(used, ev, args.Broadcast);
|
|
}
|
|
}
|