Makes tools and welders ECS, add ToolQualityPrototype. (#4741)

Content.Server/Tools/ToolSystem.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.DoAfter;
+using Content.Server.Popups;
+using Content.Server.Tools.Components;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Audio;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Tools;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Tools
+{
+    public partial class ToolSystem : EntitySystem
+    {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
+        [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
+        [Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
+        [Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
+        [Dependency] private readonly PopupSystem _popupSystem = default!;
+
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            InitializeWelders();
+            InitializeMultipleTools();
+        }
+
+        public async Task<bool> UseTool(EntityUid tool, EntityUid user, EntityUid? target, float fuel,
+            float doAfterDelay, IEnumerable<string> toolQualitiesNeeded, Func<bool>? doAfterCheck = null,
+            ToolComponent? toolComponent = null)
+        {
+            if (!Resolve(tool, ref toolComponent))
+                return false;
+
+            if (!toolComponent.Qualities.ContainsAll(toolQualitiesNeeded) || !_actionBlockerSystem.CanInteract(user))
+                return false;
+
+            var beforeAttempt = new ToolUseAttemptEvent(fuel, user);
+            RaiseLocalEvent(tool, beforeAttempt, false);
+
+            if (beforeAttempt.Cancelled)
+                return false;
+
+            if (doAfterDelay > 0f)
+            {
+                var doAfterArgs = new DoAfterEventArgs(user, doAfterDelay / toolComponent.SpeedModifier, default, target)
+                {
+                    ExtraCheck = doAfterCheck,
+                    BreakOnDamage = true,
+                    BreakOnStun = true,
+                    BreakOnTargetMove = true,
+                    BreakOnUserMove = true,
+                    NeedHand = true,
+                };
+
+                var result = await _doAfterSystem.WaitDoAfter(doAfterArgs);
+
+                if (result == DoAfterStatus.Cancelled)
+                    return false;
+            }
+
+            var afterAttempt = new ToolUseFinishAttemptEvent(fuel, user);
+            RaiseLocalEvent(tool, afterAttempt, false);
+
+            if (afterAttempt.Cancelled)
+                return false;
+
+            if (toolComponent.UseSound != null)
+                PlayToolSound(tool, toolComponent);
+
+            return true;
+        }
+
+        public Task<bool> UseTool(EntityUid tool, EntityUid user, EntityUid? target, float fuel,
+            float doAfterDelay, string toolQualityNeeded, Func<bool>? doAfterCheck = null,
+            ToolComponent? toolComponent = null)
+        {
+            return UseTool(tool, user, target, fuel, doAfterDelay, new [] {toolQualityNeeded}, doAfterCheck, toolComponent);
+        }
+
+        public void PlayToolSound(EntityUid uid, ToolComponent? tool = null)
+        {
+            if (!Resolve(uid, ref tool))
+                return;
+
+            if (tool.UseSound is not {} sound)
+                return;
+
+            // Pass tool.Owner to Filter.Pvs to avoid a TryGetEntity call.
+            SoundSystem.Play(Filter.Pvs(tool.Owner), sound.GetSound(), uid,
+                AudioHelpers.WithVariation(0.175f).WithVolume(-5f));
+        }
+
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            UpdateWelders(frameTime);
+        }
+    }
+
+    /// <summary>
+    ///     Attempt event called *before* any do afters to see if the tool usage should succeed or not.
+    ///     You can change the fuel consumption by changing the Fuel property.
+    /// </summary>
+    public class ToolUseAttemptEvent : CancellableEntityEventArgs
+    {
+        public float Fuel { get; set; }
+        public EntityUid User { get; }
+
+        public ToolUseAttemptEvent(float fuel, EntityUid user)
+        {
+            Fuel = fuel;
+            User = user;
+        }
+    }
+
+    /// <summary>
+    ///     Attempt event called *after* any do afters to see if the tool usage should succeed or not.
+    ///     You can use this event to consume any fuel needed.
+    /// </summary>
+    public class ToolUseFinishAttemptEvent : CancellableEntityEventArgs
+    {
+        public float Fuel { get; }
+        public EntityUid User { get; }
+
+        public ToolUseFinishAttemptEvent(float fuel, EntityUid user)
+        {
+            Fuel = fuel;
+        }
+    }
+}