Pipebombs now require ignition source

Content.Server/Explosion/EntitySystems/TriggerSystem.OnUse.cs

@@ -18,7 +18,7 @@ private void InitializeOnUse()
         SubscribeLocalEvent<OnUseTimerTriggerComponent, ExaminedEvent>(OnExamined);
         SubscribeLocalEvent<OnUseTimerTriggerComponent, GetVerbsEvent<AlternativeVerb>>(OnGetAltVerbs);
         SubscribeLocalEvent<OnUseTimerTriggerComponent, EntityStuckEvent>(OnStuck);
-        SubscribeLocalEvent<RandomTimerTriggerComponent, MapInitEvent>(OnRandomTimerTriggerMapInit);
+        //SubscribeLocalEvent<RandomTimerTriggerComponent, MapInitEvent>(OnRandomTimerTriggerMapInit);
     }
 
     private void OnStuck(EntityUid uid, OnUseTimerTriggerComponent component, EntityStuckEvent args)

Content.Server/Explosion/EntitySystems/TriggerTimerOnIgniteSystem.cs

@@ -0,0 +1,82 @@
+using Content.Shared.Explosion.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Examine;
+using Content.Shared.Popups;
+using Content.Shared.Verbs;
+using Content.Shared.Temperature;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Content.Server.Explosion.EntitySystems;
+using Content.Server.Explosion.Components;
+using Robust.Shared.Random;
+using Content.Shared.Trigger;
+using Content.Server.IgnitionSource;
+
+
+namespace Content.Server.Explosion
+{
+    public sealed class TriggerTimerOnIgniteSystem : EntitySystem
+    {
+        [Dependency] private readonly SharedPopupSystem _popupSystem = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+
+
+
+        public override void Initialize()
+        {
+            SubscribeLocalEvent<OnIgniteTimerTriggerComponent, InteractUsingEvent>(OnInteracted);
+            SubscribeLocalEvent<RandomTimerTriggerComponent, MapInitEvent>(OnRandomTimerTriggerMapInit2);
+            //SubscribeLocalEvent<OnIgniteTimerTriggerComponent, UseInHandEvent>(OnUseInHand);
+        }
+
+        private void OnInteracted(EntityUid uid, OnIgniteTimerTriggerComponent component, InteractUsingEvent args)
+        {
+            if (TryComp<IgnitionSourceComponent>(args.Used, out var comp)) {
+                if(comp.Ignited == true)
+                {
+                    if (args.Handled)
+                        return;
+
+                    var active = AddComp<ActiveTimerTriggerComponent>(uid);
+                    active.TimeRemaining = component.Delay;
+                    active.User = args.User;
+                    active.BeepSound = component.BeepSound;
+                    active.BeepInterval = component.BeepInterval;
+                    active.TimeUntilBeep = component.InitialBeepDelay ?? 0f;
+                    active.TimeUntilBeep = component.InitialBeepDelay == null ? active.BeepInterval : component.InitialBeepDelay.Value;
+
+                    var ev = new ActiveTimerTriggerEvent(uid, args.User);
+                    RaiseLocalEvent(uid, ref ev);
+                    _popupSystem.PopupEntity(Loc.GetString("trigger-activated", ("device", uid)), args.User, args.User);
+                    Log.Debug("You used this with another item!");
+                    var triggerEvent = new TriggerEvent(uid, args.User);
+
+                    if (TryComp<AppearanceComponent>(uid, out var appearance))
+                        _appearance.SetData(uid, TriggerVisuals.VisualState, TriggerVisualState.Primed, appearance);
+
+                }
+            }
+        }
+
+        private void OnUseInHand(EntityUid uid, OnIgniteTimerTriggerComponent component, UseInHandEvent args)
+        {
+            Log.Debug("You used this in your hand!");
+        }
+        private void OnRandomTimerTriggerMapInit2(Entity<RandomTimerTriggerComponent> ent, ref MapInitEvent args)
+        {
+            var (_, comp) = ent;
+
+            if (!TryComp<OnIgniteTimerTriggerComponent>(ent, out var timerTriggerComp))
+                return;
+
+            timerTriggerComp.Delay = _random.NextFloat(comp.Min, comp.Max);
+        }
+
+
+    }
+}

Content.Shared/Explosion/Components/OnIgniteTimerTriggerComponent.cs

@@ -0,0 +1,54 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Shared.Explosion.Components
+{
+    [RegisterComponent, NetworkedComponent]
+    public sealed partial class OnIgniteTimerTriggerComponent : Component
+    {
+        [DataField] public float Delay = 1f;
+
+        /// <summary>
+        ///     If not null, a user can use verbs to configure the delay to one of these options.
+        /// </summary>
+        [DataField] public List<float>? DelayOptions = null;
+
+        /// <summary>
+        ///     If not null, this timer will periodically play this sound while active.
+        /// </summary>
+        [DataField] public SoundSpecifier? BeepSound;
+
+        /// <summary>
+        ///     Time before beeping starts. Defaults to a single beep interval. If set to zero, will emit a beep immediately after use.
+        /// </summary>
+        [DataField] public float? InitialBeepDelay;
+
+        [DataField] public float BeepInterval = 1;
+
+        /// <summary>
+        ///     Whether the timer should instead be activated through a verb in the right-click menu
+        /// </summary>
+        [DataField] public bool UseVerbInstead = false;
+
+        /// <summary>
+        ///     Should timer be started when it was stuck to another entity.
+        ///     Used for C4 charges and similar behaviour.
+        /// </summary>
+        [DataField] public bool StartOnStick;
+
+        /// <summary>
+        ///     Allows changing the start-on-stick quality.
+        /// </summary>
+        [DataField("canToggleStartOnStick")] public bool AllowToggleStartOnStick;
+
+        /// <summary>
+        ///     Whether you can examine the item to see its timer or not.
+        /// </summary>
+        [DataField] public bool Examinable = true;
+    }
+}

Resources/Prototypes/Entities/Objects/Tools/lighters.yml

@@ -151,6 +151,8 @@
   - type: ItemToggleSize
     activatedSize: Small
   - type: ItemToggleHot
+  - type: IgnitionSource
+    ignited: false
   - type: Item
     size: Tiny
     sprite: Objects/Tools/lighters.rsi

Resources/Prototypes/Entities/Objects/Weapons/Bombs/pipebomb.yml

@@ -1,5 +1,44 @@
 - type: entity
-  parent: GrenadeBase
+  abstract: true
+  parent: BaseItem
+  id: IgniteBombBase
+  components:
+  - type: Sprite
+    sprite: Objects/Weapons/Grenades/grenade.rsi
+    layers:
+    - state: icon
+      map: ["enum.TriggerVisualLayers.Base"]
+  - type: Item
+    size: Small
+  - type: Clothing
+    quickEquip: false
+    slots:
+    - Belt
+#  - type: OnUseTimerTrigger
+#    delay: 3.5
+  - type: Damageable
+    damageContainer: Inorganic
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 10
+      behaviors:
+      - !type:TriggerBehavior
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+  - type: Appearance
+  - type: AnimationPlayer
+  - type: GenericVisualizer
+    visuals:
+      enum.Trigger.TriggerVisuals.VisualState:
+        enum.ConstructionVisuals.Layer:
+          Primed: { state: primed }
+          Unprimed: { state: icon }
+
+
+- type: entity
+  parent: IgniteBombBase
   id: PipeBomb
   name: pipe bomb
   description: An improvised explosive made from pipes and wire.
@@ -10,7 +49,7 @@
     - state: base
       map: ["enum.TriggerVisualLayers.Base"]
     - state: wires
-  - type: OnUseTimerTrigger # todo: make it activate through welder/lighter/fire instead
+  - type: OnIgniteTimerTrigger
     delay: 5
     examinable: false
     initialBeepDelay: 0
@@ -59,4 +98,6 @@
   - type: Construction
     graph: PipeBomb
     node: cable
-    defaultTarget: pipebomb
+    defaultTarget: pipebomb
+
+