ss14Starlight · Proximitron · Aug 27, 2026 · Aug 27, 2026 · Aug 27, 2026 · Aug 27, 2026
@@ -6,16 +6,27 @@
 using Robust.Client.UserInterface;
 using Robust.Shared.Map;
 
+#region Starlight
+using Content.Shared.Medical.CrewMonitoring;
+using Content.Shared.Silicons.StationAi;
+using Robust.Shared.Player;
+#endregion Starlight
+
 namespace Content.Client.Shuttles.BUI;
 
 [UsedImplicitly]
 public sealed class ShuttleConsoleBoundUserInterface : BoundUserInterface
 {
+    #region Starlight
+    [Dependency] private ISharedPlayerManager _playerManager = default!;
+    #endregion Starlight
+
     [ViewVariables]
     private ShuttleConsoleWindow? _window;
 
     public ShuttleConsoleBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
     {
+        IoCManager.InjectDependencies(this); // Starlight
     }
 
     protected override void Open()
@@ -27,6 +38,7 @@
         _window.RequestBeaconFTL += OnFTLBeaconRequest;
         _window.DockRequest += OnDockRequest;
         _window.UndockRequest += OnUndockRequest;
+        _window.RadarClicked += OnRadarClicked; // Starlight
     }
 
     private void OnUndockRequest(NetEntity entity)
@@ -70,10 +82,25 @@
 
         if (disposing)
         {
+            // Starlight - start
+            if (_window != null)
+                _window.RadarClicked -= OnRadarClicked;
+            // Starlight - end
             _window?.DisposePopOut(); // Starlight: close the popout if exists
         }
     }
 
+    #region Starlight
+    private void OnRadarClicked(EntityCoordinates coordinates)
+    {
+        var local = _playerManager.LocalEntity;
+        if (local is null || !EntMan.HasComponent<StationAiHeldComponent>(local.Value))
+            return;
+
+        SendMessage(new CrewMonitoringWarpRequestMessage(EntMan.GetNetCoordinates(coordinates)));
+    }
+    #endregion Starlight
+
     protected override void UpdateState(BoundUserInterfaceState state)
     {
         base.UpdateState(state);

@@ -19,6 +19,10 @@
     private EntityUid? _consoleEntity; // Entity of controlling console
     private EntityUid? _shuttleEntity;
 
+    #region Starlight
+    public event Action<EntityCoordinates>? OnRadarClick;
+    #endregion Starlight
+
     public NavScreen()
     {
         RobustXamlLoader.Load(this);
@@ -30,6 +34,10 @@
 
         DockToggle.OnToggled += OnDockTogglePressed;
         DockToggle.Pressed = NavRadar.ShowDocks;
+
+        // Starlight - start
+        NavRadar.OnRadarClick += OnRadarClickPressed;
+        // Starlight - end
     }
 
     public void SetShuttle(EntityUid? shuttle)
@@ -55,6 +63,13 @@
         args.Button.Pressed = NavRadar.ShowDocks;
     }
 
+    #region Starlight
+    private void OnRadarClickPressed(EntityCoordinates coordinates)
+    {
+        OnRadarClick?.Invoke(coordinates);
+    }
+    #endregion
+
     public void UpdateState(NavInterfaceState scc, DockingPortStates dockingPortStates) // Starlight: +dockingPortStates
     {
         NavRadar.UpdateState(scc, dockingPortStates); // Starlight: +dockingPortStates

@@ -27,6 +27,10 @@
     public event Action<NetEntity, NetEntity>? DockRequest;
     public event Action<NetEntity>? UndockRequest;
 
+    #region Starlight
+    public event Action<EntityCoordinates>? RadarClicked;
+    #endregion Starlight
+
     public ShuttleConsoleWindow()
     {
         RobustXamlLoader.Load(this);
@@ -47,6 +51,8 @@
         NavModeButton.Pressed = true;
         SetupMode(_mode);
 
+        NavContainer.OnRadarClick += OnRadarClick; // Starlight
+
         MapContainer.RequestFTL += (coords, angle) =>
         {
             RequestFTL?.Invoke(coords, angle);
@@ -68,6 +74,13 @@
         };
     }
 
+    #region Starlight
+    private void OnRadarClick(EntityCoordinates coordinates)
+    {
+        RadarClicked?.Invoke(coordinates);
+    }
+    #endregion
+
     private void ClearModes(ShuttleConsoleMode mode)
     {
         if (mode != ShuttleConsoleMode.Nav)

@@ -76,15 +76,25 @@ protected override void Draw(in OverlayDrawArgs args)
 
         // Check for cross-grid viewing (e.g., Abductor remote eye) BEFORE getting gridUid
         if (_entManager.TryGetComponent(playerEnt, out StationAiOverlayComponent? stationAiOverlay)
-            && stationAiOverlay.AllowCrossGrid
+            && (stationAiOverlay.AllowCrossGrid || _entManager.HasComponent<StationAiHeldComponent>(playerEnt))
             && _entManager.TryGetComponent(playerEnt, out RelayInputMoverComponent? relay))
             playerEnt = relay.RelayEntity;
 
         _entManager.TryGetComponent(playerEnt, out StationAiOverlayComponent? relayStationAiOverlay);
         _entManager.TryGetComponent(playerEnt, out TransformComponent? playerXform);
 
+        // We try to figure out where the AI is even coming from to make sure we don't render cameras for remote grids without access
+        EntityUid? sourceGrid = null;
+        var stationAiSystem = _entManager.System<SharedStationAiSystem>();
+        if (_player.LocalEntity is EntityUid localEntity)
+            if (stationAiSystem.TryGetCore(localEntity, out var core) && core.Comp is not null)
+                sourceGrid = _entManager.GetComponent<TransformComponent>(core.Owner).GridUid;
+
         var gridUid = playerXform?.GridUid
-            ?? (stationAiOverlay is { AllowCrossGrid: true } ? _lastGridUid : EntityUid.Invalid);
+            ?? (stationAiOverlay is { AllowCrossGrid: true } ||
+                _entManager.HasComponent<StationAiHeldComponent>(_player.LocalEntity)
+                ? _lastGridUid
+                : EntityUid.Invalid);
         if (gridUid != EntityUid.Invalid)
             _lastGridUid = gridUid;
 
@@ -113,7 +123,7 @@ protected override void Draw(in OverlayDrawArgs args)
                 _visibleTiles.Clear();
                 // Starlight - start
                 _visibleTileTags.Clear();
-                _entManager.System<StationAiVisionSystem>().GetView((gridUid, broadphase, grid), worldBounds, _visibleTiles, _visibleTileTags);
+                _entManager.System<StationAiVisionSystem>().GetView((gridUid, broadphase, grid), worldBounds, _visibleTiles, _visibleTileTags, sourceGrid: sourceGrid);
                 // Starlight - end
             }
 

@@ -1,6 +1,7 @@
 using Content.Server.DeviceNetwork.Components;
 using Content.Server.Station.Systems;
 using Content.Shared.DeviceNetwork.Events;
+using Content.Shared.Maps;
 using JetBrains.Annotations;
 using Robust.Shared.Map;
 
@@ -13,6 +14,9 @@
     public sealed partial class StationLimitedNetworkSystem : EntitySystem
     {
         [Dependency] private StationSystem _stationSystem = default!;
+        #region Starlight
+        [Dependency] private SharedGridAccessSystem _gridAccess = default!;
+        #endregion
         public override void Initialize()
         {
             base.Initialize();
@@ -59,12 +63,25 @@
             if (!component.StationId.HasValue)
                 TrySetStationId(uid, component);
 
-            if (!CheckStationId(args.Sender, component.AllowNonStationPackets, component.StationId))
+            if (!CheckStationId(args.Sender, component.AllowNonStationPackets, component.StationId) &&
+                !CanAccessSenderGrid(uid, args.Sender)) // Starlight: allow access if the sender and receiver are on grids that can access each other
             {
                 args.Cancel();
             }
         }
 
+        #region Starlight
+        private bool CanAccessSenderGrid(EntityUid receiver, EntityUid sender)
+        {
+            var receiverGrid = Transform(receiver).GridUid;
+            var senderGrid = Transform(sender).GridUid;
+
+            return receiverGrid is { } targetGrid && senderGrid is { } sourceGrid &&
+                   (_gridAccess.CanAccess(sourceGrid, targetGrid) ||
+                    _gridAccess.CanAccess(targetGrid, sourceGrid));
+        }
+        #endregion Starlight
+
         /// <summary>
         /// Compares the station IDs of the sending and receiving network components.
         /// Returns false if either of them doesn't have a station ID or if their station ID isn't equal.

@@ -105,6 +105,11 @@ private void OnHolopadStartNewCall(Entity<HolopadComponent> source, ref HolopadS
         if (!TryComp<TelephoneComponent>(receiver, out var receiverTelephone))
             return;
 
+        // Starlight - start
+        if (HasComp<StationAiHeldComponent>(args.Actor) &&
+            !_stationAiSystem.CanAccessGrid(args.Actor, Transform(receiver).GridUid))
+            return;
+        // Starlight - end
         LinkHolopadToUser(source, args.Actor);
         _telephoneSystem.CallTelephone((source, sourceTelephone), (receiver, receiverTelephone), args.Actor);
     }
@@ -127,15 +132,6 @@ private void OnHolopadAnswerCall(Entity<HolopadComponent> receiver, ref HolopadA
                 if (_stationAiSystem.TryGetCore(args.Actor, out var stationAiCore))
                     _userInterfaceSystem.CloseUi(receiver.Owner, HolopadUiKey.AiRequestWindow, args.Actor);
 
-                // Try to warn the AI if the source of the call is out of its range
-                if (TryComp<TelephoneComponent>(stationAiCore, out var stationAiTelephone) &&
-                    TryComp<TelephoneComponent>(source, out var sourceTelephone) &&
-                    !_telephoneSystem.IsSourceInRangeOfReceiver((stationAiCore.Owner, stationAiTelephone), (source.Value.Owner, sourceTelephone)))
-                {
-                    _popupSystem.PopupEntity(Loc.GetString("holopad-ai-is-unable-to-reach-holopad"), receiver, args.Actor);
-                    return;
-                }
-
                 ActivateProjector(source.Value, args.Actor);
             }
 
@@ -673,8 +669,18 @@ private void ActivateProjector(Entity<HolopadComponent> entity, EntityUid user)
 
         var source = new Entity<TelephoneComponent>(stationAiCore, stationAiTelephone);
 
+        // Starlight - start
+        // We check if the AI has grid access. Normal projector call are range limited, not limited by grid access. The AI is special.
+        if (!_stationAiSystem.CanAccessGrid(user, Transform(entity).GridUid))
+        {
+            _popupSystem.PopupEntity(Loc.GetString("holopad-ai-is-unable-to-activate-projector"), receiver, user);
+            return;
+        }
+        // Starlight - end
+
         // Check if the AI is unable to activate the projector (unlikely this will ever pass; its just a safeguard)
-        if (!_telephoneSystem.IsSourceInRangeOfReceiver(source, receiver))
+        if (!_telephoneSystem.IsTelephonePowered(source) ||
+            !_telephoneSystem.IsTelephonePowered(receiver)) // Starlight: check replaced with sensible check based on power
         {
             _popupSystem.PopupEntity(Loc.GetString("holopad-ai-is-unable-to-activate-projector"), receiver, user);
             return;
@@ -685,6 +691,7 @@ private void ActivateProjector(Entity<HolopadComponent> entity, EntityUid user)
 
         var callOptions = new TelephoneCallOptions()
         {
+            IgnoreRange = true, // Starlight: we do check things in advance and have safeguards in place
             ForceConnect = true,
             MuteReceiver = true
         };

@@ -2,11 +2,24 @@
 using Content.Server.Shuttles.Events;
 using Content.Shared.Station.Components;
 using Content.Shared.UserInterface;
+using Content.Server.Power.Components;
+using Content.Server.Power.EntitySystems;
+using Content.Shared.Maps;
 
 namespace Content.Server.Shuttles.Systems;
 
 public sealed partial class ShuttleConsoleSystem
 {
+    #region Starlight
+    [Dependency] private SharedGridAccessSystem _gridAccess = default!;
+    private readonly Dictionary<EntityUid, (EntityUid SourceGrid, EntityUid TargetGrid)> _remoteGridAccess = new();
+
+    private void OnDroneConsoleStartup(EntityUid uid, DroneConsoleComponent component, ComponentStartup args)
+    {
+        UpdateRemoteGridAccess(uid, component);
+    }
+    #endregion Starlight
+
     /// <summary>
     /// Gets the drone console target if applicable otherwise returns itself.
     /// </summary>
@@ -30,13 +43,17 @@
 
         while (query.MoveNext(out var uid, out var comp))
         {
-            comp.Entity = GetShuttleConsole(uid, comp);
+            // Starlight - start
+            UpdateRemoteGridAccess(uid, comp);
+            // Starlight - end
         }
     }
 
     private void OnDronePilotConsoleOpen(EntityUid uid, DroneConsoleComponent component, AfterActivatableUIOpenEvent args)
     {
-        component.Entity = GetShuttleConsole(uid);
+        // Starlight - start
+        UpdateRemoteGridAccess(uid, component);
+        // Starlight - end
     }
 
     private void OnDronePilotConsoleClose(EntityUid uid, DroneConsoleComponent component, BoundUIClosedEvent args)
@@ -48,8 +65,74 @@
 
     private void OnCargoGetConsole(EntityUid uid, DroneConsoleComponent component, ref ConsoleShuttleEvent args)
     {
-        args.Console = GetShuttleConsole(uid, component);
+        // Starlight - start
+        UpdateRemoteGridAccess(uid, component);
+        // Starlight - end
+        args.Console = component.Entity;
+    }
+
+    #region Starlight
+    private void UpdateRemoteGridAccess(EntityUid uid, DroneConsoleComponent component)
+    {
+        // Starlight - start
+        var targetConsole = GetShuttleConsole(uid, component);
+        var sourceGrid = Transform(uid).GridUid;
+        var targetGrid = targetConsole is { } target
+            ? Transform(target).GridUid
+            : null;
+
+        if (_remoteGridAccess.TryGetValue(uid, out var previous) &&
+            (sourceGrid != previous.SourceGrid || targetGrid != previous.TargetGrid ||
+             !IsConsoleOperational(uid) || targetConsole is not { } currentTarget || !IsConsoleOperational(currentTarget)))
+        {
+            RemoveRemoteGridAccess(uid);
+        }
+
+        component.Entity = targetConsole;
+
+        if (sourceGrid is not { } source || targetGrid is not { } targetUid ||
+            targetConsole is not { } console ||
+            !IsConsoleOperational(uid) || !IsConsoleOperational(console))
+        {
+            return;
+        }
+
+        if (_remoteGridAccess.ContainsKey(uid))
+            return;
+
+        _gridAccess.AddAccessibleGrid(source, targetUid);
+        _remoteGridAccess[uid] = (source, targetUid);
+        // Starlight - end
+    }
+
+    private void RemoveRemoteGridAccess(EntityUid uid)
+    {
+        // Starlight - start
+        if (!_remoteGridAccess.Remove(uid, out var access))
+            return;
+
+        foreach (var other in _remoteGridAccess.Values)
+        {
+            if (other != access)
+                continue;
+
+            return;
+        }
+
+        _gridAccess.RemoveAccessibleGrid(access.SourceGrid, access.TargetGrid);
+        // Starlight - end
+    }
+
+    private bool IsConsoleOperational(EntityUid uid)
+    {
+        // Starlight - start
+        return TryComp<ShuttleConsoleComponent>(uid, out _) &&
+               MetaData(uid).EntityLifeStage < EntityLifeStage.Terminating &&
+               Transform(uid).Anchored &&
+               this.IsPowered(uid, EntityManager);
+        // Starlight - end
     }
+    #endregion Starlight
 
     /// <summary>
     /// Gets the relevant shuttle console to proxy from the drone console.