Port automatic jetpack activation

Content.Shared/Movement/Components/JetpackComponent.cs

@@ -25,4 +25,19 @@ public sealed partial class JetpackComponent : Component
 
     [ViewVariables(VVAccess.ReadWrite), DataField("weightlessModifier")]
     public float WeightlessModifier = 1.2f;
+
+    // DeltaV Start - Jetpacks automatically toggle on.
+    /// <summary>
+    /// When toggling the jetpack, this will turn true/false.
+    /// Upon leaving a grid, this will determine if the jetpack activates.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool AutomaticMode;
+
+    /// <summary>
+    /// The user whose jetpack is waiting to activate.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public EntityUid? AutomaticUser;
+    // DeltaV End - Jetpacks automatically toggle on.
 }

Content.Shared/Movement/Systems/SharedJetpackSystem.cs

@@ -1,3 +1,4 @@
+using Content.Shared._DVA.Movement.Components; // DeltaV - Jetpacks automatically toggle on.
 using Content.Shared.Actions;
 using Content.Shared.Gravity;
 using Content.Shared.Interaction.Events;
@@ -36,6 +37,7 @@ public override void Initialize()
 
         SubscribeLocalEvent<GravityChangedEvent>(OnJetpackUserGravityChanged);
         SubscribeLocalEvent<JetpackComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<DVAutomaticJetpackUserComponent, EntParentChangedMessage>(OnAutomaticJetpackEntParentChanged); // DeltaV - Jetpacks automatically toggle on.
     }
 
     private void OnJetpackUserWeightlessMovement(Entity<JetpackUserComponent> ent, ref RefreshWeightlessModifiersEvent args)
@@ -71,13 +73,17 @@ private void OnJetpackUserGravityChanged(ref GravityChangedEvent ev)
 
     private void OnJetpackDropped(EntityUid uid, JetpackComponent component, DroppedEvent args)
     {
+        RemoveAutomaticJetpack((uid, component)); // DeltaV - Jetpacks automatically toggle on.
         SetEnabled(uid, component, false, args.User);
     }
 
     private void OnJetpackMoved(Entity<JetpackComponent> ent, ref EntGotInsertedIntoContainerMessage args)
     {
         if (args.Container.Owner != ent.Comp.JetpackUser)
+        {
+            RemoveAutomaticJetpack(ent); // DeltaV - Jetpacks automatically toggle on.
             SetEnabled(ent, ent.Comp, false, ent.Comp.JetpackUser);
+        }
     }
 
     private void OnJetpackUserCanWeightless(EntityUid uid, JetpackUserComponent component, ref CanWeightlessMoveEvent args)
@@ -125,20 +131,22 @@ private void RemoveUser(EntityUid uid, JetpackComponent component)
         _movementSpeedModifier.RefreshWeightlessModifiers(uid);
     }
 
-    private void OnJetpackToggle(EntityUid uid, JetpackComponent component, ToggleJetpackEvent args)
-    {
-        if (args.Handled)
-            return;
-
-        if (TryComp(uid, out TransformComponent? xform) && !CanEnableOnGrid(xform.GridUid))
-        {
-            _popup.PopupEntity(Loc.GetString("jetpack-no-station"), uid, args.Performer);
-
-            return;
-        }
-
-        SetEnabled(uid, component, !IsEnabled(uid));
-    }
+    /// DeltaV Start - Replaced with DeltaV method in <see cref="SharedJetpackSystem"/>
+    // private void OnJetpackToggle(EntityUid uid, JetpackComponent component, ToggleJetpackEvent args)
+    // {
+    //     if (args.Handled)
+    //         return;
+    //
+    //     if (TryComp(uid, out TransformComponent? xform) && !CanEnableOnGrid(xform.GridUid))
+    //     {
+    //         _popup.PopupClient(Loc.GetString("jetpack-no-station"), uid, args.Performer);
+    //
+    //         return;
+    //     }
+    //
+    //     SetEnabled(uid, component, !IsEnabled(uid));
+    // }
+    // DeltaV End - Replaced with DeltaV method.
 
     private bool CanEnableOnGrid(EntityUid? gridUid)
     {
@@ -171,6 +179,8 @@ public void SetEnabled(EntityUid uid, JetpackComponent component, bool enabled,
             user = container.Owner;
         }
 
+        RefreshAutomaticJetpack((uid, component), user.Value, enabled); // DeltaV - Jetpacks automatically turn on when toggled.
+
         if (enabled)
         {
             // If the user is already using another jetpack, disable it first

Content.Shared/_DVA/Movement/Components/DVAutomaticJetpackUserComponent.cs

@@ -0,0 +1,16 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._DVA.Movement.Components;
+
+/// <summary>
+/// Added when someone holds a jetpack that is toggled active and waits to turn on.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class DVAutomaticJetpackUserComponent : Component
+{
+    /// <summary>
+    /// The jetpack that will automatically activate.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public EntityUid Jetpack;
+}

Content.Shared/_DVA/Movement/Systems/SharedJetpackSystem.cs

@@ -0,0 +1,76 @@
+using Content.Shared._DVA.Movement.Components;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Events;
+
+namespace Content.Shared.Movement.Systems;
+
+public abstract partial class SharedJetpackSystem
+{
+    [Dependency] private SharedTransformSystem _transform = default!;
+
+    private void OnJetpackToggle(Entity<JetpackComponent> jetpack, ref ToggleJetpackEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        jetpack.Comp.AutomaticMode = !jetpack.Comp.AutomaticMode;
+        jetpack.Comp.AutomaticUser = args.Performer;
+        Dirty(jetpack);
+
+        if (!CanEnableOnGrid(_transform.GetGrid(jetpack.Owner)))
+        {
+            if (jetpack.Comp.AutomaticMode)
+            {
+                var autoUser = EnsureComp<DVAutomaticJetpackUserComponent>(args.Performer);
+                autoUser.Jetpack = jetpack;
+                Dirty(args.Performer, autoUser);
+            }
+            else
+            {
+                RemComp<DVAutomaticJetpackUserComponent>(args.Performer);
+            }
+
+            var message = jetpack.Comp.AutomaticMode ? "jetpack-activated-on-grid" : "jetpack-deactivated";
+            _popup.PopupEntity(Loc.GetString(message), jetpack, args.Performer);
+            return;
+        }
+
+        var messageOffGrid = jetpack.Comp.AutomaticMode ? "jetpack-activated-off-grid" : "jetpack-deactivated";
+        _popup.PopupEntity(Loc.GetString(messageOffGrid), jetpack, args.Performer);
+
+        SetEnabled(jetpack.Owner, jetpack.Comp, !IsEnabled(jetpack.Owner));
+    }
+
+    private void OnAutomaticJetpackEntParentChanged(Entity<DVAutomaticJetpackUserComponent> jetpackUser, ref EntParentChangedMessage args)
+    {
+        if (!TryComp<JetpackComponent>(jetpackUser.Comp.Jetpack, out var jetpack)
+            || args.Transform.GridUid != null)
+            return;
+
+        SetEnabled(jetpackUser.Comp.Jetpack, jetpack, true, args.Entity);
+        _popup.PopupEntity(Loc.GetString("jetpack-activates-automatically"), args.Entity, args.Entity);
+    }
+
+    private void RemoveAutomaticJetpack(Entity<JetpackComponent> jetpack)
+    {
+        jetpack.Comp.AutomaticMode = false;
+        if (jetpack.Comp.AutomaticUser.HasValue)
+            RemComp<DVAutomaticJetpackUserComponent>(jetpack.Comp.AutomaticUser.Value);
+        jetpack.Comp.AutomaticUser = null;
+    }
+
+    private void RefreshAutomaticJetpack(Entity<JetpackComponent> jetpack, EntityUid user, bool jetpackEnabled)
+    {
+        if (jetpackEnabled)
+        {
+            RemComp<DVAutomaticJetpackUserComponent>(user);
+        }
+        else if (jetpack.Comp.AutomaticMode)
+        {
+            var pack = EnsureComp<DVAutomaticJetpackUserComponent>(user);
+            pack.Jetpack = jetpack;
+            Dirty(user, pack);
+        }
+
+    }
+}

Resources/Locale/en-US/_DVA/movement/jetpacks.ftl

@@ -0,0 +1,4 @@
+jetpack-activated-on-grid = The jetpack will automatically turn on when leaving the station.
+jetpack-activated-off-grid = The jetpack turns on.
+jetpack-activates-automatically = The jetpack automatically turns on.
+jetpack-deactivated = The jetpack will no longer turn on.