Re-organize all projects (#4166)

Content.Server/Tools/Components/MultitoolComponent.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using Content.Shared.Interaction;
+using Content.Shared.NetIDs;
+using Content.Shared.Tool;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Players;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Server.Tools.Components
+{
+    /// <summary>
+    ///     Not to be confused with Multitool (power)
+    /// </summary>
+    [RegisterComponent]
+    public class MultiToolComponent : Component, IUse
+    {
+        [DataDefinition]
+        public class ToolEntry
+        {
+            [DataField("behavior")] public ToolQuality Behavior { get; private set; } = ToolQuality.None;
+
+            [DataField("state")]
+            public string State { get; } = string.Empty;
+
+            [DataField("texture")]
+            public string Texture { get; } = string.Empty;
+
+            [DataField("sprite")]
+            public string Sprite { get; } = string.Empty;
+
+            [DataField("useSound")]
+            public string Sound { get; } = string.Empty;
+
+            [DataField("useSoundCollection")]
+            public string SoundCollection { get; } = string.Empty;
+
+            [DataField("changeSound")]
+            public string ChangeSound { get; } = string.Empty;
+        }
+
+        public override string Name => "MultiTool";
+        public override uint? NetID => ContentNetIDs.MULTITOOLS;
+        [DataField("tools")] private List<ToolEntry> _tools = new();
+        private int _currentTool = 0;
+
+        private ToolComponent? _tool;
+        private SpriteComponent? _sprite;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            Owner.TryGetComponent(out _tool);
+            Owner.TryGetComponent(out _sprite);
+            SetTool();
+        }
+
+        public void Cycle()
+        {
+            _currentTool = (_currentTool + 1) % _tools.Count;
+            SetTool();
+            var current = _tools[_currentTool];
+            if(!string.IsNullOrEmpty(current.ChangeSound))
+                SoundSystem.Play(Filter.Pvs(Owner), current.ChangeSound, Owner);
+        }
+
+        private void SetTool()
+        {
+            if (_tool == null) return;
+
+            var current = _tools[_currentTool];
+
+            _tool.UseSound = current.Sound;
+            _tool.UseSoundCollection = current.SoundCollection;
+            _tool.Qualities = current.Behavior;
+
+            if (_sprite == null) return;
+
+            if (string.IsNullOrEmpty(current.Texture))
+                if (!string.IsNullOrEmpty(current.Sprite))
+                    _sprite.LayerSetState(0, current.State, current.Sprite);
+                else
+                    _sprite.LayerSetState(0, current.State);
+            else
+                _sprite.LayerSetTexture(0, current.Texture);
+
+            Dirty();
+        }
+
+        bool IUse.UseEntity(UseEntityEventArgs eventArgs)
+        {
+            Cycle();
+            return true;
+        }
+
+        public override ComponentState GetComponentState(ICommonSession player)
+        {
+            return new MultiToolComponentState(_tool?.Qualities ?? ToolQuality.None);
+        }
+    }
+}

Content.Server/Tools/Components/TilePryingComponent.cs

@@ -0,0 +1,54 @@
+using System.Threading.Tasks;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Helpers;
+using Content.Shared.Maps;
+using Content.Shared.Tool;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Server.Tools.Components
+{
+    [RegisterComponent]
+    public class TilePryingComponent : Component, IAfterInteract
+    {
+        [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
+
+        public override string Name => "TilePrying";
+        [DataField("toolComponentNeeded")]
+        private bool _toolComponentNeeded = true;
+
+        async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
+        {
+            TryPryTile(eventArgs.User, eventArgs.ClickLocation);
+            return true;
+        }
+
+        public async void TryPryTile(IEntity user, EntityCoordinates clickLocation)
+        {
+            if (!Owner.TryGetComponent<ToolComponent>(out var tool) && _toolComponentNeeded)
+                return;
+
+            if (!_mapManager.TryGetGrid(clickLocation.GetGridId(Owner.EntityManager), out var mapGrid))
+                return;
+
+            var tile = mapGrid.GetTileRef(clickLocation);
+
+            var coordinates = mapGrid.GridTileToLocal(tile.GridIndices);
+
+            if (!user.InRangeUnobstructed(coordinates, popup: false))
+                return;
+
+            var tileDef = (ContentTileDefinition)_tileDefinitionManager[tile.Tile.TypeId];
+
+            if (!tileDef.CanCrowbar) return;
+
+            if (_toolComponentNeeded && !await tool!.UseTool(user, null, 0f,  ToolQuality.Prying))
+                return;
+
+            coordinates.PryTile(Owner.EntityManager, _mapManager);
+        }
+    }
+}

Content.Server/Tools/Components/ToolComponent.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Threading.Tasks;
+using Content.Server.DoAfter;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Audio;
+using Content.Shared.Tool;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Tools.Components
+{
+    public interface IToolComponent
+    {
+        ToolQuality Qualities { get; set; }
+    }
+
+    [RegisterComponent]
+    [ComponentReference(typeof(IToolComponent))]
+    public class ToolComponent : SharedToolComponent, IToolComponent
+    {
+        [DataField("qualities")]
+        protected ToolQuality _qualities = ToolQuality.None;
+
+        [ViewVariables]
+        public override ToolQuality Qualities
+        {
+            get => _qualities;
+            set
+            {
+                _qualities = value;
+                Dirty();
+            }
+        }
+
+        /// <summary>
+        ///     For tool interactions that have a delay before action this will modify the rate, time to wait is divided by this value
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("speed")]
+        public float SpeedModifier { get; set; } = 1;
+
+        [DataField("useSound")]
+        public string? UseSound { get; set; }
+
+        [DataField("useSoundCollection")]
+        public string? UseSoundCollection { get; set; }
+
+        public void AddQuality(ToolQuality quality)
+        {
+            _qualities |= quality;
+            Dirty();
+        }
+
+        public void RemoveQuality(ToolQuality quality)
+        {
+            _qualities &= ~quality;
+            Dirty();
+        }
+
+        public bool HasQuality(ToolQuality quality)
+        {
+            return _qualities.HasFlag(quality);
+        }
+
+        public virtual async Task<bool> UseTool(IEntity user, IEntity? target, float doAfterDelay, ToolQuality toolQualityNeeded, Func<bool>? doAfterCheck = null)
+        {
+            if (!HasQuality(toolQualityNeeded) || !ActionBlockerSystem.CanInteract(user))
+                return false;
+
+            if (doAfterDelay > 0f)
+            {
+                var doAfterSystem = EntitySystem.Get<DoAfterSystem>();
+
+                var doAfterArgs = new DoAfterEventArgs(user, doAfterDelay / SpeedModifier, default, target)
+                {
+                    ExtraCheck = doAfterCheck,
+                    BreakOnDamage = false, // TODO: Change this to true once breathing is fixed.
+                    BreakOnStun = true,
+                    BreakOnTargetMove = true,
+                    BreakOnUserMove = true,
+                    NeedHand = true,
+                };
+
+                var result = await doAfterSystem.DoAfter(doAfterArgs);
+
+                if (result == DoAfterStatus.Cancelled)
+                    return false;
+            }
+
+            PlayUseSound();
+
+            return true;
+        }
+
+        protected void PlaySoundCollection(string? name, float volume = -5f)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                return;
+            }
+
+            var file = AudioHelpers.GetRandomFileFromSoundCollection(name);
+            SoundSystem.Play(Filter.Pvs(Owner), file, Owner, AudioHelpers.WithVariation(0.15f).WithVolume(volume));
+        }
+
+        public void PlayUseSound(float volume=-5f)
+        {
+            if (string.IsNullOrEmpty(UseSoundCollection))
+            {
+                if (!string.IsNullOrEmpty(UseSound))
+                {
+                    SoundSystem.Play(Filter.Pvs(Owner), UseSound, Owner, AudioHelpers.WithVariation(0.15f).WithVolume(volume));
+                }
+            }
+            else
+            {
+                PlaySoundCollection(UseSoundCollection, volume);
+            }
+        }
+    }
+}

Content.Server/Tools/Components/WelderComponent.cs

@@ -0,0 +1,335 @@
+#nullable enable
+using System;
+using System.Threading.Tasks;
+using Content.Server.Act;
+using Content.Server.Atmos;
+using Content.Server.Chat.Managers;
+using Content.Server.Chemistry.Components;
+using Content.Server.Explosion;
+using Content.Server.Items;
+using Content.Server.Notification;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Chemistry.Solution.Components;
+using Content.Shared.Examine;
+using Content.Shared.Interaction;
+using Content.Shared.NetIDs;
+using Content.Shared.Notification;
+using Content.Shared.Temperature;
+using Content.Shared.Tool;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Player;
+using Robust.Shared.Players;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Tools.Components
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(ToolComponent))]
+    [ComponentReference(typeof(IToolComponent))]
+    [ComponentReference(typeof(IHotItem))]
+    public class WelderComponent : ToolComponent, IExamine, IUse, ISuicideAct, ISolutionChange, IHotItem, IAfterInteract
+    {
+        [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
+
+        public override string Name => "Welder";
+        public override uint? NetID => ContentNetIDs.WELDER;
+
+        /// <summary>
+        /// Default Cost of using the welder fuel for an action
+        /// </summary>
+        public const float DefaultFuelCost = 10;
+
+        /// <summary>
+        /// Rate at which we expunge fuel from ourselves when activated
+        /// </summary>
+        public const float FuelLossRate = 0.5f;
+
+        private bool _welderLit;
+        private WelderSystem _welderSystem = default!;
+        private SpriteComponent? _spriteComponent;
+        private SolutionContainerComponent? _solutionComponent;
+        private PointLightComponent? _pointLightComponent;
+
+        [DataField("weldSoundCollection")]
+        public string? WeldSoundCollection { get; set; }
+
+        [ViewVariables]
+        public float Fuel => _solutionComponent?.Solution?.GetReagentQuantity("WeldingFuel").Float() ?? 0f;
+
+        [ViewVariables]
+        public float FuelCapacity => _solutionComponent?.MaxVolume.Float() ?? 0f;
+
+        /// <summary>
+        /// Status of welder, whether it is ignited
+        /// </summary>
+        [ViewVariables]
+        public bool WelderLit
+        {
+            get => _welderLit;
+            private set
+            {
+                _welderLit = value;
+                Dirty();
+            }
+        }
+
+        bool IHotItem.IsCurrentlyHot()
+        {
+            return WelderLit;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            AddQuality(ToolQuality.Welding);
+
+            _welderSystem = _entitySystemManager.GetEntitySystem<WelderSystem>();
+
+            Owner.TryGetComponent(out _solutionComponent);
+            Owner.TryGetComponent(out _spriteComponent);
+            Owner.TryGetComponent(out _pointLightComponent);
+        }
+
+        public override ComponentState GetComponentState(ICommonSession player)
+        {
+            return new WelderComponentState(FuelCapacity, Fuel, WelderLit);
+        }
+
+        public override async Task<bool> UseTool(IEntity user, IEntity? target, float doAfterDelay, ToolQuality toolQualityNeeded, Func<bool>? doAfterCheck = null)
+        {
+            bool ExtraCheck()
+            {
+                var extraCheck = doAfterCheck?.Invoke() ?? true;
+
+                if (!CanWeld(DefaultFuelCost))
+                {
+                    target?.PopupMessage(user, "Can't weld!");
+
+                    return false;
+                }
+
+                return extraCheck;
+            }
+
+            var canUse = await base.UseTool(user, target, doAfterDelay, toolQualityNeeded, ExtraCheck);
+
+            return toolQualityNeeded.HasFlag(ToolQuality.Welding) ? canUse && TryWeld(DefaultFuelCost, user) : canUse;
+        }
+
+        public async Task<bool> UseTool(IEntity user, IEntity target, float doAfterDelay, ToolQuality toolQualityNeeded, float fuelConsumed, Func<bool>? doAfterCheck = null)
+        {
+            bool ExtraCheck()
+            {
+                var extraCheck = doAfterCheck?.Invoke() ?? true;
+
+                return extraCheck && CanWeld(fuelConsumed);
+            }
+
+            return await base.UseTool(user, target, doAfterDelay, toolQualityNeeded, ExtraCheck) && TryWeld(fuelConsumed, user);
+        }
+
+        private bool TryWeld(float value, IEntity? user = null, bool silent = false)
+        {
+            if (!WelderLit)
+            {
+                if (!silent && user != null)
+                    Owner.PopupMessage(user, Loc.GetString("The welder is turned off!"));
+
+                return false;
+            }
+
+            if (!CanWeld(value))
+            {
+                if (!silent && user != null)
+                    Owner.PopupMessage(user, Loc.GetString("The welder does not have enough fuel for that!"));
+
+                return false;
+            }
+
+            if (_solutionComponent == null)
+                return false;
+
+            var succeeded = _solutionComponent.TryRemoveReagent("WeldingFuel", ReagentUnit.New(value));
+
+            if (succeeded && !silent)
+            {
+                PlaySoundCollection(WeldSoundCollection);
+            }
+            return succeeded;
+        }
+
+        private bool CanWeld(float value)
+        {
+            return Fuel > value || Qualities != ToolQuality.Welding;
+        }
+
+        private bool CanLitWelder()
+        {
+            return Fuel > 0 || Qualities != ToolQuality.Welding;
+        }
+
+        /// <summary>
+        /// Deactivates welding tool if active, activates welding tool if possible
+        /// </summary>
+        private bool ToggleWelderStatus(IEntity? user = null)
+        {
+            var item = Owner.GetComponent<ItemComponent>();
+
+            if (WelderLit)
+            {
+                WelderLit = false;
+                // Layer 1 is the flame.
+                item.EquippedPrefix = "off";
+                _spriteComponent?.LayerSetVisible(1, false);
+
+                if (_pointLightComponent != null) _pointLightComponent.Enabled = false;
+
+                PlaySoundCollection("WelderOff", -5);
+                _welderSystem.Unsubscribe(this);
+                return true;
+            }
+
+            if (!CanLitWelder() && user != null)
+            {
+                Owner.PopupMessage(user, Loc.GetString("The welder has no fuel left!"));
+                return false;
+            }
+
+            WelderLit = true;
+            item.EquippedPrefix = "on";
+            _spriteComponent?.LayerSetVisible(1, true);
+
+            if (_pointLightComponent != null) _pointLightComponent.Enabled = true;
+
+            PlaySoundCollection("WelderOn", -5);
+            _welderSystem.Subscribe(this);
+
+            Owner.Transform.Coordinates
+                .GetTileAtmosphere()?.HotspotExpose(700f, 50f, true);
+
+            return true;
+        }
+
+        bool IUse.UseEntity(UseEntityEventArgs eventArgs)
+        {
+            return ToggleWelderStatus(eventArgs.User);
+        }
+
+        public void Examine(FormattedMessage message, bool inDetailsRange)
+        {
+            if (WelderLit)
+            {
+                message.AddMarkup(Loc.GetString("[color=orange]Lit[/color]\n"));
+            }
+            else
+            {
+                message.AddText(Loc.GetString("Not lit\n"));
+            }
+
+            if (inDetailsRange)
+            {
+                message.AddMarkup(Loc.GetString("Fuel: [color={0}]{1}/{2}[/color].",
+                    Fuel < FuelCapacity / 4f ? "darkorange" : "orange", Math.Round(Fuel), FuelCapacity));
+            }
+        }
+
+        protected override void Shutdown()
+        {
+            base.Shutdown();
+            _welderSystem.Unsubscribe(this);
+        }
+
+        public void OnUpdate(float frameTime)
+        {
+            if (!HasQuality(ToolQuality.Welding) || !WelderLit || Owner.Deleted)
+                return;
+
+            _solutionComponent?.TryRemoveReagent("WeldingFuel", ReagentUnit.New(FuelLossRate * frameTime));
+
+            Owner.Transform.Coordinates
+                .GetTileAtmosphere()?.HotspotExpose(700f, 50f, true);
+
+            if (Fuel == 0)
+                ToggleWelderStatus();
+
+        }
+
+        SuicideKind ISuicideAct.Suicide(IEntity victim, IChatManager chat)
+        {
+            string othersMessage;
+            string selfMessage;
+
+            if (TryWeld(5, victim, silent: true))
+            {
+                PlaySoundCollection(WeldSoundCollection);
+
+                othersMessage =
+                    Loc.GetString(
+                        "{0:theName} welds {0:their} every orifice closed! It looks like {0:theyre} trying to commit suicide!",
+                        victim);
+                victim.PopupMessageOtherClients(othersMessage);
+
+                selfMessage = Loc.GetString("You weld your every orifice closed!");
+                victim.PopupMessage(selfMessage);
+
+                return SuicideKind.Heat;
+            }
+
+            othersMessage = Loc.GetString("{0:theName} bashes themselves with the unlit welding torch!", victim);
+            victim.PopupMessageOtherClients(othersMessage);
+
+            selfMessage = Loc.GetString("You bash yourself with the unlit welding torch!");
+            victim.PopupMessage(selfMessage);
+
+            return SuicideKind.Blunt;
+        }
+
+        public void SolutionChanged(SolutionChangeEventArgs eventArgs)
+        {
+            Dirty();
+        }
+
+
+        async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
+        {
+            if (eventArgs.Target == null || !eventArgs.CanReach)
+            {
+                return false;
+            }
+
+            if (eventArgs.Target.TryGetComponent(out ReagentTankComponent? tank)
+                && tank.TankType == ReagentTankType.Fuel
+                && eventArgs.Target.TryGetComponent(out ISolutionInteractionsComponent? targetSolution)
+                && targetSolution.CanDrain
+                && _solutionComponent != null)
+            {
+                if (WelderLit)
+                {
+                    // Oh no no
+                    eventArgs.Target.SpawnExplosion();
+                    return true;
+                }
+
+                var trans = ReagentUnit.Min(_solutionComponent.EmptyVolume, targetSolution.DrainAvailable);
+                if (trans > 0)
+                {
+                    var drained = targetSolution.Drain(trans);
+                    _solutionComponent.TryAddSolution(drained);
+
+                    SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Effects/refill.ogg", Owner);
+                    eventArgs.Target.PopupMessage(eventArgs.User, Loc.GetString("Welder refueled"));
+                }
+            }
+
+            return true;
+        }
+    }
+}

Content.Server/Tools/WelderSystem.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Tools.Components;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Tools
+{
+    /// <summary>
+    ///     Despite the name, it's only really used for the welder logic in tools. Go figure.
+    /// </summary>
+    public class WelderSystem : EntitySystem
+    {
+        private readonly HashSet<WelderComponent> _activeWelders = new();
+
+        public bool Subscribe(WelderComponent welder)
+        {
+            return _activeWelders.Add(welder);
+        }
+
+        public bool Unsubscribe(WelderComponent welder)
+        {
+            return _activeWelders.Remove(welder);
+        }
+
+        public override void Update(float frameTime)
+        {
+            foreach (var tool in _activeWelders.ToArray())
+            {
+                tool.OnUpdate(frameTime);
+            }
+        }
+    }
+}