Intellicard fixes and adding pAI to allowed targets (#5867)

## Short description
- This will fix the bug that intellicards can target AI Interfaces or
borgs with them installed (entity transfer in/out)
- This will add the ability to the intellicard to also target pAI's
(in/out)

## Why we need to add this
While very convenient, AI Interfaces are to be be used only for
shunting. This fixes an obviously problem that was also reported as such
(directly to me as i have made the merged pull request
#5776

pAI's are just players in boxes. It makes sense to be able to transfer
those to any other digital interface instead of them being ghosting and
doing it that way.

## Media (Video/Screenshots)

https://github.com/user-attachments/assets/4c51d12e-4aa9-4588-bd25-16a46a4066ba


## Checks
- [x] I do not require assistance to complete the PR.
- [x] Before posting/requesting review of a PR, I have verified that the
changes work.
- [x] I have added screenshots/videos of the changes, or this PR does
not change in-game mechanics.
- [x] I affirm that my changes are licensed under the [MIT
License](https://github.com/ss14Starlight/space-station-14/blob/Starlight/LICENSE.TXT)
and grant permission for use in this repository under its conditions.

**Changelog**
:cl: Floximo
- add: Intellicards can now target pAI and transfer in both directions.
- fix: AI Interfaces or borgs with AI Interfaces can no longer be
target/source of intellicard transfers.

---------

Co-authored-by: Walker Fowlkes <47339836+walksanatora@users.noreply.github.com>

Author: Proximitron

Content.Shared/Silicons/StationAi/SharedStationAiSystem.cs

@@ -16,6 +16,7 @@
 using Content.Shared.Mind.Components; // Starlight-edit
 using Content.Shared.Mobs;
 using Content.Shared.Mobs.Systems;
+using Content.Shared.PAI;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Systems;
 using Content.Shared.Popups;
@@ -122,6 +123,7 @@ public override void Initialize()
         SubscribeLocalEvent<StationAiHolderComponent, IntellicardDoAfterEvent>(OnIntellicardDoAfter);
 
         SubscribeLocalEvent<BorgBrainComponent, IntellicardDoAfterEvent>(OnIntellicardBorgDoAfter); // Starlight-edit
+        SubscribeLocalEvent<PAIComponent, IntellicardDoAfterEvent>(OnIntellicardPaiDoAfter); // Starlight-edit
 
         SubscribeLocalEvent<StationAiCoreComponent, EntInsertedIntoContainerMessage>(OnAiInsert);
         SubscribeLocalEvent<StationAiCoreComponent, EntRemovedFromContainerMessage>(OnAiRemove);
@@ -271,9 +273,7 @@ private void OnAiInRange(Entity<StationAiOverlayComponent> ent, ref InRangeOverr
     }
 
     private void OnIntellicardDoAfter(Entity<StationAiHolderComponent> ent, ref IntellicardDoAfterEvent args) => IntellicardTransfer(ent.Owner, ent.Comp, args); // Starlight-edit
-
     private void OnIntellicardBorgDoAfter(Entity<BorgBrainComponent> ent, ref IntellicardDoAfterEvent args) => IntellicardTransfer(ent.Owner, null, args); // Starlight-edit
-
     private void IntellicardTransfer(EntityUid uid, StationAiHolderComponent? component, IntellicardDoAfterEvent args) // Starlight-edit
     {
         if (args.Cancelled)
@@ -286,6 +286,9 @@ private void IntellicardTransfer(EntityUid uid, StationAiHolderComponent? compon
             return;
 
         var target = args.Args.Target.Value;
+        if (IsAiInterface(target)) // Starlight-edit
+            return;
+
         if (TryComp<BorgChassisComponent>(target, out var chassis) && chassis.BrainEntity is { } chassisBrain)
             target = chassisBrain;
 
@@ -371,14 +374,6 @@ private void IntellicardTransfer(EntityUid uid, StationAiHolderComponent? compon
         }
         // Starlight-end
     }
-
-    // Starlight: wipe the name of the entity to the prototype name, used for entities when they are downloaded/uploaded
-    private void ResetNameToPrototype(EntityUid entity)
-    {
-        if (MetaData(entity).EntityPrototype is { } prototype)
-            _metadata.SetEntityName(entity, prototype.Name);
-    }
-
     private void OnHolderInteract(Entity<StationAiHolderComponent> ent, ref AfterInteractEvent args)
     {
         if (args.Handled || !args.CanReach || args.Target == null)
@@ -401,15 +396,19 @@ private void OnHolderInteract(Entity<StationAiHolderComponent> ent, ref AfterInt
         // Starlight-start: Downloadable borgs
 
         var borgTarget = args.Target.Value;
-        var borgMindTarget = borgTarget; // Starlight-edit
+        var borgMindTarget = borgTarget;
+        if (IsAiInterface(borgTarget))
+            return;
+
         if (TryComp<BorgChassisComponent>(borgTarget, out var chassis) && chassis.BrainEntity is { } chassisBrain)
             borgTarget = chassisBrain;
 
         var isBorg = HasComp<BorgBrainComponent>(borgTarget);
+        var isPai = HasComp<PAIComponent>(borgTarget);
         var isShunted = TryComp<StationAIShuntComponent>(borgTarget, out var shunt) && shunt.Return != null;
         var borgHaveMind = TryComp<MindContainerComponent>(borgMindTarget, out var mindContainer) && mindContainer.HasMind; // Starlight-edit
 
-        if (targetHolder == null && !isBorg)
+        if (targetHolder == null && !isBorg && !isPai)
         {
             var message = cardHasAi ? "intellicard-cannot-transfer-to" : "intellicard-core-empty";
             _popup.PopupClient(Loc.GetString(message), args.User, args.User, PopupType.Medium);
@@ -425,7 +424,7 @@ private void OnHolderInteract(Entity<StationAiHolderComponent> ent, ref AfterInt
             args.Handled = true;
             return;
         }
-        if (!cardHasAi && !coreHasAi && !(isBorg && borgHaveMind)) // Starlight-edit
+        if (!cardHasAi && !coreHasAi && !(isBorg && borgHaveMind) && !isPai) // Starlight: pai is also possible
         {
             _popup.PopupClient(Loc.GetString("intellicard-core-empty"), args.User, args.User, PopupType.Medium);
             args.Handled = true;
@@ -434,7 +433,8 @@ private void OnHolderInteract(Entity<StationAiHolderComponent> ent, ref AfterInt
         // Starlight-start: Downloadable borgs
         if (isShunted)
         {
-            _popup.PopupClient(Loc.GetString("intellicard-shunted"), args.User, args.User, PopupType.Medium);
+            if (HasComp<BorgBrainComponent>(ent.Owner))
+                _popup.PopupClient(Loc.GetString("intellicard-shunted"), args.User, args.User, PopupType.Medium);
             args.Handled = true;
             return;
         }
@@ -445,8 +445,8 @@ private void OnHolderInteract(Entity<StationAiHolderComponent> ent, ref AfterInt
             var ev = new ChatNotificationEvent(_downloadChatNotificationPrototype, args.Used, args.User);
             RaiseLocalEvent(held.Value, ref ev);
         }
-        // Starlight-start: borgs can be downloaded/uploaded
-        else if (isBorg)
+        // Starlight-start: borgs/pAI can be downloaded/uploaded
+        else if (isBorg || isPai)
         {
             var ev = new ChatNotificationEvent(_downloadChatNotificationPrototype, args.Used, args.User);
             RaiseLocalEvent(args.Target.Value, ref ev);

Content.Shared/_Starlight/Silicons/Borgs/StationAIShuntSystem.cs

@@ -67,6 +67,15 @@ private void OnAttemptShunt(EntityUid uid, StationAIShuntableComponent shuntable
 
         if (!TryComp<StationAIShuntComponent>(target, out var shunt))
             return;
+
+        // We check first if this is already "posessed" for one or another reason. This is a remote, not a ghost maker.
+        if (_mindSystem.TryGetMind(target, out _, out _))
+        {
+            if (_net.IsServer)
+                _popup.PopupEntity(Loc.GetString("shunt-target-occupied"), target, uid, PopupType.Large);
+            return;
+        }
+
         if (!_mindSystem.TryGetMind(uid, out var mindId, out var _))
             return;
         if (!TryComp<MobStateComponent>(uid, out var state) || state.CurrentState != MobState.Alive)

Content.Shared/_Starlight/Silicons/StationAi/SharedStationAiSystem.cs

@@ -0,0 +1,68 @@
+using Content.Shared.Intellicard;
+using Content.Shared.PAI;
+using Content.Shared.Popups;
+//ReSharper disable CheckNamespace
+using Content.Shared.Silicons.Borgs.Components;
+using Content.Shared._Starlight.Silicons.Borgs;
+
+namespace Content.Shared.Silicons.StationAi;
+
+public abstract partial class SharedStationAiSystem
+{
+    private void OnIntellicardPaiDoAfter(Entity<PAIComponent> ent, ref IntellicardDoAfterEvent args) => TransferPai(ent.Owner, args);
+
+    // Starlight: wipe the name of the entity to the prototype name, used for entities when they are downloaded/uploaded
+    private void ResetNameToPrototype(EntityUid entity)
+    {
+        if (MetaData(entity).EntityPrototype is { } prototype)
+            _metadata.SetEntityName(entity, prototype.Name);
+    }
+
+    private bool IsAiInterface(EntityUid entity)
+    {
+        if (TryComp<BorgChassisComponent>(entity, out var chassis) && chassis.BrainEntity is { } brain)
+            entity = brain;
+
+        return HasComp<StationAIShuntComponent>(entity);
+    }
+
+    private void TransferPai(EntityUid pai, IntellicardDoAfterEvent args)
+    {
+        if (args.Cancelled || args.Handled)
+            return;
+
+        if (args.Args.Target is not { } card || !TryComp<StationAiHolderComponent>(card, out var cardHolder))
+            return;
+
+        var slot = cardHolder.Slot;
+        if (slot.Item is { } stored)
+        {
+            if (!_mind.TryGetMind(stored, out var mindId, out var mind))
+                return;
+
+            if (_mind.TryGetMind(pai, out _, out _))
+            {
+                _popup.PopupEntity(Loc.GetString("intellicard-core-occupied"), pai, args.User, PopupType.Large);
+                return;
+            }
+
+            var name = _nameModifier.GetBaseName(stored);
+            _mind.TransferTo(mindId, pai, ghostCheckOverride: true, mind: mind);
+            _metadata.SetEntityName(pai, name);
+            Del(stored);
+            args.Handled = true;
+            return;
+        }
+
+        if (slot.ContainerSlot is not { } containerSlot || !_mind.TryGetMind(pai, out var paiMindId, out var paiMind))
+            return;
+
+        var paiName = _nameModifier.GetBaseName(pai);
+        var brain = SpawnInContainerOrDrop(DefaultAi, card, containerSlot.ID);
+        _metadata.SetEntityName(brain, paiName);
+        _metadata.SetEntityName(card, paiName);
+        _mind.TransferTo(paiMindId, brain, ghostCheckOverride: true, mind: paiMind);
+        ResetNameToPrototype(pai);
+        args.Handled = true;
+    }
+}