Implement vital chef's hat functionality

Content.Client/Clothing/Systems/PilotedByClothingSystem.cs

@@ -0,0 +1,19 @@
+using Content.Shared.Clothing.Components;
+using Robust.Client.Physics;
+
+namespace Content.Client.Clothing.Systems;
+
+public sealed partial class PilotedByClothingSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PilotedByClothingComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
+    }
+
+    private void OnUpdatePredicted(Entity<PilotedByClothingComponent> entity, ref UpdateIsPredictedEvent args)
+    {
+        args.BlockPrediction = true;
+    }
+}

Content.Shared/Clothing/Components/PilotedByClothingComponent.cs

@@ -0,0 +1,12 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Clothing.Components;
+
+/// <summary>
+/// Disables client-side physics prediction for this entity.
+/// Without this, movement with <see cref="PilotedClothingSystem"/> is very rubberbandy.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class PilotedByClothingComponent : Component
+{
+}

Content.Shared/Clothing/Components/PilotedClothingComponent.cs

@@ -0,0 +1,47 @@
+using Content.Shared.Whitelist;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Clothing.Components;
+
+/// <summary>
+/// Allows an entity stored in this clothing item to pass inputs to the entity wearing it.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class PilotedClothingComponent : Component
+{
+    /// <summary>
+    /// Whitelist for entities that are allowed to act as pilots when inside this entity.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? PilotWhitelist;
+
+    /// <summary>
+    /// Should movement input be relayed from the pilot to the target?
+    /// </summary>
+    [DataField]
+    public bool RelayMovement = true;
+
+    /// <summary>
+    /// Should click interaction input be relayed from the pilot to the target?
+    /// </summary>
+    /// <remarks>
+    /// This doesn't work very well right now, so it's disabled by default.
+    /// If improvements are made to interaction relays, consider using it.
+    /// </remarks>
+    [DataField]
+    public bool RelayInteraction;
+
+    /// <summary>
+    /// Reference to the entity contained in the clothing and acting as pilot.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public NetEntity? Pilot;
+
+    /// <summary>
+    /// Reference to the entity wearing this clothing who will be controlled by the pilot.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public NetEntity? Wearer;
+
+    public bool IsActive => Pilot != null && Wearer != null;
+}

Content.Shared/Clothing/EntitySystems/PilotedClothingSystem.cs

@@ -0,0 +1,177 @@
+using Content.Shared.Clothing.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Components;
+using Content.Shared.Inventory.Events;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Content.Shared.Storage;
+using Robust.Shared.Containers;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Clothing.EntitySystems;
+
+public sealed partial class PilotedClothingSystem : EntitySystem
+{
+    [Dependency] private readonly IEntityManager _entMan = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedMoverController _moverController = default!;
+    [Dependency] private readonly SharedInteractionSystem _interaction = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PilotedClothingComponent, EntInsertedIntoContainerMessage>(OnEntInserted);
+        SubscribeLocalEvent<PilotedClothingComponent, EntRemovedFromContainerMessage>(OnEntRemoved);
+        SubscribeLocalEvent<PilotedClothingComponent, GotEquippedEvent>(OnEquipped);
+        SubscribeLocalEvent<PilotedClothingComponent, GotUnequippedEvent>(OnUnequipped);
+    }
+
+    private void OnEntInserted(Entity<PilotedClothingComponent> entity, ref EntInsertedIntoContainerMessage args)
+    {
+        // Make sure the entity was actually inserted into storage and not a different container.
+        if (!TryComp(entity, out StorageComponent? storage) || args.Container != storage.Container)
+            return;
+
+        // Check potential pilot against whitelist, if one exists.
+        if (entity.Comp.PilotWhitelist != null && !entity.Comp.PilotWhitelist.IsValid(args.Entity))
+            return;
+
+        entity.Comp.Pilot = _entMan.GetNetEntity(args.Entity);
+        Dirty(entity);
+
+        // Attempt to setup control link, if Pilot and Wearer are both present.
+        StartPiloting(entity);
+    }
+
+    private void OnEntRemoved(Entity<PilotedClothingComponent> entity, ref EntRemovedFromContainerMessage args)
+    {
+        // Make sure the removed entity is actually the pilot.
+        if (_entMan.GetNetEntity(args.Entity) != entity.Comp.Pilot)
+            return;
+
+        StopPiloting(entity);
+    }
+
+    private void OnEquipped(Entity<PilotedClothingComponent> entity, ref GotEquippedEvent args)
+    {
+        if (!TryComp(entity, out ClothingComponent? clothing))
+            return;
+
+        // Make sure the clothing item was equipped to the right slot, and not just held in a hand.
+        var isCorrectSlot = clothing.Slots.HasFlag(args.SlotFlags);
+        if (!isCorrectSlot)
+            return;
+
+        entity.Comp.Wearer = _entMan.GetNetEntity(args.Equipee);
+        Dirty(entity);
+
+        // Attempt to setup control link, if Pilot and Wearer are both present.
+        StartPiloting(entity);
+    }
+
+    private void OnUnequipped(Entity<PilotedClothingComponent> entity, ref GotUnequippedEvent args)
+    {
+        StopPiloting(entity);
+    }
+
+    /// <summary>
+    /// Attempts to establish movement/interaction relay connection(s) from Pilot to Wearer.
+    /// If either is missing, fails and returns false.
+    /// </summary>
+    private bool StartPiloting(Entity<PilotedClothingComponent> entity)
+    {
+        // Make sure we have both a Pilot and a Wearer
+        if (entity.Comp.Pilot == null || entity.Comp.Wearer == null)
+            return false;
+
+        if (!_timing.IsFirstTimePredicted)
+            return false;
+
+        var pilotEnt = _entMan.GetEntity(entity.Comp.Pilot.Value);
+        var wearerEnt = _entMan.GetEntity(entity.Comp.Wearer.Value);
+
+        // Add component to block prediction of wearer
+        AddComp<PilotedByClothingComponent>(wearerEnt);
+
+        if (entity.Comp.RelayMovement)
+        {
+            // Establish movement input relay.
+            _moverController.SetRelay(pilotEnt, wearerEnt);
+        }
+
+        if (entity.Comp.RelayInteraction)
+        {
+            // Establish click input relay.
+            var interactionRelay = EnsureComp<InteractionRelayComponent>(pilotEnt);
+            _interaction.SetRelay(pilotEnt, wearerEnt, interactionRelay);
+        }
+
+        var pilotEv = new StartedPilotingClothingEvent(entity, wearerEnt);
+        RaiseLocalEvent(pilotEnt, ref pilotEv);
+
+        var wearerEv = new StartingBeingPilotedByClothing(entity, pilotEnt);
+        RaiseLocalEvent(wearerEnt, ref wearerEv);
+
+        return true;
+    }
+
+    /// <summary>
+    /// Removes components from the Pilot and Wearer to stop the control relay.
+    /// Returns false if a connection does not already exist.
+    /// </summary>
+    private bool StopPiloting(Entity<PilotedClothingComponent> entity)
+    {
+        if (entity.Comp.Pilot == null || entity.Comp.Wearer == null)
+            return false;
+
+        // Clean up components on the Pilot
+        var pilotEnt = _entMan.GetEntity(entity.Comp.Pilot.Value);
+        RemCompDeferred<RelayInputMoverComponent>(pilotEnt);
+        RemCompDeferred<InteractionRelayComponent>(pilotEnt);
+
+        // Clean up components on the Wearer
+        var wearerEnt = _entMan.GetEntity(entity.Comp.Wearer.Value);
+        RemCompDeferred<MovementRelayTargetComponent>(wearerEnt);
+        RemCompDeferred<PilotedByClothingComponent>(wearerEnt);
+
+        // Raise an event on the Pilot
+        var pilotEv = new StoppedPilotingClothingEvent(entity, wearerEnt);
+        RaiseLocalEvent(pilotEnt, ref pilotEv);
+
+        // Raise an event on the Wearer
+        var wearerEv = new StoppedBeingPilotedByClothing(entity, pilotEnt);
+        RaiseLocalEvent(wearerEnt, ref wearerEv);
+
+        entity.Comp.Pilot = null;
+        entity.Comp.Wearer = null;
+        Dirty(entity);
+
+        return true;
+    }
+}
+
+/// <summary>
+/// Raised on the Pilot when they gain control of the Wearer.
+/// </summary>
+[ByRefEvent]
+public record struct StartedPilotingClothingEvent(EntityUid Clothing, EntityUid Wearer);
+
+/// <summary>
+/// Raised on the Pilot when they lose control of the Wearer,
+/// due to the Pilot exiting the clothing or the clothing being unequipped by the Wearer.
+/// </summary>
+[ByRefEvent]
+public record struct StoppedPilotingClothingEvent(EntityUid Clothing, EntityUid Wearer);
+
+/// <summary>
+/// Raised on the Wearer when the Pilot gains control of them.
+/// </summary>
+[ByRefEvent]
+public record struct StartingBeingPilotedByClothing(EntityUid Clothing, EntityUid Pilot);
+
+/// <summary>
+/// Raised on the Wearer when the Pilot loses control of them
+/// due to the Pilot exiting the clothing or the clothing being unequipped by the Wearer.
+/// </summary>
+[ByRefEvent]
+public record struct StoppedBeingPilotedByClothing(EntityUid Clothing, EntityUid Pilot);

Resources/Prototypes/Entities/Clothing/Head/hats.yml

@@ -250,6 +250,10 @@
   - type: ContainerContainer
     containers:
       storagebase: !type:Container
+  - type: PilotedClothing
+    pilotWhitelist:
+      tags:
+        - ChefPilot
   - type: Tag
     tags:
     - ClothMade

Resources/Prototypes/Entities/Mobs/NPCs/animals.yml

@@ -1550,6 +1550,7 @@
     tags:
     - Trash
     - VimPilot
+    - ChefPilot
     - Mouse
     - Meat
   - type: Respirator
@@ -2989,6 +2990,7 @@
   - type: Tag
     tags:
     - VimPilot
+    - ChefPilot
     - Trash
     - Hamster
     - Meat
@@ -3186,4 +3188,3 @@
   components:
   - type: ReplacementAccent
     accent: nymph
-

Resources/Prototypes/tags.yml

@@ -341,6 +341,10 @@
 - type: Tag
   id: Chicken
 
+# Allowed to control someone wearing a Chef's hat if inside their hat.
+- type: Tag
+  id: ChefPilot
+
 - type: Tag
   id: ChemDispensable # container that can go into the chem dispenser