Universal weldable component (#7955)

* Weldable component for door

* Content update

* Examine message

* Universal visualizer

* Small fix

* Entity storage

* Content

* Fixed test

* Update Content.Shared/Storage/SharedStorageComponent.cs

Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>

* Fixed loc string

* Add public API to change welding time

Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>

Content.Server/Tools/Systems/WeldableSystem.cs

@@ -0,0 +1,159 @@
+using Content.Server.Tools.Components;
+using Content.Shared.Examine;
+using Content.Shared.Interaction;
+using Content.Shared.Tools.Components;
+
+namespace Content.Server.Tools.Systems;
+
+public sealed class WeldableSystem : EntitySystem
+{
+    [Dependency] private readonly ToolSystem _toolSystem = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<WeldableComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<WeldableComponent, WeldFinishedEvent>(OnWeldFinished);
+        SubscribeLocalEvent<WeldableComponent, WeldCancelledEvent>(OnWeldCanceled);
+        SubscribeLocalEvent<WeldableComponent, ExaminedEvent>(OnExamine);
+    }
+
+    private void OnExamine(EntityUid uid, WeldableComponent component, ExaminedEvent args)
+    {
+        if (component.IsWelded && component.WeldedExamineMessage != null)
+            args.PushText(Loc.GetString(component.WeldedExamineMessage));
+    }
+
+    private void OnInteractUsing(EntityUid uid, WeldableComponent component, InteractUsingEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        args.Handled = TryWeld(uid, args.Used, args.User, component);
+    }
+
+    private bool CanWeld(EntityUid uid, EntityUid tool, EntityUid user, WeldableComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return false;
+
+        // Basic checks
+        if (!component.Weldable || component.BeingWelded)
+            return false;
+        if (!_toolSystem.HasQuality(tool, component.WeldingQuality))
+            return false;
+
+        // Other component systems
+        var attempt = new WeldableAttemptEvent(user, tool);
+        RaiseLocalEvent(uid, attempt);
+        if (attempt.Cancelled)
+            return false;
+
+        return true;
+    }
+
+    private bool TryWeld(EntityUid uid, EntityUid tool, EntityUid user, WeldableComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return false;
+
+        if (!CanWeld(uid, tool, user, component))
+            return false;
+
+        component.BeingWelded = true;
+        _toolSystem.UseTool(tool, user, uid, component.FuelConsumption,
+            component.WeldingTime.Seconds, component.WeldingQuality,
+            new WeldFinishedEvent(user, tool), new WeldCancelledEvent(), uid);
+
+        return true;
+    }
+
+    private void OnWeldFinished(EntityUid uid, WeldableComponent component, WeldFinishedEvent args)
+    {
+        component.BeingWelded = false;
+
+        // Check if target is still valid
+        if (!CanWeld(uid, args.Tool, args.User, component))
+            return;
+
+        component.IsWelded = !component.IsWelded;
+        RaiseLocalEvent(uid, new WeldableChangedEvent(component.IsWelded));
+
+        UpdateAppearance(uid, component);
+    }
+
+    private void OnWeldCanceled(EntityUid uid, WeldableComponent component, WeldCancelledEvent args)
+    {
+        component.BeingWelded = false;
+    }
+
+    private void UpdateAppearance(EntityUid uid, WeldableComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return;
+
+        if (!TryComp(uid, out AppearanceComponent? appearance))
+            return;
+        appearance.SetData(WeldableVisuals.IsWelded, component.IsWelded);
+    }
+
+    public void SetWeldingTime(EntityUid uid, TimeSpan time, WeldableComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return;
+        component.WeldingTime = time;
+    }
+
+    /// <summary>
+    ///     Raised after welding do_after has finished. It doesn't guarantee success,
+    ///     use <see cref="WeldableChangedEvent"/> to get updated status.
+    /// </summary>
+    private sealed class WeldFinishedEvent : EntityEventArgs
+    {
+        public readonly EntityUid User;
+        public readonly EntityUid Tool;
+
+        public WeldFinishedEvent(EntityUid user, EntityUid tool)
+        {
+            User = user;
+            Tool = tool;
+        }
+    }
+
+    /// <summary>
+    ///     Raised when entity welding has failed.
+    /// </summary>
+    private sealed class WeldCancelledEvent : EntityEventArgs
+    {
+
+    }
+}
+
+/// <summary>
+///     Checks that entity can be weld/unweld.
+///     Raised twice: before do_after and after to check that entity still valid.
+/// </summary>
+public sealed class WeldableAttemptEvent : CancellableEntityEventArgs
+{
+    public readonly EntityUid User;
+    public readonly EntityUid Tool;
+
+    public WeldableAttemptEvent(EntityUid user, EntityUid tool)
+    {
+        User = user;
+        Tool = tool;
+    }
+}
+
+/// <summary>
+///     Raised when <see cref="WeldableComponent.IsWelded"/> has changed.
+/// </summary>
+public sealed class WeldableChangedEvent : EntityEventArgs
+{
+    public readonly bool IsWelded;
+
+    public WeldableChangedEvent(bool isWelded)
+    {
+        IsWelded = isWelded;
+    }
+}