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

114
Content.Server/Wires/WiresSystem.cs
View File

@@ -2,7 +2,6 @@ using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using Content.Server.Administration.Logs;
using Content.Server.DoAfter;
using Content.Server.Hands.Components;
using Content.Server.Power.Components;
using Content.Shared.DoAfter;
@@ -24,15 +23,14 @@ public sealed class WiresSystem : SharedWiresSystem
{
[Dependency] private readonly IPrototypeManager _protoMan = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly DoAfterSystem _doAfter = default!;
[Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
[Dependency] private readonly SharedToolSystem _toolSystem = default!;
[Dependency] private readonly SharedPopupSystem _popupSystem = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
private IRobustRandom _random = new RobustRandom();
[Dependency] private readonly IRobustRandom _random = default!;
// This is where all the wire layouts are stored.
[ViewVariables] private readonly Dictionary<string, WireLayout> _layouts = new();
@@ -48,15 +46,14 @@ public sealed class WiresSystem : SharedWiresSystem
SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
// this is a broadcast event
SubscribeLocalEvent<WireToolFinishedEvent>(OnToolFinished);
SubscribeLocalEvent<WireToolCanceledEvent>(OnToolCanceled);
SubscribeLocalEvent<WiresPanelComponent, WirePanelDoAfterEvent>(OnPanelDoAfter);
SubscribeLocalEvent<WiresComponent, ComponentStartup>(OnWiresStartup);
SubscribeLocalEvent<WiresComponent, WiresActionMessage>(OnWiresActionMessage);
SubscribeLocalEvent<WiresComponent, InteractUsingEvent>(OnInteractUsing);
SubscribeLocalEvent<WiresComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<WiresComponent, TimedWireEvent>(OnTimedWire);
SubscribeLocalEvent<WiresComponent, PowerChangedEvent>(OnWiresPowered);
SubscribeLocalEvent<WiresComponent, DoAfterEvent<WireExtraData>>(OnDoAfter);
SubscribeLocalEvent<WiresComponent, WireDoAfterEvent>(OnDoAfter);
}
private void SetOrCreateWireLayout(EntityUid uid, WiresComponent? wires = null)
@@ -437,84 +434,62 @@ public sealed class WiresSystem : SharedWiresSystem
TryDoWireAction(uid, player, activeHandEntity, args.Id, args.Action, component, tool);
}
private void OnDoAfter(EntityUid uid, WiresComponent component, DoAfterEvent<WireExtraData> args)
private void OnDoAfter(EntityUid uid, WiresComponent component, WireDoAfterEvent args)
{
if (args.Cancelled)
{
component.WiresQueue.Remove(args.AdditionalData.Id);
component.WiresQueue.Remove(args.Id);
return;
}
if (args.Handled || args.Args.Target == null || args.Args.Used == null)
return;
UpdateWires(args.Args.Target.Value, args.Args.User, args.Args.Used.Value, args.AdditionalData.Id, args.AdditionalData.Action, component);
UpdateWires(args.Args.Target.Value, args.Args.User, args.Args.Used.Value, args.Id, args.Action, component);
args.Handled = true;
}
private void OnInteractUsing(EntityUid uid, WiresComponent component, InteractUsingEvent args)
{
if (args.Handled)
return;
if (!TryComp<ToolComponent>(args.Used, out var tool) || !TryComp<WiresPanelComponent>(uid, out var panel))
return;
if (panel.Open &&
(_toolSystem.HasQuality(args.Used, "Cutting", tool) ||
_toolSystem.HasQuality(args.Used, "Pulsing", tool)))
{
if (EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
{
var ui = _uiSystem.GetUiOrNull(uid, WiresUiKey.Key);
if (ui != null)
_uiSystem.OpenUi(ui, actor.PlayerSession);
args.Handled = true;
}
if (TryComp(args.User, out ActorComponent? actor))
_uiSystem.TryOpen(uid, WiresUiKey.Key, actor.PlayerSession);
}
else if (!panel.IsScrewing && _toolSystem.HasQuality(args.Used, "Screwing", tool))
else if (_toolSystem.UseTool(args.Used, args.User, uid, ScrewTime, "Screwing", new WirePanelDoAfterEvent(), toolComponent: tool))
{
var toolEvData = new ToolEventData(new WireToolFinishedEvent(uid, args.User), cancelledEv: new WireToolCanceledEvent(uid));
panel.IsScrewing = _toolSystem.UseTool(args.Used, args.User, uid, ScrewTime, new[] { "Screwing" }, toolEvData, toolComponent: tool);
args.Handled = panel.IsScrewing;
// Log attempt
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(args.User):user} is screwing {ToPrettyString(uid):target}'s {(panel.Open ? "open" : "closed")} maintenance panel at {Transform(uid).Coordinates:targetlocation}");
_adminLogger.Add(LogType.Action, LogImpact.Low,
$"{ToPrettyString(args.User):user} is screwing {ToPrettyString(uid):target}'s {(panel.Open ? "open" : "closed")} maintenance panel at {Transform(uid).Coordinates:targetlocation}");
}
}
private void OnToolFinished(WireToolFinishedEvent args)
private void OnPanelDoAfter(EntityUid uid, WiresPanelComponent panel, WirePanelDoAfterEvent args)
{
if (!TryComp<WiresPanelComponent>((args.Target), out var panel))
if (args.Cancelled)
return;
panel.IsScrewing = false;
TogglePanel(args.Target, panel, !panel.Open);
// Log success
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(args.User):user} screwed {ToPrettyString(args.Target):target}'s maintenance panel {(panel.Open ? "open" : "closed")}");
TogglePanel(uid, panel, !panel.Open);
UpdateAppearance(uid, panel);
_adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(args.User):user} screwed {ToPrettyString(uid):target}'s maintenance panel {(panel.Open ? "open" : "closed")}");
if (panel.Open)
{
_audio.PlayPvs(panel.ScrewdriverOpenSound, args.Target);
_audio.PlayPvs(panel.ScrewdriverOpenSound, uid);
}
else
{
_audio.PlayPvs(panel.ScrewdriverCloseSound, args.Target);
var ui = _uiSystem.GetUiOrNull(args.Target, WiresUiKey.Key);
if (ui != null)
{
_uiSystem.CloseAll(ui);
}
_audio.PlayPvs(panel.ScrewdriverCloseSound, uid);
_uiSystem.TryCloseAll(uid, WiresUiKey.Key);
}
Dirty(panel);
}
private void OnToolCanceled(WireToolCanceledEvent ev)
{
if (!TryComp<WiresPanelComponent>(ev.Target, out var component))
return;
component.IsScrewing = false;
}
private void OnMapInit(EntityUid uid, WiresComponent component, MapInitEvent args)
@@ -662,16 +637,16 @@ public sealed class WiresSystem : SharedWiresSystem
_appearance.SetData(uid, WiresVisuals.MaintenancePanelState, panel.Open && panel.Visible, appearance);
}
private void TryDoWireAction(EntityUid used, EntityUid user, EntityUid toolEntity, int id, WiresAction action, WiresComponent? wires = null, ToolComponent? tool = null)
private void TryDoWireAction(EntityUid target, EntityUid user, EntityUid toolEntity, int id, WiresAction action, WiresComponent? wires = null, ToolComponent? tool = null)
{
if (!Resolve(used, ref wires)
if (!Resolve(target, ref wires)
|| !Resolve(toolEntity, ref tool))
return;
if (wires.WiresQueue.Contains(id))
return;
var wire = TryGetWire(used, id, wires);
var wire = TryGetWire(target, id, wires);
if (wire == null)
return;
@@ -726,29 +701,21 @@ public sealed class WiresSystem : SharedWiresSystem
if (_toolTime > 0f)
{
var data = new WireExtraData(action, id);
var args = new DoAfterEventArgs(user, _toolTime, target: used, used: toolEntity)
var args = new DoAfterArgs(user, _toolTime, new WireDoAfterEvent(action, id), target, target: target, used: toolEntity)
{
NeedHand = true,
BreakOnStun = true,
BreakOnDamage = true,
BreakOnUserMove = true
};
_doAfter.DoAfter(args, data);
_doAfter.TryStartDoAfter(args);
}
else
{
UpdateWires(used, user, toolEntity, id, action, wires);
UpdateWires(target, user, toolEntity, id, action, wires);
}
}
private record struct WireExtraData(WiresAction Action, int Id)
{
public WiresAction Action = Action;
public int Id = Id;
}
private void UpdateWires(EntityUid used, EntityUid user, EntityUid toolEntity, int id, WiresAction action, WiresComponent? wires = null, ToolComponent? tool = null)
{
if (!Resolve(used, ref wires))
@@ -786,7 +753,7 @@ public sealed class WiresSystem : SharedWiresSystem
break;
}
_toolSystem.PlayToolSound(toolEntity, tool);
_toolSystem.PlayToolSound(toolEntity, tool, user);
if (wire.Action == null || wire.Action.Cut(user, wire))
{
wire.IsCut = true;
@@ -807,7 +774,7 @@ public sealed class WiresSystem : SharedWiresSystem
break;
}
_toolSystem.PlayToolSound(toolEntity, tool);
_toolSystem.PlayToolSound(toolEntity, tool, user);
if (wire.Action == null || wire.Action.Mend(user, wire))
{
wire.IsCut = false;
@@ -921,25 +888,8 @@ public sealed class WiresSystem : SharedWiresSystem
private void Reset(RoundRestartCleanupEvent args)
{
_layouts.Clear();
_random = new RobustRandom();
}
#endregion
#region Events
private sealed class WireToolFinishedEvent : EntityEventArgs
{
public EntityUid User { get; }
public EntityUid Target { get; }
public WireToolFinishedEvent(EntityUid target, EntityUid user)
{
Target = target;
User = user;
}
}
public record struct WireToolCanceledEvent(EntityUid Target);
#endregion
}
public sealed class Wire