Refactors smoking to ECS, smoking actually makes you inhale reagents. (#4678)

Content.Client/Entry/IgnoredComponents.cs

@@ -179,7 +179,8 @@ namespace Content.Client.Entry
             "Spillable",
             "SpaceVillainArcade",
             "Flammable",
-            "Smoking",
+            "Smokable",
+            "Cigar",
             "Matchstick",
             "Matchbox",
             "BlockGameArcade",

Content.Client/Smoking/BurnStateVisualizer.cs

@@ -1,4 +1,5 @@
-using Content.Shared.Smoking;
+using Content.Client.Clothing;
+using Content.Shared.Smoking;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -15,29 +16,46 @@ namespace Content.Client.Smoking
         [DataField("unlitIcon")]
         private string _unlitIcon = "icon";
 
+        [DataField("burntPrefix")]
+        private string _burntPrefix = "unlit";
+        [DataField("litPrefix")]
+        private string _litPrefix = "lit";
+        [DataField("unlitPrefix")]
+        private string _unlitPrefix = "unlit";
+
+
+
         public override void OnChangeData(AppearanceComponent component)
         {
             base.OnChangeData(component);
 
-            if (component.TryGetData<SharedBurningStates>(SmokingVisuals.Smoking, out var smoking))
+            if (component.TryGetData<SmokableState>(SmokingVisuals.Smoking, out var smoking))
             {
                 SetState(component, smoking);
             }
         }
 
-        private void SetState(AppearanceComponent component, SharedBurningStates burnState)
+        private void SetState(AppearanceComponent component, SmokableState burnState)
         {
+            var clothing = component.Owner.GetComponentOrNull<ClothingComponent>();
+
             if (component.Owner.TryGetComponent<ISpriteComponent>(out var sprite))
             {
                 switch (burnState)
                 {
-                    case SharedBurningStates.Lit:
+                    case SmokableState.Lit:
+                        if (clothing != null)
+                            clothing.ClothingEquippedPrefix = _litPrefix;
                         sprite.LayerSetState(0, _litIcon);
                         break;
-                    case SharedBurningStates.Burnt:
+                    case SmokableState.Burnt:
+                        if (clothing != null)
+                            clothing.ClothingEquippedPrefix = _burntPrefix;
                         sprite.LayerSetState(0, _burntIcon);
                         break;
-                    default:
+                    case SmokableState.Unlit:
+                        if (clothing != null)
+                            clothing.ClothingEquippedPrefix = _unlitPrefix;
                         sprite.LayerSetState(0, _unlitIcon);
                         break;
                 }

Content.Server/Light/Components/MatchstickComponent.cs

@@ -21,7 +21,7 @@ namespace Content.Server.Light.Components
         /// Current state to matchstick. Can be <code>Unlit</code>, <code>Lit</code> or <code>Burnt</code>.
         /// </summary>
         [ViewVariables]
-        public SharedBurningStates CurrentState = SharedBurningStates.Unlit;
+        public SmokableState CurrentState = SmokableState.Unlit;
 
         /// <summary>
         /// How long will matchstick last in seconds.

Content.Server/Light/EntitySystems/MatchboxSystem.cs

@@ -17,7 +17,7 @@ namespace Content.Server.Light.EntitySystems
         {
             if (!args.Handled
                 && args.Used.TryGetComponent<MatchstickComponent>(out var matchstick)
-                && matchstick.CurrentState == SharedBurningStates.Unlit)
+                && matchstick.CurrentState == SmokableState.Unlit)
             {
                 Get<MatchstickSystem>().Ignite(matchstick, args.User);
                 args.Handled = true;

Content.Server/Light/EntitySystems/MatchstickSystem.cs

@@ -32,7 +32,7 @@ namespace Content.Server.Light.EntitySystems
             base.Update(frameTime);
             foreach (var match in _litMatches)
             {
-                if (match.CurrentState != SharedBurningStates.Lit)
+                if (match.CurrentState != SmokableState.Lit)
                     continue;
 
                 _atmosphereSystem.HotspotExpose(match.Owner.Transform.Coordinates, 400, 50, true);
@@ -41,7 +41,7 @@ namespace Content.Server.Light.EntitySystems
 
         private void OnInteractUsing(EntityUid uid, MatchstickComponent component, InteractUsingEvent args)
         {
-            if (args.Handled || component.CurrentState != SharedBurningStates.Unlit)
+            if (args.Handled || component.CurrentState != SmokableState.Unlit)
                 return;
 
             var isHotEvent = new IsHotEvent();
@@ -56,7 +56,7 @@ namespace Content.Server.Light.EntitySystems
 
         private void OnIsHotEvent(EntityUid uid, MatchstickComponent component, IsHotEvent args)
         {
-            args.IsHot = component.CurrentState == SharedBurningStates.Lit;
+            args.IsHot = component.CurrentState == SmokableState.Lit;
         }
 
         public void Ignite(MatchstickComponent component, IEntity user)
@@ -67,29 +67,29 @@ namespace Content.Server.Light.EntitySystems
                 AudioHelpers.WithVariation(0.125f).WithVolume(-0.125f));
 
             // Change state
-            SetState(component, SharedBurningStates.Lit);
+            SetState(component, SmokableState.Lit);
             _litMatches.Add(component);
             component.Owner.SpawnTimer(component.Duration * 1000, delegate
             {
-                SetState(component, SharedBurningStates.Burnt);
+                SetState(component, SmokableState.Burnt);
                 _litMatches.Remove(component);
             });
         }
 
-        private void SetState(MatchstickComponent component, SharedBurningStates value)
+        private void SetState(MatchstickComponent component, SmokableState value)
         {
             component.CurrentState = value;
 
             if (component.PointLightComponent != null)
             {
-                component.PointLightComponent.Enabled = component.CurrentState == SharedBurningStates.Lit;
+                component.PointLightComponent.Enabled = component.CurrentState == SmokableState.Lit;
             }
 
             if (component.Owner.TryGetComponent(out ItemComponent? item))
             {
                 switch (component.CurrentState)
                 {
-                    case SharedBurningStates.Lit:
+                    case SmokableState.Lit:
                         item.EquippedPrefix = "lit";
                         break;
                     default:

Content.Server/Nutrition/Components/CigarComponent.cs

@@ -0,0 +1,15 @@
+using Content.Server.Nutrition.EntitySystems;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Nutrition.Components
+{
+    /// <summary>
+    ///     A disposable, single-use smokable.
+    /// </summary>
+    [RegisterComponent, Friend(typeof(SmokingSystem))]
+    public class CigarComponent : Component
+    {
+        public override string Name => "Cigar";
+    }
+}

Content.Server/Nutrition/Components/SmokableComponent.cs

@@ -0,0 +1,27 @@
+using Content.Server.Nutrition.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Smoking;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Server.Nutrition.Components
+{
+    [RegisterComponent, Friend(typeof(SmokingSystem))]
+    public class SmokableComponent : Component
+    {
+        public override string Name => "Smokable";
+
+        [DataField("solution")]
+        public string Solution { get; } = "smokable";
+
+        /// <summary>
+        ///     Solution inhale amount per second.
+        /// </summary>
+        [DataField("inhaleAmount")]
+        public ReagentUnit InhaleAmount { get; } = ReagentUnit.New(0.05f);
+
+        [DataField("state")]
+        public SmokableState State { get; set; } = SmokableState.Unlit;
+    }
+}

Content.Server/Nutrition/Components/SmokingComponent.cs

@@ -1,98 +0,0 @@
-using System.Threading.Tasks;
-using Content.Server.Clothing.Components;
-using Content.Shared.Interaction;
-using Content.Shared.Smoking;
-using Content.Shared.Temperature;
-using Robust.Server.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
-using Robust.Shared.ViewVariables;
-
-namespace Content.Server.Nutrition.Components
-{
-    /// <summary>
-    /// This item acts as a representation for smokable consumables.
-    ///
-    /// To smoke a cigar, you need:
-    /// <list type="bullet">
-    /// <item><description> a hot item (implements IHotItem interface)</description></item>
-    /// <item><description> that's a alight.</description></item>
-    /// <item><description>  for the target cigar be Unlit. Lit cigars are already lit and butt's don't have any "fuel" left.</description></item>
-    ///</list>
-    /// TODO: Add reagents that interact when smoking
-    /// TODO: Allow suicide via excessive Smoking
-    /// </summary>
-    [RegisterComponent]
-    public class SmokingComponent : Component, IInteractUsing
-    {
-        public override string Name => "Smoking";
-
-        private SharedBurningStates _currentState = SharedBurningStates.Unlit;
-
-        [ComponentDependency] private readonly ClothingComponent? _clothingComponent = default!;
-        [ComponentDependency] private readonly AppearanceComponent? _appearanceComponent = default!;
-
-        /// <summary>
-        /// Duration represents how long will this item last.
-        /// Generally it ticks down whether it's time-based
-        /// or consumption-based.
-        /// </summary>
-        [ViewVariables] [DataField("duration")]
-        private int _duration = 30;
-
-        /// <summary>
-        /// What is the temperature of the cigar?
-        ///
-        /// For a regular cigar, the temp approaches around 400°C or 580°C
-        /// dependant on where you measure.
-        /// </summary>
-        //[ViewVariables] [DataField("temperature")]
-        //private float _temperature = 673.15f;
-
-        [ViewVariables]
-        public SharedBurningStates CurrentState
-        {
-            get => _currentState;
-            set
-            {
-                _currentState = value;
-
-                if (_clothingComponent != null)
-                {
-                    switch (_currentState)
-                    {
-                        case SharedBurningStates.Lit:
-                            _clothingComponent.EquippedPrefix = "lit";
-                            _clothingComponent.ClothingEquippedPrefix = "lit";
-                            break;
-                        default:
-                            _clothingComponent.EquippedPrefix = "unlit";
-                            _clothingComponent.ClothingEquippedPrefix = "unlit";
-                            break;
-                    }
-                }
-
-                _appearanceComponent?.SetData(SmokingVisuals.Smoking, _currentState);
-            }
-        }
-
-        // TODO: ECS this method and component.
-        async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
-        {
-            if (CurrentState != SharedBurningStates.Unlit)
-                return false;
-
-            var isHotEvent = new IsHotEvent();
-            Owner.EntityManager.EventBus.RaiseLocalEvent(eventArgs.Using.Uid, isHotEvent, false);
-
-            if (!isHotEvent.IsHot)
-                return false;
-
-            CurrentState = SharedBurningStates.Lit;
-            // TODO More complex handling of cigar consumption
-            Owner.SpawnTimer(_duration * 1000, () => CurrentState = SharedBurningStates.Burnt);
-            return true;
-
-        }
-    }
-}

Content.Server/Nutrition/EntitySystems/SmokingSystem.Cigar.cs

@@ -0,0 +1,60 @@
+using Content.Server.Nutrition.Components;
+using Content.Shared.Chemistry.Components.SolutionManager;
+using Content.Shared.Interaction;
+using Content.Shared.Smoking;
+using Content.Shared.Temperature;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Nutrition.EntitySystems
+{
+    public partial class SmokingSystem
+    {
+        private void InitializeCigars()
+        {
+            SubscribeLocalEvent<CigarComponent, ActivateInWorldEvent>(OnCigarActivatedEvent);
+            SubscribeLocalEvent<CigarComponent, InteractUsingEvent>(OnCigarInteractUsingEvent);
+            SubscribeLocalEvent<CigarComponent, SmokableSolutionEmptyEvent>(OnCigarSolutionEmptyEvent);
+        }
+
+        private void OnCigarActivatedEvent(EntityUid uid, CigarComponent component, ActivateInWorldEvent args)
+        {
+            if (args.Handled)
+                return;
+
+            if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
+                return;
+
+            if (smokable.State != SmokableState.Lit)
+                return;
+
+            SetSmokableState(uid, SmokableState.Burnt, smokable);
+            args.Handled = true;
+        }
+
+        private void OnCigarInteractUsingEvent(EntityUid uid, CigarComponent component, InteractUsingEvent args)
+        {
+            if (args.Handled)
+                return;
+
+            if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
+                return;
+
+            if (smokable.State != SmokableState.Unlit)
+                return;
+
+            var isHotEvent = new IsHotEvent();
+            RaiseLocalEvent(args.Used.Uid, isHotEvent, false);
+
+            if (!isHotEvent.IsHot)
+                return;
+
+            SetSmokableState(uid, SmokableState.Lit, smokable);
+            args.Handled = true;
+        }
+
+        private void OnCigarSolutionEmptyEvent(EntityUid uid, CigarComponent component, SmokableSolutionEmptyEvent args)
+        {
+            SetSmokableState(uid, SmokableState.Burnt);
+        }
+    }
+}

Content.Server/Nutrition/EntitySystems/SmokingSystem.cs

@@ -1,20 +1,115 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Body.Circulatory;
 using Content.Server.Nutrition.Components;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Interaction;
 using Content.Shared.Smoking;
 using Content.Shared.Temperature;
+using Robust.Server.GameObjects;
+using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 
 namespace Content.Server.Nutrition.EntitySystems
 {
-    public class SmokingSystem : EntitySystem
+    public partial class SmokingSystem : EntitySystem
     {
+        [Dependency] private readonly ChemistrySystem _chemistrySystem = default!;
+        [Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
+
+        private const float UpdateTimer = 3f;
+
+        private float _timer = 0f;
+
+        /// <summary>
+        ///     We keep a list of active smokables, because iterating all existing smokables would be dumb.
+        /// </summary>
+        private readonly HashSet<EntityUid> _active = new();
+
         public override void Initialize()
         {
-            SubscribeLocalEvent<SmokingComponent, IsHotEvent>(OnIsHotEvent);
+            SubscribeLocalEvent<SmokableComponent, IsHotEvent>(OnSmokableIsHotEvent);
+            SubscribeLocalEvent<SmokableComponent, ComponentShutdown>(OnSmokableShutdownEvent);
+
+            InitializeCigars();
         }
 
-        private void OnIsHotEvent(EntityUid uid, SmokingComponent component, IsHotEvent args)
+        public void SetSmokableState(EntityUid uid, SmokableState state, SmokableComponent? smokable = null, AppearanceComponent? appearance = null)
         {
-            args.IsHot = component.CurrentState == SharedBurningStates.Lit;
+            if (!Resolve(uid, ref smokable, ref appearance))
+                return;
+
+            smokable.State = state;
+            appearance.SetData(SmokingVisuals.Smoking, state);
+
+            if (state == SmokableState.Lit)
+                _active.Add(uid);
+            else
+                _active.Remove(uid);
+        }
+
+        private void OnSmokableIsHotEvent(EntityUid uid, SmokableComponent component, IsHotEvent args)
+        {
+            args.IsHot = component.State == SmokableState.Lit;
+        }
+
+        private void OnSmokableShutdownEvent(EntityUid uid, SmokableComponent component, ComponentShutdown args)
+        {
+            _active.Remove(uid);
+        }
+
+        public override void Update(float frameTime)
+        {
+            _timer += frameTime;
+
+            if (_timer < UpdateTimer)
+                return;
+
+            foreach (var uid in _active.ToArray())
+            {
+                if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
+                {
+                    _active.Remove(uid);
+                    continue;
+                }
+
+                if (!_solutionContainerSystem.TryGetSolution(uid, smokable.Solution, out var solution))
+                {
+                    _active.Remove(uid);
+                    continue;
+                }
+
+                var inhaledSolution = _solutionContainerSystem.SplitSolution(uid, solution, smokable.InhaleAmount * _timer);
+
+                if (solution.TotalVolume == ReagentUnit.Zero)
+                {
+                    RaiseLocalEvent(uid, new SmokableSolutionEmptyEvent());
+                }
+
+                if (inhaledSolution.TotalVolume == ReagentUnit.Zero)
+                    continue;
+
+                // This is awful. I hate this so much.
+                // TODO: Please, someone refactor containers and free me from this bullshit.
+                if (!smokable.Owner.TryGetContainerMan(out var containerManager) ||
+                    !containerManager.Owner.TryGetComponent(out BloodstreamComponent? bloodstream))
+                    continue;
+
+                _chemistrySystem.ReactionEntity(containerManager.Owner, ReactionMethod.Ingestion, inhaledSolution);
+                bloodstream.TryTransferSolution(inhaledSolution);
+            }
+
+            _timer -= UpdateTimer;
         }
     }
+
+    /// <summary>
+    ///     Directed event raised when the smokable solution is empty.
+    /// </summary>
+    public class SmokableSolutionEmptyEvent : EntityEventArgs
+    {
+    }
 }

Content.Shared/Chemistry/ChemistrySystem.cs

@@ -1,3 +1,4 @@
+using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.Reaction;
 using Content.Shared.Chemistry.Reagent;
 using JetBrains.Annotations;
@@ -12,15 +13,22 @@ namespace Content.Shared.Chemistry
     {
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
-        public void ReactionEntity(IEntity? entity, ReactionMethod method, string reagentId, ReagentUnit reactVolume,
+        public void ReactionEntity(IEntity entity, ReactionMethod method, Solution solution)
-            Components.Solution? source)
+        {
+            foreach (var (id, quantity) in solution)
+            {
+                ReactionEntity(entity, method, id, quantity, solution);
+            }
+        }
+
+        public void ReactionEntity(IEntity entity, ReactionMethod method, string reagentId, ReagentUnit reactVolume, Solution? source)
         {
             // We throw if the reagent specified doesn't exist.
             ReactionEntity(entity, method, _prototypeManager.Index<ReagentPrototype>(reagentId), reactVolume, source);
         }
 
-        public void ReactionEntity(IEntity? entity, ReactionMethod method, ReagentPrototype reagent,
+        public void ReactionEntity(IEntity entity, ReactionMethod method, ReagentPrototype reagent,
-            ReagentUnit reactVolume, Components.Solution? source)
+            ReagentUnit reactVolume, Solution? source)
         {
             if (entity == null || entity.Deleted || !entity.TryGetComponent(out ReactiveComponent? reactive))
                 return;

Content.Shared/Smoking/SmokableState.cs

@@ -4,7 +4,7 @@ using Robust.Shared.Serialization;
 namespace Content.Shared.Smoking
 {
     [Serializable, NetSerializable]
-    public enum SharedBurningStates : byte
+    public enum SmokableState : byte
     {
         Unlit,
         Lit,

Resources/Prototypes/Entities/Clothing/Belt/belts.yml

@@ -299,7 +299,7 @@
         - CigPack
       components:
         - Seed
-        - Smoking
+        - Smokable
   - type: ItemMapper
     mapLayers:
       hatchet:

Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigarettes/blunts.yml

@@ -1,6 +1,6 @@
 - type: entity
   id: Rollie
-  parent: BaseSmokeable
+  parent: BaseCigar
   name: blunt
   description: A roll of dried plant matter wrapped in thin paper.
   components:
@@ -19,3 +19,10 @@
   - type: Construction
     graph: smokeableRollie
     node: rollie
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 20
+        reagents:
+          - ReagentId: THC
+            Quantity: 10

Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigarettes/cigarette.yml

@@ -3,7 +3,7 @@
 
 - type: entity
   id: Cigarette
-  parent: BaseSmokeable
+  parent: BaseCigar
   name: cigarette
   description: A roll of tobacco and nicotine.
   components:

Resources/Prototypes/Entities/Objects/Consumable/Smokeables/Cigars/cigar.yml

@@ -3,12 +3,10 @@
 
 - type: entity
   id: Cigar
-  parent: BaseSmokeable
+  parent: BaseCigar
   name: cigar
   description: "A brown roll of tobacco and... well, you're not quite sure."
   components:
-  - type: Smoking
-    duration: 70
   - type: Sprite
     sprite: Objects/Consumable/Smokeables/Cigars/cigar.rsi
     netsync: false

Resources/Prototypes/Entities/Objects/Consumable/Smokeables/base.yml

@@ -1,11 +1,29 @@
 - type: entity
   description: "If you want to get cancer, might as well do it in style."
-  id: BaseSmokeable
+  id: BaseSmokable
   parent: BaseItem
   abstract: true
   components:
-  - type: Smoking
+  - type: Smokable
-    duration: 50
+  - type: Sprite
+    netsync: false
   - type: Appearance
     visuals:
       - type: BurnStateVisualizer
+
+# Base for all cigars and cigarettes.
+- type: entity
+  parent: BaseSmokable
+  id: BaseCigar
+  abstract: true
+  components:
+  - type: Cigar
+  - type: InjectableSolution
+    solution: smokable
+  - type: SolutionContainerManager
+    solutions:
+      smokable:
+        maxVol: 20
+        reagents:
+          - ReagentId: Nicotine
+            Quantity: 10

Resources/Prototypes/Entities/Objects/Consumable/Smokeables/pipes.yml

@@ -1,17 +0,0 @@
-- type: entity
-  id: SmokingPipe
-  parent: BaseSmokeable
-  name: smoking pipe
-  description: "A pipe, for smoking. Probably made of meershaum or something."
-  components:
-  - type: Smoking
-    duration: 70
-  - type: Sprite
-    sprite: Objects/Consumable/Smokeables/Pipes/pipe.rsi
-    netsync: false
-    state: unlit-icon
-  - type: Clothing
-    sprite: Objects/Consumable/Smokeables/Pipes/pipe.rsi
-    Slots: [ mask ]
-    HeldPrefix: unlit
-    size: 1

SpaceStation14.sln.DotSettings

@@ -256,6 +256,8 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=sandboxing/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Serilog/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=singulo/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Smokable/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=smokables/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Soundfont/@EntryIndexedValue">True</s:Boolean>
     <s:Boolean x:Key="/Default/UserDictionary/Words/=soundfonts/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=spawnable/@EntryIndexedValue">True</s:Boolean>