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

More DoAfter Changes (#14609)

Browse Source 
* DoAfters

* Compact Clone()

* Fix mice and cuffables

* Try generalize attempt events

* moves climbabledoafter event to shared, fixes issue with climbable target

* Fix merge (cuffing)

* Make all events netserializable

* handful of doafter events moved

* moves the rest of the events to their respective shared folders

* Changes all mentions of server doafter to shared

* stop stripping cancellation

* fix merge errors

* draw paused doafters

* handle unpausing

* missing netserializable ref

* removes break on stun reference

* removes cuffing state reference

* Fix tools

* Fix door prying.

* Fix construction

* Fix dumping

* Fix wielding assert

* fix rev

* Fix test

* more test fixes

---------

Co-authored-by: keronshb <keronshb@live.com>
This commit is contained in:
Leon Friedrich
2023-04-03 13:13:48 +12:00
committed by GitHub
parent 9e66fac805
commit 19277a2276
170 changed files with 3042 additions and 2954 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
Content.Client/DoAfter/DoAfterOverlay.cs
View File

@@ -3,6 +3,7 @@ using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Shared.Enums;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Client.DoAfter;
@@ -10,17 +11,30 @@ namespace Content.Client.DoAfter;
public sealed class DoAfterOverlay : Overlay
{
private readonly IEntityManager _entManager;
private readonly IGameTiming _timing;
private readonly SharedTransformSystem _transform;
private readonly MetaDataSystem _meta;
private readonly Texture _barTexture;
private readonly ShaderInstance _shader;
/// <summary>
/// Flash time for cancelled DoAfters
/// </summary>
private const float FlashTime = 0.125f;
// Hardcoded width of the progress bar because it doesn't match the texture.
private const float StartX = 2;
private const float EndX = 22f;
public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
public DoAfterOverlay(IEntityManager entManager, IPrototypeManager protoManager)
public DoAfterOverlay(IEntityManager entManager, IPrototypeManager protoManager, IGameTiming timing)
{
_entManager = entManager;
_timing = timing;
_transform = _entManager.EntitySysManager.GetEntitySystem<SharedTransformSystem>();
_meta = _entManager.EntitySysManager.GetEntitySystem<MetaDataSystem>();
var sprite = new SpriteSpecifier.Rsi(new ResourcePath("/Textures/Interface/Misc/progress_bar.rsi"), "icon");
_barTexture = _entManager.EntitySysManager.GetEntitySystem<SpriteSystem>().Frame0(sprite);
@@ -31,7 +45,6 @@ public sealed class DoAfterOverlay : Overlay
{
var handle = args.WorldHandle;
var rotation = args.Viewport.Eye?.Rotation ?? Angle.Zero;
var spriteQuery = _entManager.GetEntityQuery<SpriteComponent>();
var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
// If you use the display UI scale then need to set max(1f, displayscale) because 0 is valid.
@@ -40,43 +53,42 @@ public sealed class DoAfterOverlay : Overlay
var rotationMatrix = Matrix3.CreateRotation(-rotation);
handle.UseShader(_shader);
// TODO: Need active DoAfter component (or alternatively just make DoAfter itself active)
foreach (var comp in _entManager.EntityQuery<DoAfterComponent>(true))
{
if (comp.DoAfters.Count == 0 ||
!xformQuery.TryGetComponent(comp.Owner, out var xform) ||
xform.MapID != args.MapId)
{
continue;
}
var curTime = _timing.CurTime;
var bounds = args.WorldAABB.Enlarged(5f);
var metaQuery = _entManager.GetEntityQuery<MetaDataComponent>();
var enumerator = _entManager.AllEntityQueryEnumerator<ActiveDoAfterComponent, DoAfterComponent, SpriteComponent, TransformComponent>();
while (enumerator.MoveNext(out var uid, out _, out var comp, out var sprite, out var xform))
{
if (xform.MapID != args.MapId)
continue;
if (comp.DoAfters.Count == 0)
continue;
var worldPosition = _transform.GetWorldPosition(xform, xformQuery);
if (!bounds.Contains(worldPosition))
continue;
// If the entity is paused, we will draw the do-after as it was when the entity got paused.
var meta = metaQuery.GetComponent(uid);
var time = meta.EntityPaused
? curTime - _meta.GetPauseTime(uid, meta)
: curTime;
var worldPosition = _transform.GetWorldPosition(xform);
var index = 0;
var worldMatrix = Matrix3.CreateTranslation(worldPosition);
Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
handle.SetTransform(matty);
var offset = 0f;
foreach (var doAfter in comp.DoAfters.Values)
{
var elapsed = doAfter.Elapsed;
var displayRatio = MathF.Min(1.0f,
(float)elapsed.TotalSeconds / doAfter.Delay);
Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
handle.SetTransform(matty);
var offset = _barTexture.Height / scale * index;
// Use the sprite itself if we know its bounds. This means short or tall sprites don't get overlapped
// by the bar.
float yOffset;
if (spriteQuery.TryGetComponent(comp.Owner, out var sprite))
{
yOffset = sprite.Bounds.Height / 2f + 0.05f;
}
else
{
yOffset = 0.5f;
}
float yOffset = sprite.Bounds.Height / 2f + 0.05f;
// Position above the entity (we've already applied the matrix transform to the entity itself)
// Offset by the texture size for every do_after we have.
@@ -86,33 +98,30 @@ public sealed class DoAfterOverlay : Overlay
// Draw the underlying bar texture
handle.DrawTexture(_barTexture, position);
// Draw the bar itself
var cancelled = doAfter.Cancelled;
Color color;
const float flashTime = 0.125f;
float elapsedRatio;
// if we're cancelled then flick red / off.
if (cancelled)
if (doAfter.CancelledTime != null)
{
var flash = Math.Floor((float)doAfter.CancelledElapsed.TotalSeconds / flashTime) % 2 == 0;
var elapsed = doAfter.CancelledTime.Value - doAfter.StartTime;
elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
var cancelElapsed = (time - doAfter.CancelledTime.Value).TotalSeconds;
var flash = Math.Floor(cancelElapsed / FlashTime) % 2 == 0;
color = new Color(1f, 0f, 0f, flash ? 1f : 0f);
}
else
{
color = GetProgressColor(displayRatio);
var elapsed = time - doAfter.StartTime;
elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
color = GetProgressColor(elapsedRatio);
}
// Hardcoded width of the progress bar because it doesn't match the texture.
const float startX = 2f;
const float endX = 22f;
var xProgress = (endX - startX) * displayRatio + startX;
var box = new Box2(new Vector2(startX, 3f) / EyeManager.PixelsPerMeter, new Vector2(xProgress, 4f) / EyeManager.PixelsPerMeter);
var xProgress = (EndX - StartX) * elapsedRatio + StartX;
var box = new Box2(new Vector2(StartX, 3f) / EyeManager.PixelsPerMeter, new Vector2(xProgress, 4f) / EyeManager.PixelsPerMeter);
box = box.Translated(position);
handle.DrawRect(box, color);
index++;
offset += _barTexture.Height / scale;
}
}

163
Content.Client/DoAfter/DoAfterSystem.cs
View File

@@ -1,9 +1,8 @@
using Content.Shared.DoAfter;
using Content.Shared.Hands.Components;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Shared.GameStates;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
namespace Content.Client.DoAfter;
@@ -16,19 +15,12 @@ public sealed class DoAfterSystem : SharedDoAfterSystem
[Dependency] private readonly IOverlayManager _overlay = default!;
[Dependency] private readonly IPlayerManager _player = default!;
[Dependency] private readonly IPrototypeManager _prototype = default!;
/// <summary>
/// We'll use an excess time so stuff like finishing effects can show.
/// </summary>
public const float ExcessTime = 0.5f;
[Dependency] private readonly MetaDataSystem _metadata = default!;
public override void Initialize()
{
base.Initialize();
UpdatesOutsidePrediction = true;
SubscribeNetworkEvent<CancelledDoAfterMessage>(OnCancelledDoAfter);
SubscribeLocalEvent<DoAfterComponent, ComponentHandleState>(OnDoAfterHandleState);
_overlay.AddOverlay(new DoAfterOverlay(EntityManager, _prototype));
_overlay.AddOverlay(new DoAfterOverlay(EntityManager, _prototype, GameTiming));
}
public override void Shutdown()
@@ -37,147 +29,26 @@ public sealed class DoAfterSystem : SharedDoAfterSystem
_overlay.RemoveOverlay<DoAfterOverlay>();
}
private void OnDoAfterHandleState(EntityUid uid, DoAfterComponent component, ref ComponentHandleState args)
{
if (args.Current is not DoAfterComponentState state)
return;
foreach (var (_, doAfter) in state.DoAfters)
{
if (component.DoAfters.ContainsKey(doAfter.ID))
continue;
component.DoAfters.Add(doAfter.ID, doAfter);
}
}
private void OnCancelledDoAfter(CancelledDoAfterMessage ev)
{
if (!TryComp<DoAfterComponent>(ev.Uid, out var doAfter))
return;
Cancel(doAfter, ev.ID);
}
/// <summary>
/// Remove a DoAfter without showing a cancellation graphic.
/// </summary>
public void Remove(DoAfterComponent component, Shared.DoAfter.DoAfter doAfter, bool found = false)
{
component.DoAfters.Remove(doAfter.ID);
component.CancelledDoAfters.Remove(doAfter.ID);
}
/// <summary>
/// Mark a DoAfter as cancelled and show a cancellation graphic.
/// </summary>
/// Actual removal is handled by DoAfterEntitySystem.
public void Cancel(DoAfterComponent component, byte id)
{
if (component.CancelledDoAfters.ContainsKey(id))
return;
if (!component.DoAfters.ContainsKey(id))
return;
var doAfterMessage = component.DoAfters[id];
doAfterMessage.Cancelled = true;
doAfterMessage.CancelledTime = GameTiming.CurTime;
component.CancelledDoAfters.Add(id, doAfterMessage);
}
// TODO separate DoAfter & ActiveDoAfter components for the entity query.
public override void Update(float frameTime)
{
if (!GameTiming.IsFirstTimePredicted)
return;
// Currently this only predicts do afters initiated by the player.
// TODO maybe predict do-afters if the local player is the target of some other players do-after? Specifically
// ones that depend on the target not moving, because the cancellation of those do afters should be readily
// predictable by clients.
var playerEntity = _player.LocalPlayer?.ControlledEntity;
foreach (var (comp, xform) in EntityQuery<DoAfterComponent, TransformComponent>())
{
var doAfters = comp.DoAfters;
if (!TryComp(playerEntity, out ActiveDoAfterComponent? active))
return;
if (doAfters.Count == 0)
continue;
if (_metadata.EntityPaused(playerEntity.Value))
return;
var userGrid = xform.Coordinates;
var toRemove = new RemQueue<Shared.DoAfter.DoAfter>();
// Check cancellations / finishes
foreach (var (id, doAfter) in doAfters)
{
// If we've passed the final time (after the excess to show completion graphic) then remove.
if ((float)doAfter.Elapsed.TotalSeconds + (float)doAfter.CancelledElapsed.TotalSeconds >
doAfter.Delay + ExcessTime)
{
toRemove.Add(doAfter);
continue;
}
if (doAfter.Cancelled)
{
doAfter.CancelledElapsed = GameTiming.CurTime - doAfter.CancelledTime;
continue;
}
doAfter.Elapsed = GameTiming.CurTime - doAfter.StartTime;
// Well we finished so don't try to predict cancels.
if ((float)doAfter.Elapsed.TotalSeconds > doAfter.Delay)
continue;
// Predictions
if (comp.Owner != playerEntity)
continue;
// TODO: Add these back in when I work out some system for changing the accumulation rate
// based on ping. Right now these would show as cancelled near completion if we moved at the end
// despite succeeding.
continue;
if (doAfter.EventArgs.BreakOnUserMove)
{
if (!userGrid.InRange(EntityManager, doAfter.UserGrid, doAfter.EventArgs.MovementThreshold))
{
Cancel(comp, id);
continue;
}
}
if (doAfter.EventArgs.BreakOnTargetMove)
{
if (!Deleted(doAfter.EventArgs.Target) &&
!Transform(doAfter.EventArgs.Target.Value).Coordinates.InRange(EntityManager,
doAfter.TargetGrid,
doAfter.EventArgs.MovementThreshold))
{
Cancel(comp, id);
continue;
}
}
}
foreach (var doAfter in toRemove)
{
Remove(comp, doAfter);
}
// Remove cancelled DoAfters after ExcessTime has elapsed
var toRemoveCancelled = new RemQueue<Shared.DoAfter.DoAfter>();
foreach (var (_, doAfter) in comp.CancelledDoAfters)
{
var cancelledElapsed = (float)doAfter.CancelledElapsed.TotalSeconds;
if (cancelledElapsed > ExcessTime)
toRemoveCancelled.Add(doAfter);
}
foreach (var doAfter in toRemoveCancelled)
{
Remove(comp, doAfter);
}
}
var time = GameTiming.CurTime;
var comp = Comp<DoAfterComponent>(playerEntity.Value);
var xformQuery = GetEntityQuery<TransformComponent>();
var handsQuery = GetEntityQuery<SharedHandsComponent>();
Update(playerEntity.Value, active, comp, time, xformQuery, handsQuery);
}
}