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

DoAfter Refactor (#13225)

Browse Source 
Co-authored-by: DrSmugleaf <drsmugleaf@gmail.com>
This commit is contained in:
keronshb
2023-02-24 19:01:25 -05:00
committed by GitHub
parent 7a9baa79c2
commit 9ebb452a3c
129 changed files with 2624 additions and 4132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
Content.Server/DoAfter/DoAfter.cs
View File

@@ -1,209 +0,0 @@
using System.Threading.Tasks;
using Content.Server.Hands.Components;
using Content.Shared.Stunnable;
using Robust.Shared.Map;
using Robust.Shared.Timing;
namespace Content.Server.DoAfter
{
public sealed class DoAfter
{
public Task<DoAfterStatus> AsTask { get; }
private TaskCompletionSource<DoAfterStatus> Tcs { get; }
public readonly DoAfterEventArgs EventArgs;
public TimeSpan StartTime { get; }
public float Elapsed { get; set; }
public EntityCoordinates UserGrid { get; }
public EntityCoordinates TargetGrid { get; }
#pragma warning disable RA0004
public DoAfterStatus Status => AsTask.IsCompletedSuccessfully ? AsTask.Result : DoAfterStatus.Running;
#pragma warning restore RA0004
// NeedHand
private readonly string? _activeHand;
private readonly EntityUid? _activeItem;
public DoAfter(DoAfterEventArgs eventArgs, IEntityManager entityManager)
{
EventArgs = eventArgs;
StartTime = IoCManager.Resolve<IGameTiming>().CurTime;
if (eventArgs.BreakOnUserMove)
{
UserGrid = entityManager.GetComponent<TransformComponent>(eventArgs.User).Coordinates;
}
if (eventArgs.Target != null && eventArgs.BreakOnTargetMove)
{
// Target should never be null if the bool is set.
TargetGrid = entityManager.GetComponent<TransformComponent>(eventArgs.Target!.Value).Coordinates;
}
// 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 (eventArgs.NeedHand && entityManager.TryGetComponent(eventArgs.User, out HandsComponent? handsComponent))
{
_activeHand = handsComponent.ActiveHand?.Name;
_activeItem = handsComponent.ActiveHandEntity;
}
Tcs = new TaskCompletionSource<DoAfterStatus>();
AsTask = Tcs.Task;
}
public void Cancel()
{
if (Status == DoAfterStatus.Running)
Tcs.SetResult(DoAfterStatus.Cancelled);
}
public void Run(float frameTime, IEntityManager entityManager)
{
switch (Status)
{
case DoAfterStatus.Running:
break;
case DoAfterStatus.Cancelled:
case DoAfterStatus.Finished:
return;
default:
throw new ArgumentOutOfRangeException();
}
Elapsed += frameTime;
if (IsFinished())
{
// Do the final checks here
if (!TryPostCheck())
{
Tcs.SetResult(DoAfterStatus.Cancelled);
}
else
{
Tcs.SetResult(DoAfterStatus.Finished);
}
return;
}
if (IsCancelled(entityManager))
{
Tcs.SetResult(DoAfterStatus.Cancelled);
}
}
private bool IsCancelled(IEntityManager entityManager)
{
if (!entityManager.EntityExists(EventArgs.User) || EventArgs.Target is {} target && !entityManager.EntityExists(target))
{
return true;
}
//https://github.com/tgstation/tgstation/blob/1aa293ea337283a0191140a878eeba319221e5df/code/__HELPERS/mobs.dm
if (EventArgs.CancelToken.IsCancellationRequested)
{
return true;
}
// TODO :Handle inertia in space.
if (EventArgs.BreakOnUserMove && !entityManager.GetComponent<TransformComponent>(EventArgs.User).Coordinates.InRange(
entityManager, UserGrid, EventArgs.MovementThreshold))
{
return true;
}
if (EventArgs.Target != null &&
EventArgs.BreakOnTargetMove &&
!entityManager.GetComponent<TransformComponent>(EventArgs.Target!.Value).Coordinates.InRange(entityManager, TargetGrid, EventArgs.MovementThreshold))
{
return true;
}
if (EventArgs.ExtraCheck != null && !EventArgs.ExtraCheck.Invoke())
{
return true;
}
if (EventArgs.BreakOnStun &&
entityManager.HasComponent<StunnedComponent>(EventArgs.User))
{
return true;
}
if (EventArgs.NeedHand)
{
if (!entityManager.TryGetComponent(EventArgs.User, out HandsComponent? handsComponent))
{
// If we had a hand but no longer have it that's still a paddlin'
if (_activeHand != null)
{
return true;
}
}
else
{
var currentActiveHand = handsComponent.ActiveHand?.Name;
if (_activeHand != currentActiveHand)
{
return true;
}
var currentItem = handsComponent.ActiveHandEntity;
if (_activeItem != currentItem)
{
return true;
}
}
}
if (EventArgs.DistanceThreshold != null)
{
var xformQuery = entityManager.GetEntityQuery<TransformComponent>();
TransformComponent? userXform = null;
// Check user distance to target AND used entities.
if (EventArgs.Target != null && !EventArgs.User.Equals(EventArgs.Target))
{
//recalculate Target location in case Target has also moved
var targetCoordinates = xformQuery.GetComponent(EventArgs.Target.Value).Coordinates;
userXform ??= xformQuery.GetComponent(EventArgs.User);
if (!userXform.Coordinates.InRange(entityManager, targetCoordinates, EventArgs.DistanceThreshold.Value))
return true;
}
if (EventArgs.Used != null)
{
var targetCoordinates = xformQuery.GetComponent(EventArgs.Used.Value).Coordinates;
userXform ??= xformQuery.GetComponent(EventArgs.User);
if (!userXform.Coordinates.InRange(entityManager, targetCoordinates, EventArgs.DistanceThreshold.Value))
return true;
}
}
return false;
}
private bool TryPostCheck()
{
return EventArgs.PostCheck?.Invoke() != false;
}
private bool IsFinished()
{
if (Elapsed <= EventArgs.Delay)
{
return false;
}
return true;
}
}
}

20
Content.Server/DoAfter/DoAfterComponent.cs
View File

@@ -1,20 +0,0 @@
using Content.Shared.DoAfter;
namespace Content.Server.DoAfter
{
[RegisterComponent, Access(typeof(DoAfterSystem))]
public sealed class DoAfterComponent : SharedDoAfterComponent
{
public readonly Dictionary<DoAfter, byte> DoAfters = new();
// So the client knows which one to update (and so we don't send all of the do_afters every time 1 updates)
// we'll just send them the index. Doesn't matter if it wraps around.
public byte RunningIndex;
}
/// <summary>
/// Added to entities that are currently performing any doafters.
/// </summary>
[RegisterComponent]
public sealed class ActiveDoAfterComponent : Component {}
}

144
Content.Server/DoAfter/DoAfterEventArgs.cs
View File

@@ -1,144 +0,0 @@
using System.Threading;
using Content.Shared.FixedPoint;
using Robust.Shared.Utility;
namespace Content.Server.DoAfter
{
public sealed class DoAfterEventArgs
{
/// <summary>
/// The entity invoking do_after
/// </summary>
public EntityUid User { get; }
/// <summary>
/// How long does the do_after require to complete
/// </summary>
public float Delay { get; }
/// <summary>
/// Applicable target (if relevant)
/// </summary>
public EntityUid? Target { get; }
/// <summary>
/// Entity used by the User on the Target.
/// </summary>
public EntityUid? Used { get; set; }
/// <summary>
/// Manually cancel the do_after so it no longer runs
/// </summary>
public CancellationToken CancelToken { get; }
// Break the chains
/// <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).
/// </summary>
public bool NeedHand { get; set; }
/// <summary>
/// If do_after stops when the user moves
/// </summary>
public bool BreakOnUserMove { get; set; }
/// <summary>
/// If do_after stops when the target moves (if there is a target)
/// </summary>
public bool BreakOnTargetMove { get; set; }
/// <summary>
/// Threshold for user and target movement
/// </summary>
public float MovementThreshold { get; set; }
public bool BreakOnDamage { get; set; }
/// <summary>
/// Threshold for user damage
/// </summary>
public FixedPoint2 DamageThreshold { get; set; }
public bool BreakOnStun { get; set; }
/// <summary>
/// Threshold for distance user from the used OR target entities.
/// </summary>
public float? DistanceThreshold { get; set; }
/// <summary>
/// Requires a function call once at the end (like InRangeUnobstructed).
/// </summary>
/// <remarks>
/// Anything that needs a pre-check should do it itself so no DoAfterState is ever sent to the client.
/// </remarks>
public Func<bool>? PostCheck { get; set; } = null;
/// <summary>
/// Additional conditions that need to be met. Return false to cancel.
/// </summary>
public Func<bool>? ExtraCheck { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="User"/> entity when the DoAfter is cancelled.
/// </summary>
public object? UserCancelledEvent { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="User"/> entity when the DoAfter is finished successfully.
/// </summary>
public object? UserFinishedEvent { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="Used"/> entity when the DoAfter is cancelled.
/// </summary>
public object? UsedCancelledEvent { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="Used"/> entity when the DoAfter is finished successfully.
/// </summary>
public object? UsedFinishedEvent { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="Target"/> entity when the DoAfter is cancelled.
/// </summary>
public object? TargetCancelledEvent { get; set; }
/// <summary>
/// Event to be raised directed to the <see cref="Target"/> entity when the DoAfter is finished successfully.
/// </summary>
public object? TargetFinishedEvent { get; set; }
/// <summary>
/// Event to be broadcast when the DoAfter is cancelled.
/// </summary>
public object? BroadcastCancelledEvent { get; set; }
/// <summary>
/// Event to be broadcast when the DoAfter is finished successfully.
/// </summary>
public object? BroadcastFinishedEvent { get; set; }
public DoAfterEventArgs(
EntityUid user,
float delay,
CancellationToken cancelToken = default,
EntityUid? target = null,
EntityUid? used = null)
{
User = user;
Delay = delay;
CancelToken = cancelToken;
Target = target;
Used = used;
MovementThreshold = 0.1f;
DamageThreshold = 1.0;
if (Target == null)
{
DebugTools.Assert(!BreakOnTargetMove);
BreakOnTargetMove = false;
}
}
}
}

224
Content.Server/DoAfter/DoAfterSystem.cs
View File

@@ -1,227 +1,11 @@
using System.Linq;
using System.Threading.Tasks;
using Content.Shared.Damage;
using Content.Shared.DoAfter;
using Content.Shared.Mobs;
using JetBrains.Annotations;
using Robust.Shared.GameStates;
namespace Content.Server.DoAfter
namespace Content.Server.DoAfter;
[UsedImplicitly]
public sealed class DoAfterSystem : SharedDoAfterSystem
{
[UsedImplicitly]
public sealed class DoAfterSystem : EntitySystem
{
// We cache these lists as to not allocate them every update tick...
private readonly Queue<DoAfter> _cancelled = new();
private readonly Queue<DoAfter> _finished = new();
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<DoAfterComponent, DamageChangedEvent>(OnDamage);
SubscribeLocalEvent<DoAfterComponent, MobStateChangedEvent>(OnStateChanged);
SubscribeLocalEvent<DoAfterComponent, ComponentGetState>(OnDoAfterGetState);
}
public void Add(DoAfterComponent component, DoAfter doAfter)
{
component.DoAfters.Add(doAfter, component.RunningIndex);
EnsureComp<ActiveDoAfterComponent>(component.Owner);
component.RunningIndex++;
Dirty(component);
}
public void Cancelled(DoAfterComponent component, DoAfter doAfter)
{
if (!component.DoAfters.TryGetValue(doAfter, out var index))
return;
component.DoAfters.Remove(doAfter);
if (component.DoAfters.Count == 0)
{
RemComp<ActiveDoAfterComponent>(component.Owner);
}
RaiseNetworkEvent(new CancelledDoAfterMessage(component.Owner, index));
}
/// <summary>
/// Call when the particular DoAfter is finished.
/// Client should be tracking this independently.
/// </summary>
public void Finished(DoAfterComponent component, DoAfter doAfter)
{
if (!component.DoAfters.ContainsKey(doAfter))
return;
component.DoAfters.Remove(doAfter);
if (component.DoAfters.Count == 0)
{
RemComp<ActiveDoAfterComponent>(component.Owner);
}
}
private void OnDoAfterGetState(EntityUid uid, DoAfterComponent component, ref ComponentGetState args)
{
var toAdd = new List<ClientDoAfter>(component.DoAfters.Count);
foreach (var (doAfter, _) in component.DoAfters)
{
// THE ALMIGHTY PYRAMID
var clientDoAfter = new ClientDoAfter(
component.DoAfters[doAfter],
doAfter.UserGrid,
doAfter.TargetGrid,
doAfter.StartTime,
doAfter.EventArgs.Delay,
doAfter.EventArgs.BreakOnUserMove,
doAfter.EventArgs.BreakOnTargetMove,
doAfter.EventArgs.MovementThreshold,
doAfter.EventArgs.DamageThreshold,
doAfter.EventArgs.Target);
toAdd.Add(clientDoAfter);
}
args.State = new DoAfterComponentState(toAdd);
}
private void OnStateChanged(EntityUid uid, DoAfterComponent component, MobStateChangedEvent args)
{
if (args.NewMobState == MobState.Alive)
return;
foreach (var (doAfter, _) in component.DoAfters)
{
doAfter.Cancel();
}
}
/// <summary>
/// Cancels DoAfter if it breaks on damage and it meets the threshold
/// </summary>
/// <param name="_">
/// The EntityUID of the user
/// </param>
/// <param name="component"></param>
/// <param name="args"></param>
public void OnDamage(EntityUid _, DoAfterComponent component, DamageChangedEvent args)
{
if (!args.InterruptsDoAfters || !args.DamageIncreased || args.DamageDelta == null)
return;
foreach (var (doAfter, _) in component.DoAfters)
{
if (doAfter.EventArgs.BreakOnDamage && args.DamageDelta?.Total.Float() > doAfter.EventArgs.DamageThreshold)
{
doAfter.Cancel();
}
}
}
public override void Update(float frameTime)
{
base.Update(frameTime);
foreach (var (_, comp) in EntityManager.EntityQuery<ActiveDoAfterComponent, DoAfterComponent>())
{
foreach (var (doAfter, _) in comp.DoAfters.ToArray())
{
doAfter.Run(frameTime, EntityManager);
switch (doAfter.Status)
{
case DoAfterStatus.Running:
break;
case DoAfterStatus.Cancelled:
_cancelled.Enqueue(doAfter);
break;
case DoAfterStatus.Finished:
_finished.Enqueue(doAfter);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
while (_cancelled.TryDequeue(out var doAfter))
{
Cancelled(comp, doAfter);
if(EntityManager.EntityExists(doAfter.EventArgs.User) && doAfter.EventArgs.UserCancelledEvent != null)
RaiseLocalEvent(doAfter.EventArgs.User, doAfter.EventArgs.UserCancelledEvent, false);
if (doAfter.EventArgs.Used is {} used && EntityManager.EntityExists(used) && doAfter.EventArgs.UsedCancelledEvent != null)
RaiseLocalEvent(used, doAfter.EventArgs.UsedCancelledEvent);
if(doAfter.EventArgs.Target is {} target && EntityManager.EntityExists(target) && doAfter.EventArgs.TargetCancelledEvent != null)
RaiseLocalEvent(target, doAfter.EventArgs.TargetCancelledEvent, false);
if(doAfter.EventArgs.BroadcastCancelledEvent != null)
RaiseLocalEvent(doAfter.EventArgs.BroadcastCancelledEvent);
}
while (_finished.TryDequeue(out var doAfter))
{
Finished(comp, doAfter);
if(EntityManager.EntityExists(doAfter.EventArgs.User) && doAfter.EventArgs.UserFinishedEvent != null)
RaiseLocalEvent(doAfter.EventArgs.User, doAfter.EventArgs.UserFinishedEvent, false);
if(doAfter.EventArgs.Used is {} used && EntityManager.EntityExists(used) && doAfter.EventArgs.UsedFinishedEvent != null)
RaiseLocalEvent(used, doAfter.EventArgs.UsedFinishedEvent);
if(doAfter.EventArgs.Target is {} target && EntityManager.EntityExists(target) && doAfter.EventArgs.TargetFinishedEvent != null)
RaiseLocalEvent(target, doAfter.EventArgs.TargetFinishedEvent, false);
if(doAfter.EventArgs.BroadcastFinishedEvent != null)
RaiseLocalEvent(doAfter.EventArgs.BroadcastFinishedEvent);
}
}
}
/// <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>
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.
/// </summary>
/// <param name="eventArgs"></param>
public void DoAfter(DoAfterEventArgs eventArgs)
{
CreateDoAfter(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);
Add(doAfterComponent, doAfter);
return doAfter;
}
}
public enum DoAfterStatus : byte
{
Running,
Cancelled,
Finished,
}
}