From 7780b867acd6fe34ff066aa48660c1e5dc60ffde Mon Sep 17 00:00:00 2001
From: chromiumboy <50505512+chromiumboy@users.noreply.github.com>
Date: Tue, 17 Dec 2024 13:18:15 -0600
Subject: [PATCH] Holopads (#32711)

* Initial resources commit

* Initial code commit

* Added additional resources

* Continuing to build holopad and telephone systems

* Added hologram shader

* Added hologram system and entity

* Holo calls now have a hologram of the user appear on them

* Initial implementation of holopads transmitting nearby chatter

* Added support for linking across multiple telephones/holopads/entities

* Fixed a bunch of bugs

* Tried simplifying holopad entity dependence, added support for mid-call user switching

* Replaced PVS expansion with manually networked sprite states

* Adjusted volume of ring tone

* Added machine board

* Minor features and tweaks

* Resolving merge conflict

* Recommit audio attributions

* Telephone chat adjustments

* Added support for AI interactions with holopads

* Building the holopad UI

* Holopad UI finished

* Further UI tweaks

* Station AI can hear local chatter when being projected from a holopad

* Minor bug fixes

* Added wire panels to holopads

* Basic broadcasting

* Start of emergency broadcasting code

* Fixing issues with broadcasting

* More work on emergency broadcasting

* Updated holopad visuals

* Added cooldown text to emergency broadcast and control lock out screen

* Code clean up

* Fixed issue with timing

* Broadcasting now requires command access

* Fixed some bugs

* Added multiple holopad prototypes with different ranges

* The AI no longer requires power to interact with holopads

* Fixed some additional issues

* Addressing more issues

* Added emote support for holograms

* Changed the broadcast lockout durations to their proper values

* Added AI vision wire to holopads

* Bug fixes

* AI vision and interaction wires can be added to the same wire panel

* Fixed error

* More bug fixes

* Fixed test fail

* Embellished the emergency call lock out window

* Holopads play borg sounds when speaking

* Borg and AI names are listed as the caller ID on the holopad

* Borg chassis can now be seen on holopad holograms

* Holopad returns to a machine frame when badly damaged

* Clarified some text

* Fix merge conflict

* Fixed merge conflict

* Fixing merge conflict

* Fixing merge conflict

* Fixing merge conflict

* Offset menu on open

* AI can alt click on holopads to activate the projector

* Bug fixes for intellicard interactions

* Fixed speech issue with intellicards

* The UI automatically opens for the AI when it alt-clicks on the holopad

* Simplified shader math

* Telephones will auto hang up 60 seconds after the last person on a call stops speaking

* Added better support for AI requests when multiple AI cores are on the station

* The call controls pop up for the AI when they accept a summons from a holopad

* Compatibility mode fix for the hologram shader

* Further shader fixes for compatibility mode

* File clean up

* More cleaning up

* Removed access requirements from quantum holopads so they can used by nukies

* The title of the holopad window now reflects the name of the device

* Linked telephones will lose their connection if both move out of range of each other
---
 Content.Client/Chat/UI/SpeechBubble.cs        |   8 +-
 .../Holopad/HolopadBoundUserInterface.cs      | 101 +++
 Content.Client/Holopad/HolopadSystem.cs       | 172 ++++
 Content.Client/Holopad/HolopadWindow.xaml     | 107 +++
 Content.Client/Holopad/HolopadWindow.xaml.cs  | 338 ++++++++
 Content.Client/Stylesheets/StyleNano.cs       |  15 +
 Content.Client/Telephone/TelephoneSystem.cs   |   8 +
 Content.Server/Holopad/HolopadSystem.cs       | 761 ++++++++++++++++++
 .../Silicons/StationAi/AiVisionWireAction.cs  |   4 +-
 .../Silicons/StationAi/StationAiSystem.cs     |  41 +
 Content.Server/Telephone/TelephoneSystem.cs   | 468 +++++++++++
 Content.Shared/Doors/AirlockWireStatus.cs     |   3 +-
 .../Holopad/HolographicAvatarComponent.cs     |  13 +
 Content.Shared/Holopad/HolopadComponent.cs    | 133 +++
 .../Holopad/HolopadHologramComponent.cs       |  71 ++
 .../Holopad/HolopadUserComponent.cs           | 104 +++
 Content.Shared/Holopad/SharedHolopadSystem.cs |  43 +
 .../StationAi/SharedStationAiSystem.cs        |  88 +-
 .../StationAi/StationAiCoreComponent.cs       |  10 +
 Content.Shared/Speech/SpeechComponent.cs      |   6 +
 .../Telephone/SharedTelephoneSystem.cs        |  39 +
 .../Telephone/TelephoneComponent.cs           | 203 +++++
 Resources/Audio/Machines/attributions.yml     |   5 +
 Resources/Audio/Machines/double_ring.ogg      | Bin 0 -> 16754 bytes
 Resources/Locale/en-US/holopad/holopad.ftl    |  40 +
 .../Locale/en-US/telephone/telephone.ftl      |   8 +
 Resources/Locale/en-US/wires/wire-names.ftl   |   1 +
 .../Entities/Mobs/Player/silicon.yml          |  39 +
 .../Devices/Circuitboards/Machine/holopad.yml |  12 +
 .../Entities/Structures/Machines/holopad.yml  | 158 ++++
 Resources/Prototypes/Shaders/shaders.yml      |   5 +
 Resources/Prototypes/Wires/layouts.yml        |  10 +-
 Resources/Textures/Shaders/hologram.swsl      |  23 +
 .../Structures/Machines/holopad.rsi/base.png  | Bin 0 -> 457 bytes
 .../Structures/Machines/holopad.rsi/blank.png | Bin 0 -> 83 bytes
 .../Machines/holopad.rsi/icon_in_call.png     | Bin 0 -> 414 bytes
 .../Machines/holopad.rsi/lights_calling.png   | Bin 0 -> 425 bytes
 .../holopad.rsi/lights_hanging_up.png         | Bin 0 -> 432 bytes
 .../Machines/holopad.rsi/lights_in_call.png   | Bin 0 -> 326 bytes
 .../Machines/holopad.rsi/lights_ringing.png   | Bin 0 -> 4429 bytes
 .../Structures/Machines/holopad.rsi/meta.json | 100 +++
 .../Machines/holopad.rsi/panel_open.png       | Bin 0 -> 221 bytes
 .../Machines/holopad.rsi/unpowered.png        | Bin 0 -> 441 bytes
 43 files changed, 3129 insertions(+), 8 deletions(-)
 create mode 100644 Content.Client/Holopad/HolopadBoundUserInterface.cs
 create mode 100644 Content.Client/Holopad/HolopadSystem.cs
 create mode 100644 Content.Client/Holopad/HolopadWindow.xaml
 create mode 100644 Content.Client/Holopad/HolopadWindow.xaml.cs
 create mode 100644 Content.Client/Telephone/TelephoneSystem.cs
 create mode 100644 Content.Server/Holopad/HolopadSystem.cs
 create mode 100644 Content.Server/Telephone/TelephoneSystem.cs
 create mode 100644 Content.Shared/Holopad/HolographicAvatarComponent.cs
 create mode 100644 Content.Shared/Holopad/HolopadComponent.cs
 create mode 100644 Content.Shared/Holopad/HolopadHologramComponent.cs
 create mode 100644 Content.Shared/Holopad/HolopadUserComponent.cs
 create mode 100644 Content.Shared/Holopad/SharedHolopadSystem.cs
 create mode 100644 Content.Shared/Telephone/SharedTelephoneSystem.cs
 create mode 100644 Content.Shared/Telephone/TelephoneComponent.cs
 create mode 100644 Resources/Audio/Machines/double_ring.ogg
 create mode 100644 Resources/Locale/en-US/holopad/holopad.ftl
 create mode 100644 Resources/Locale/en-US/telephone/telephone.ftl
 create mode 100644 Resources/Prototypes/Entities/Objects/Devices/Circuitboards/Machine/holopad.yml
 create mode 100644 Resources/Prototypes/Entities/Structures/Machines/holopad.yml
 create mode 100644 Resources/Textures/Shaders/hologram.swsl
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/base.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/blank.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/icon_in_call.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/lights_calling.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/lights_hanging_up.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/lights_in_call.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/lights_ringing.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/meta.json
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/panel_open.png
 create mode 100644 Resources/Textures/Structures/Machines/holopad.rsi/unpowered.png

diff --git a/Content.Client/Chat/UI/SpeechBubble.cs b/Content.Client/Chat/UI/SpeechBubble.cs
index 32e9f4ae9b..aa61e73e31 100644
--- a/Content.Client/Chat/UI/SpeechBubble.cs
+++ b/Content.Client/Chat/UI/SpeechBubble.cs
@@ -2,6 +2,7 @@ using System.Numerics;
 using Content.Client.Chat.Managers;
 using Content.Shared.CCVar;
 using Content.Shared.Chat;
+using Content.Shared.Speech;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
@@ -141,7 +142,12 @@ namespace Content.Client.Chat.UI
                 Modulate = Color.White;
             }
 
-            var offset = (-_eyeManager.CurrentEye.Rotation).ToWorldVec() * -EntityVerticalOffset;
+            var baseOffset = 0f;
+
+           if (_entityManager.TryGetComponent<SpeechComponent>(_senderEntity, out var speech))
+                baseOffset = speech.SpeechBubbleOffset;
+
+            var offset = (-_eyeManager.CurrentEye.Rotation).ToWorldVec() * -(EntityVerticalOffset + baseOffset);
             var worldPos = _transformSystem.GetWorldPosition(xform) + offset;
 
             var lowerCenter = _eyeManager.WorldToScreen(worldPos) / UIScale;
diff --git a/Content.Client/Holopad/HolopadBoundUserInterface.cs b/Content.Client/Holopad/HolopadBoundUserInterface.cs
new file mode 100644
index 0000000000..20b55ea8c7
--- /dev/null
+++ b/Content.Client/Holopad/HolopadBoundUserInterface.cs
@@ -0,0 +1,101 @@
+using Content.Shared.Holopad;
+using Content.Shared.Silicons.StationAi;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Shared.Player;
+using System.Numerics;
+
+namespace Content.Client.Holopad;
+
+public sealed class HolopadBoundUserInterface : BoundUserInterface
+{
+    [Dependency] private readonly ISharedPlayerManager _playerManager = default!;
+    [Dependency] private readonly IClyde _displayManager = default!;
+
+    [ViewVariables]
+    private HolopadWindow? _window;
+
+    public HolopadBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<HolopadWindow>();
+        _window.Title = Loc.GetString("holopad-window-title", ("title", EntMan.GetComponent<MetaDataComponent>(Owner).EntityName));
+
+        if (this.UiKey is not HolopadUiKey)
+        {
+            Close();
+            return;
+        }
+
+        var uiKey = (HolopadUiKey)this.UiKey;
+
+        // AIs will see a different holopad interface to crew when interacting with them in the world
+        if (uiKey == HolopadUiKey.InteractionWindow && EntMan.HasComponent<StationAiHeldComponent>(_playerManager.LocalEntity))
+            uiKey = HolopadUiKey.InteractionWindowForAi;
+
+        _window.SetState(Owner, uiKey);
+        _window.UpdateState(new Dictionary<NetEntity, string>());
+
+        // Set message actions
+        _window.SendHolopadStartNewCallMessageAction += SendHolopadStartNewCallMessage;
+        _window.SendHolopadAnswerCallMessageAction += SendHolopadAnswerCallMessage;
+        _window.SendHolopadEndCallMessageAction += SendHolopadEndCallMessage;
+        _window.SendHolopadStartBroadcastMessageAction += SendHolopadStartBroadcastMessage;
+        _window.SendHolopadActivateProjectorMessageAction += SendHolopadActivateProjectorMessage;
+        _window.SendHolopadRequestStationAiMessageAction += SendHolopadRequestStationAiMessage;
+
+        // If this call is addressed to an AI, open the window in the bottom right hand corner of the screen
+        if (uiKey == HolopadUiKey.AiRequestWindow)
+            _window.OpenCenteredAt(new Vector2(1f, 1f));
+
+        // Otherwise offset to the left so the holopad can still be seen
+        else
+            _window.OpenCenteredAt(new Vector2(0.3333f, 0.50f));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        var castState = (HolopadBoundInterfaceState)state;
+        EntMan.TryGetComponent<TransformComponent>(Owner, out var xform);
+
+        _window?.UpdateState(castState.Holopads);
+    }
+
+    public void SendHolopadStartNewCallMessage(NetEntity receiver)
+    {
+        SendMessage(new HolopadStartNewCallMessage(receiver));
+    }
+
+    public void SendHolopadAnswerCallMessage()
+    {
+        SendMessage(new HolopadAnswerCallMessage());
+    }
+
+    public void SendHolopadEndCallMessage()
+    {
+        SendMessage(new HolopadEndCallMessage());
+    }
+
+    public void SendHolopadStartBroadcastMessage()
+    {
+        SendMessage(new HolopadStartBroadcastMessage());
+    }
+
+    public void SendHolopadActivateProjectorMessage()
+    {
+        SendMessage(new HolopadActivateProjectorMessage());
+    }
+
+    public void SendHolopadRequestStationAiMessage()
+    {
+        SendMessage(new HolopadStationAiRequestMessage());
+    }
+}
diff --git a/Content.Client/Holopad/HolopadSystem.cs b/Content.Client/Holopad/HolopadSystem.cs
new file mode 100644
index 0000000000..3bd556f1fc
--- /dev/null
+++ b/Content.Client/Holopad/HolopadSystem.cs
@@ -0,0 +1,172 @@
+using Content.Shared.Chat.TypingIndicator;
+using Content.Shared.Holopad;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using System.Linq;
+
+namespace Content.Client.Holopad;
+
+public sealed class HolopadSystem : SharedHolopadSystem
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HolopadHologramComponent, ComponentInit>(OnComponentInit);
+        SubscribeLocalEvent<HolopadHologramComponent, BeforePostShaderRenderEvent>(OnShaderRender);
+        SubscribeAllEvent<TypingChangedEvent>(OnTypingChanged);
+
+        SubscribeNetworkEvent<PlayerSpriteStateRequest>(OnPlayerSpriteStateRequest);
+        SubscribeNetworkEvent<PlayerSpriteStateMessage>(OnPlayerSpriteStateMessage);
+    }
+
+    private void OnComponentInit(EntityUid uid, HolopadHologramComponent component, ComponentInit ev)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        UpdateHologramSprite(uid);
+    }
+
+    private void OnShaderRender(EntityUid uid, HolopadHologramComponent component, BeforePostShaderRenderEvent ev)
+    {
+        if (ev.Sprite.PostShader == null)
+            return;
+
+        ev.Sprite.PostShader.SetParameter("t", (float)_timing.CurTime.TotalSeconds * component.ScrollRate);
+    }
+
+    private void OnTypingChanged(TypingChangedEvent ev, EntitySessionEventArgs args)
+    {
+        var uid = args.SenderSession.AttachedEntity;
+
+        if (!Exists(uid))
+            return;
+
+        if (!HasComp<HolopadUserComponent>(uid))
+            return;
+
+        var netEv = new HolopadUserTypingChangedEvent(GetNetEntity(uid.Value), ev.IsTyping);
+        RaiseNetworkEvent(netEv);
+    }
+
+    private void OnPlayerSpriteStateRequest(PlayerSpriteStateRequest ev)
+    {
+        var targetPlayer = GetEntity(ev.TargetPlayer);
+        var player = _playerManager.LocalSession?.AttachedEntity;
+
+        // Ignore the request if received by a player who isn't the target
+        if (targetPlayer != player)
+            return;
+
+        if (!TryComp<SpriteComponent>(player, out var playerSprite))
+            return;
+
+        var spriteLayerData = new List<PrototypeLayerData>();
+
+        if (playerSprite.Visible)
+        {
+            // Record the RSI paths, state names and shader paramaters of all visible layers
+            for (int i = 0; i < playerSprite.AllLayers.Count(); i++)
+            {
+                if (!playerSprite.TryGetLayer(i, out var layer))
+                    continue;
+
+                if (!layer.Visible ||
+                    string.IsNullOrEmpty(layer.ActualRsi?.Path.ToString()) ||
+                    string.IsNullOrEmpty(layer.State.Name))
+                    continue;
+
+                var layerDatum = new PrototypeLayerData();
+                layerDatum.RsiPath = layer.ActualRsi.Path.ToString();
+                layerDatum.State = layer.State.Name;
+
+                if (layer.CopyToShaderParameters != null)
+                {
+                    var key = (string)layer.CopyToShaderParameters.LayerKey;
+
+                    if (playerSprite.LayerMapTryGet(key, out var otherLayerIdx) &&
+                        playerSprite.TryGetLayer(otherLayerIdx, out var otherLayer) &&
+                        otherLayer.Visible)
+                    {
+                        layerDatum.MapKeys = new() { key };
+
+                        layerDatum.CopyToShaderParameters = new PrototypeCopyToShaderParameters()
+                        {
+                            LayerKey = key,
+                            ParameterTexture = layer.CopyToShaderParameters.ParameterTexture,
+                            ParameterUV = layer.CopyToShaderParameters.ParameterUV
+                        };
+                    }
+                }
+
+                spriteLayerData.Add(layerDatum);
+            }
+        }
+
+        // Return the recorded data to the server
+        var evResponse = new PlayerSpriteStateMessage(ev.TargetPlayer, spriteLayerData.ToArray());
+        RaiseNetworkEvent(evResponse);
+    }
+
+    private void OnPlayerSpriteStateMessage(PlayerSpriteStateMessage ev)
+    {
+        UpdateHologramSprite(GetEntity(ev.SpriteEntity), ev.SpriteLayerData);
+    }
+
+    private void UpdateHologramSprite(EntityUid uid, PrototypeLayerData[]? layerData = null)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var hologramSprite))
+            return;
+
+        if (!TryComp<HolopadHologramComponent>(uid, out var holopadhologram))
+            return;
+
+        for (int i = hologramSprite.AllLayers.Count() - 1; i >= 0; i--)
+            hologramSprite.RemoveLayer(i);
+
+        if (layerData == null || layerData.Length == 0)
+        {
+            layerData = new PrototypeLayerData[1];
+            layerData[0] = new PrototypeLayerData()
+            {
+                RsiPath = holopadhologram.RsiPath,
+                State = holopadhologram.RsiState
+            };
+        }
+
+        for (int i = 0; i < layerData.Length; i++)
+        {
+            var layer = layerData[i];
+            layer.Shader = "unshaded";
+
+            hologramSprite.AddLayer(layerData[i], i);
+        }
+
+        UpdateHologramShader(uid, hologramSprite, holopadhologram);
+    }
+
+    private void UpdateHologramShader(EntityUid uid, SpriteComponent sprite, HolopadHologramComponent holopadHologram)
+    {
+        // Find the texture height of the largest layer
+        float texHeight = sprite.AllLayers.Max(x => x.PixelSize.Y);
+
+        var instance = _prototypeManager.Index<ShaderPrototype>(holopadHologram.ShaderName).InstanceUnique();
+        instance.SetParameter("color1", new Vector3(holopadHologram.Color1.R, holopadHologram.Color1.G, holopadHologram.Color1.B));
+        instance.SetParameter("color2", new Vector3(holopadHologram.Color2.R, holopadHologram.Color2.G, holopadHologram.Color2.B));
+        instance.SetParameter("alpha", holopadHologram.Alpha);
+        instance.SetParameter("intensity", holopadHologram.Intensity);
+        instance.SetParameter("texHeight", texHeight);
+        instance.SetParameter("t", (float)_timing.CurTime.TotalSeconds * holopadHologram.ScrollRate);
+
+        sprite.PostShader = instance;
+        sprite.RaiseShaderEvent = true;
+    }
+}
diff --git a/Content.Client/Holopad/HolopadWindow.xaml b/Content.Client/Holopad/HolopadWindow.xaml
new file mode 100644
index 0000000000..9c3dfab1ea
--- /dev/null
+++ b/Content.Client/Holopad/HolopadWindow.xaml
@@ -0,0 +1,107 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+               xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+               xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+               Resizable="False"
+               MaxSize="400 800"
+               MinSize="400 150">
+    <BoxContainer Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True">
+
+        <BoxContainer Name="ControlsLockOutContainer" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" ReservesSpace="False" Visible="False">
+            <!-- Header text -->
+            <controls:StripeBack>
+                <PanelContainer>
+                    <RichTextLabel Name="EmergencyBroadcastText" VerticalAlignment="Center" HorizontalAlignment="Center" Margin="10 10 10 10" ReservesSpace="False"/>
+                </PanelContainer>
+            </controls:StripeBack>
+            
+            <Label Text="{Loc 'holopad-window-controls-locked-out'}" HorizontalAlignment="Center" Margin="10 5 10 0" ReservesSpace="False"/>
+            <RichTextLabel Name="LockOutIdText" HorizontalAlignment="Center" Margin="10 5 10 0" ReservesSpace="False"/>
+            <Label Name="LockOutCountDownText" Text="{Loc 'holopad-window-controls-unlock-countdown'}" HorizontalAlignment="Center" Margin="10 15 10 10" ReservesSpace="False"/>
+        </BoxContainer>
+
+        <BoxContainer Name="ControlsContainer" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" ReservesSpace="False">
+        
+            <!-- Active call controls (either this or the call placement controls will be active) -->
+            <BoxContainer Name="ActiveCallControlsContainer" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" ReservesSpace="False">
+
+                <!-- Header text -->
+                <BoxContainer MinHeight="60" Orientation="Vertical" VerticalAlignment="Center">
+                    <Label Name="CallStatusText" Margin="10 5 10 0" ReservesSpace="False"/>
+                    <RichTextLabel Name="CallerIdText" HorizontalAlignment="Center" Margin="0 0 0 0" ReservesSpace="False"/>
+                </BoxContainer>
+
+                <!-- Controls (the answer call button is absent when the phone is not ringing) -->
+                <GridContainer Columns="2" ReservesSpace="False">
+                    <Control HorizontalExpand="True" Margin="10 0 2 5">
+                        <Button Name="AnswerCallButton" Text="{Loc 'holopad-window-answer-call'}" StyleClasses="OpenRight" Margin="0 0 0 5" Disabled="True"/>
+                    </Control>
+                    <Control HorizontalExpand="True" Margin="2 0 10 5">
+                        <Button Name="EndCallButton" Text="{Loc 'holopad-window-end-call'}" StyleClasses="OpenLeft" Margin="0 0 0 5" Disabled="True"/>
+                    </Control>
+                </GridContainer>
+
+            </BoxContainer>
+
+            <!-- Call placement controls (either this or the active call controls will be active) -->
+            <BoxContainer Name="CallPlacementControlsContainer" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" ReservesSpace="False">
+
+                <controls:StripeBack>
+                    <PanelContainer>
+                        <BoxContainer Orientation="Vertical">
+                            <RichTextLabel Name="SubtitleText" HorizontalAlignment="Center" Margin="0 5 0 0"/>
+                            <RichTextLabel Name="OptionsText" HorizontalAlignment="Center" Margin="0 0 0 5"/>
+                        </BoxContainer>
+                    </PanelContainer>
+                </controls:StripeBack>
+
+                <!-- Request the station AI or activate the holopad projector (only one of these should be active at a time) -->
+                <BoxContainer Name="RequestStationAiContainer" Orientation="Vertical" ReservesSpace="False" Visible="False">
+                    <Button Name="RequestStationAiButton" Text="{Loc 'holopad-window-request-station-ai'}" Margin="10 5 10 5" Disabled="False"/>
+                </BoxContainer>
+
+                <BoxContainer Name="ActivateProjectorContainer" Orientation="Vertical" ReservesSpace="False" Visible="False">
+                    <Button Name="ActivateProjectorButton" Text="{Loc 'holopad-window-activate-projector'}" Margin="10 5 10 5" Disabled="False"/>
+                </BoxContainer>
+
+                <!-- List of contactable holopads (the list is created in C#) -->
+                <BoxContainer Name="HolopadContactListContainer" Orientation="Vertical" Margin="10 0 10 5" ReservesSpace="False" Visible="False">
+                    <PanelContainer Name="HolopadContactListHeaderPanel">
+                        <Label Text="{Loc 'holopad-window-select-contact-from-list'}" HorizontalAlignment="Center" Margin="0 3 0 3"/>
+                    </PanelContainer>
+                
+                    <PanelContainer Name="HolopadContactListPanel">
+                        <ScrollContainer HorizontalExpand="True" VerticalExpand="True" Margin="8, 8, 8, 8" MinHeight="256">
+
+                            <!-- If there is no data yet, this will be displayed -->
+                            <BoxContainer Name="FetchingAvailableHolopadsContainer" HorizontalAlignment="Center" HorizontalExpand="True" VerticalExpand="True" ReservesSpace="False">
+                                <Label Text="{Loc 'holopad-window-fetching-contacts-list'}" HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                            </BoxContainer>
+
+                            <!-- Container for the contacts -->
+                            <BoxContainer Name="ContactsList" Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True" Margin="10 0 10 0"/>
+                        </ScrollContainer>
+                    </PanelContainer>
+                </BoxContainer>
+
+                <!-- Button to start an emergency broadcast (the user requires a certain level of access to interact with it) -->
+                <BoxContainer Name="StartBroadcastContainer" Orientation="Vertical" ReservesSpace="False" Visible="False">
+                    <Button Name="StartBroadcastButton" Text="{Loc 'holopad-window-emergency-broadcast'}" Margin="10 0 10 5" Disabled="False" ReservesSpace="False"/>
+                </BoxContainer>
+
+            </BoxContainer>
+        </BoxContainer>
+
+        <!-- Footer -->
+        <BoxContainer Orientation="Vertical">
+            <PanelContainer StyleClasses="LowDivider" />
+            <BoxContainer Orientation="Horizontal" Margin="10 2 5 0" VerticalAlignment="Bottom">
+                <Label Text="{Loc 'holopad-window-flavor-left'}" StyleClasses="WindowFooterText" />
+                <Label Text="{Loc 'holopad-window-flavor-right'}" StyleClasses="WindowFooterText"
+                        HorizontalAlignment="Right" HorizontalExpand="True"  Margin="0 0 5 0" />
+                <TextureRect StyleClasses="NTLogoDark" Stretch="KeepAspectCentered"
+                        VerticalAlignment="Center" HorizontalAlignment="Right" SetSize="19 19"/>
+            </BoxContainer>
+        </BoxContainer>
+    </BoxContainer>
+
+</controls:FancyWindow>
diff --git a/Content.Client/Holopad/HolopadWindow.xaml.cs b/Content.Client/Holopad/HolopadWindow.xaml.cs
new file mode 100644
index 0000000000..bcab0d43df
--- /dev/null
+++ b/Content.Client/Holopad/HolopadWindow.xaml.cs
@@ -0,0 +1,338 @@
+using Content.Client.Popups;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Access.Systems;
+using Content.Shared.Holopad;
+using Content.Shared.Telephone;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+using System.Linq;
+
+namespace Content.Client.Holopad;
+
+[GenerateTypedNameReferences]
+public sealed partial class HolopadWindow : FancyWindow
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    private readonly SharedHolopadSystem _holopadSystem = default!;
+    private readonly SharedTelephoneSystem _telephoneSystem = default!;
+    private readonly AccessReaderSystem _accessReaderSystem = default!;
+    private readonly PopupSystem _popupSystem = default!;
+
+    private EntityUid? _owner = null;
+    private HolopadUiKey _currentUiKey;
+    private TelephoneState _currentState;
+    private TelephoneState _previousState;
+    private TimeSpan _buttonUnlockTime;
+    private float _updateTimer = 0.25f;
+
+    private const float UpdateTime = 0.25f;
+    private TimeSpan _buttonUnlockDelay = TimeSpan.FromSeconds(0.5f);
+
+    public event Action<NetEntity>? SendHolopadStartNewCallMessageAction;
+    public event Action? SendHolopadAnswerCallMessageAction;
+    public event Action? SendHolopadEndCallMessageAction;
+    public event Action? SendHolopadStartBroadcastMessageAction;
+    public event Action? SendHolopadActivateProjectorMessageAction;
+    public event Action? SendHolopadRequestStationAiMessageAction;
+
+    public HolopadWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        _holopadSystem = _entManager.System<SharedHolopadSystem>();
+        _telephoneSystem = _entManager.System<SharedTelephoneSystem>();
+        _accessReaderSystem = _entManager.System<AccessReaderSystem>();
+        _popupSystem = _entManager.System<PopupSystem>();
+
+        _buttonUnlockTime = _timing.CurTime + _buttonUnlockDelay;
+
+        // Assign button actions
+        AnswerCallButton.OnPressed += args => { OnHolopadAnswerCallMessage(); };
+        EndCallButton.OnPressed += args => { OnHolopadEndCallMessage(); };
+        StartBroadcastButton.OnPressed += args => { OnHolopadStartBroadcastMessage(); };
+        ActivateProjectorButton.OnPressed += args => { OnHolopadActivateProjectorMessage(); };
+        RequestStationAiButton.OnPressed += args => { OnHolopadRequestStationAiMessage(); };
+
+        // XML formatting
+        AnswerCallButton.AddStyleClass("ButtonAccept");
+        EndCallButton.AddStyleClass("Caution");
+        StartBroadcastButton.AddStyleClass("Caution");
+
+        HolopadContactListPanel.PanelOverride = new StyleBoxFlat
+        {
+            BackgroundColor = new Color(47, 47, 59) * Color.DarkGray,
+            BorderColor = new Color(82, 82, 82), //new Color(70, 73, 102),
+            BorderThickness = new Thickness(2),
+        };
+
+        HolopadContactListHeaderPanel.PanelOverride = new StyleBoxFlat
+        {
+            BackgroundColor = new Color(82, 82, 82),
+        };
+
+        EmergencyBroadcastText.SetMessage(FormattedMessage.FromMarkupOrThrow(Loc.GetString("holopad-window-emergency-broadcast-in-progress")));
+        SubtitleText.SetMessage(FormattedMessage.FromMarkupOrThrow(Loc.GetString("holopad-window-subtitle")));
+        OptionsText.SetMessage(FormattedMessage.FromMarkupOrThrow(Loc.GetString("holopad-window-options")));
+    }
+
+    #region: Button actions
+
+    private void OnSendHolopadStartNewCallMessage(NetEntity receiver)
+    {
+        SendHolopadStartNewCallMessageAction?.Invoke(receiver);
+    }
+
+    private void OnHolopadAnswerCallMessage()
+    {
+        SendHolopadAnswerCallMessageAction?.Invoke();
+    }
+
+    private void OnHolopadEndCallMessage()
+    {
+        SendHolopadEndCallMessageAction?.Invoke();
+
+        if (_currentUiKey == HolopadUiKey.AiRequestWindow)
+            Close();
+    }
+
+    private void OnHolopadStartBroadcastMessage()
+    {
+        if (_playerManager.LocalSession?.AttachedEntity == null || _owner == null)
+            return;
+
+        var player = _playerManager.LocalSession.AttachedEntity;
+
+        if (!_accessReaderSystem.IsAllowed(player.Value, _owner.Value))
+        {
+            _popupSystem.PopupClient(Loc.GetString("holopad-window-access-denied"), _owner.Value, player.Value);
+            return;
+        }
+
+        SendHolopadStartBroadcastMessageAction?.Invoke();
+    }
+
+    private void OnHolopadActivateProjectorMessage()
+    {
+        SendHolopadActivateProjectorMessageAction?.Invoke();
+    }
+
+    private void OnHolopadRequestStationAiMessage()
+    {
+        SendHolopadRequestStationAiMessageAction?.Invoke();
+    }
+
+    #endregion
+
+    public void SetState(EntityUid owner, HolopadUiKey uiKey)
+    {
+        _owner = owner;
+        _currentUiKey = uiKey;
+
+        // Determines what UI containers are available to the user.
+        // Components of these will be toggled on and off when
+        // UpdateAppearance() is called
+
+        switch (uiKey)
+        {
+            case HolopadUiKey.InteractionWindow:
+                RequestStationAiContainer.Visible = true;
+                HolopadContactListContainer.Visible = true;
+                StartBroadcastContainer.Visible = true;
+                break;
+
+            case HolopadUiKey.InteractionWindowForAi:
+                ActivateProjectorContainer.Visible = true;
+                StartBroadcastContainer.Visible = true;
+                break;
+
+            case HolopadUiKey.AiActionWindow:
+                HolopadContactListContainer.Visible = true;
+                StartBroadcastContainer.Visible = true;
+                break;
+
+            case HolopadUiKey.AiRequestWindow:
+                break;
+        }
+    }
+
+    public void UpdateState(Dictionary<NetEntity, string> holopads)
+    {
+        if (_owner == null || !_entManager.TryGetComponent<TelephoneComponent>(_owner.Value, out var telephone))
+            return;
+
+        // Caller ID text
+        var callerId = _telephoneSystem.GetFormattedCallerIdForEntity(telephone.LastCallerId.Item1, telephone.LastCallerId.Item2, Color.LightGray, "Default", 11);
+
+        CallerIdText.SetMessage(FormattedMessage.FromMarkupOrThrow(callerId));
+        LockOutIdText.SetMessage(FormattedMessage.FromMarkupOrThrow(callerId));
+
+        // Sort holopads alphabetically
+        var holopadArray = holopads.ToArray();
+        Array.Sort(holopadArray, AlphabeticalSort);
+
+        // Clear excess children from the contact list
+        while (ContactsList.ChildCount > holopadArray.Length)
+            ContactsList.RemoveChild(ContactsList.GetChild(ContactsList.ChildCount - 1));
+
+        // Make / update required children
+        for (int i = 0; i < holopadArray.Length; i++)
+        {
+            var (netEntity, label) = holopadArray[i];
+
+            if (i >= ContactsList.ChildCount)
+            {
+                var newContactButton = new HolopadContactButton();
+                newContactButton.OnPressed += args => { OnSendHolopadStartNewCallMessage(newContactButton.NetEntity); };
+
+                ContactsList.AddChild(newContactButton);
+            }
+
+            var child = ContactsList.GetChild(i);
+
+            if (child is not HolopadContactButton)
+                continue;
+
+            var contactButton = (HolopadContactButton)child;
+            contactButton.UpdateValues(netEntity, label);
+        }
+
+        // Update buttons
+        UpdateAppearance();
+    }
+
+    private void UpdateAppearance()
+    {
+        if (_owner == null || !_entManager.TryGetComponent<TelephoneComponent>(_owner.Value, out var telephone))
+            return;
+
+        if (_owner == null || !_entManager.TryGetComponent<HolopadComponent>(_owner.Value, out var holopad))
+            return;
+
+        var hasBroadcastAccess = !_holopadSystem.IsHolopadBroadcastOnCoolDown((_owner.Value, holopad));
+        var localPlayer = _playerManager.LocalSession?.AttachedEntity;
+
+        ControlsLockOutContainer.Visible = _holopadSystem.IsHolopadControlLocked((_owner.Value, holopad), localPlayer);
+        ControlsContainer.Visible = !ControlsLockOutContainer.Visible;
+
+        // Temporarily disable the interface buttons when the call state changes to prevent any misclicks
+        if (_currentState != telephone.CurrentState)
+        {
+            _previousState = _currentState;
+            _currentState = telephone.CurrentState;
+            _buttonUnlockTime = _timing.CurTime + _buttonUnlockDelay;
+        }
+
+        var lockButtons = _timing.CurTime < _buttonUnlockTime;
+
+        // Make / update required children
+        foreach (var child in ContactsList.Children)
+        {
+            if (child is not HolopadContactButton)
+                continue;
+
+            var contactButton = (HolopadContactButton)child;
+            contactButton.Disabled = (_currentState != TelephoneState.Idle || lockButtons);
+        }
+
+        // Update control text
+        var cooldown = _holopadSystem.GetHolopadBroadcastCoolDown((_owner.Value, holopad));
+        var cooldownString = $"{cooldown.Minutes:00}:{cooldown.Seconds:00}";
+
+        StartBroadcastButton.Text = _holopadSystem.IsHolopadBroadcastOnCoolDown((_owner.Value, holopad)) ?
+            Loc.GetString("holopad-window-emergency-broadcast-with-countdown", ("countdown", cooldownString)) :
+            Loc.GetString("holopad-window-emergency-broadcast");
+
+        var lockout = _holopadSystem.GetHolopadControlLockedPeriod((_owner.Value, holopad));
+        var lockoutString = $"{lockout.Minutes:00}:{lockout.Seconds:00}";
+
+        LockOutCountDownText.Text = Loc.GetString("holopad-window-controls-unlock-countdown", ("countdown", lockoutString));
+
+        switch (_currentState)
+        {
+            case TelephoneState.Idle:
+                CallStatusText.Text = Loc.GetString("holopad-window-no-calls-in-progress"); break;
+
+            case TelephoneState.Calling:
+                CallStatusText.Text = Loc.GetString("holopad-window-outgoing-call"); break;
+
+            case TelephoneState.Ringing:
+                CallStatusText.Text = (_currentUiKey == HolopadUiKey.AiRequestWindow) ?
+                    Loc.GetString("holopad-window-ai-request") : Loc.GetString("holopad-window-incoming-call"); break;
+
+            case TelephoneState.InCall:
+                CallStatusText.Text = Loc.GetString("holopad-window-call-in-progress"); break;
+
+            case TelephoneState.EndingCall:
+                if (_previousState == TelephoneState.Calling || _previousState == TelephoneState.Idle)
+                    CallStatusText.Text = Loc.GetString("holopad-window-call-rejected");
+                else
+                    CallStatusText.Text = Loc.GetString("holopad-window-call-ending");
+                break;
+        }
+
+        // Update control disability
+        AnswerCallButton.Disabled = (_currentState != TelephoneState.Ringing || lockButtons);
+        EndCallButton.Disabled = (_currentState == TelephoneState.Idle || _currentState == TelephoneState.EndingCall || lockButtons);
+        StartBroadcastButton.Disabled = (_currentState != TelephoneState.Idle || !hasBroadcastAccess || lockButtons);
+        RequestStationAiButton.Disabled = (_currentState != TelephoneState.Idle || lockButtons);
+        ActivateProjectorButton.Disabled = (_currentState != TelephoneState.Idle || lockButtons);
+
+        // Update control visibility
+        FetchingAvailableHolopadsContainer.Visible = (ContactsList.ChildCount == 0);
+        ActiveCallControlsContainer.Visible = (_currentState != TelephoneState.Idle || _currentUiKey == HolopadUiKey.AiRequestWindow);
+        CallPlacementControlsContainer.Visible = !ActiveCallControlsContainer.Visible;
+        CallerIdText.Visible = (_currentState == TelephoneState.Ringing);
+        AnswerCallButton.Visible = (_currentState == TelephoneState.Ringing);
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        _updateTimer += args.DeltaSeconds;
+
+        if (_updateTimer >= UpdateTime)
+        {
+            _updateTimer -= UpdateTime;
+            UpdateAppearance();
+        }
+    }
+
+    private sealed class HolopadContactButton : Button
+    {
+        public NetEntity NetEntity;
+
+        public HolopadContactButton()
+        {
+            HorizontalExpand = true;
+            SetHeight = 32;
+            Margin = new Thickness(0f, 1f, 0f, 1f);
+        }
+
+        public void UpdateValues(NetEntity netEntity, string label)
+        {
+            NetEntity = netEntity;
+            Text = Loc.GetString("holopad-window-contact-label", ("label", label));
+        }
+    }
+
+    private int AlphabeticalSort(KeyValuePair<NetEntity, string> x, KeyValuePair<NetEntity, string> y)
+    {
+        if (string.IsNullOrEmpty(x.Value))
+            return -1;
+
+        if (string.IsNullOrEmpty(y.Value))
+            return 1;
+
+        return x.Value.CompareTo(y.Value);
+    }
+}
diff --git a/Content.Client/Stylesheets/StyleNano.cs b/Content.Client/Stylesheets/StyleNano.cs
index ccd36c35e8..55e7ec0949 100644
--- a/Content.Client/Stylesheets/StyleNano.cs
+++ b/Content.Client/Stylesheets/StyleNano.cs
@@ -110,6 +110,7 @@ namespace Content.Client.Stylesheets
 
         public static readonly Color ButtonColorGoodDefault = Color.FromHex("#3E6C45");
         public static readonly Color ButtonColorGoodHovered = Color.FromHex("#31843E");
+        public static readonly Color ButtonColorGoodDisabled = Color.FromHex("#164420");
 
         //NavMap
         public static readonly Color PointRed = Color.FromHex("#B02E26");
@@ -1499,6 +1500,20 @@ namespace Content.Client.Stylesheets
 
                 Element<Button>().Class("ButtonColorGreen").Pseudo(ContainerButton.StylePseudoClassHover)
                     .Prop(Control.StylePropertyModulateSelf, ButtonColorGoodHovered),
+
+                // Accept button (merge with green button?) ---
+                Element<Button>().Class("ButtonAccept")
+                    .Prop(Control.StylePropertyModulateSelf, ButtonColorGoodDefault),
+
+                Element<Button>().Class("ButtonAccept").Pseudo(ContainerButton.StylePseudoClassNormal)
+                    .Prop(Control.StylePropertyModulateSelf, ButtonColorGoodDefault),
+
+                Element<Button>().Class("ButtonAccept").Pseudo(ContainerButton.StylePseudoClassHover)
+                    .Prop(Control.StylePropertyModulateSelf, ButtonColorGoodHovered),
+
+                Element<Button>().Class("ButtonAccept").Pseudo(ContainerButton.StylePseudoClassDisabled)
+                    .Prop(Control.StylePropertyModulateSelf, ButtonColorGoodDisabled),
+
                 // ---
 
                 // Small Button ---
diff --git a/Content.Client/Telephone/TelephoneSystem.cs b/Content.Client/Telephone/TelephoneSystem.cs
new file mode 100644
index 0000000000..8fad9f7b85
--- /dev/null
+++ b/Content.Client/Telephone/TelephoneSystem.cs
@@ -0,0 +1,8 @@
+using Content.Shared.Telephone;
+
+namespace Content.Client.Telephone;
+
+public sealed class TelephoneSystem : SharedTelephoneSystem
+{
+
+}
diff --git a/Content.Server/Holopad/HolopadSystem.cs b/Content.Server/Holopad/HolopadSystem.cs
new file mode 100644
index 0000000000..bd36d38bee
--- /dev/null
+++ b/Content.Server/Holopad/HolopadSystem.cs
@@ -0,0 +1,761 @@
+using Content.Server.Chat.Systems;
+using Content.Server.Power.EntitySystems;
+using Content.Server.Speech.Components;
+using Content.Server.Telephone;
+using Content.Shared.Access.Systems;
+using Content.Shared.Audio;
+using Content.Shared.Chat.TypingIndicator;
+using Content.Shared.Holopad;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Labels.Components;
+using Content.Shared.Silicons.StationAi;
+using Content.Shared.Telephone;
+using Content.Shared.UserInterface;
+using Content.Shared.Verbs;
+using Robust.Server.GameObjects;
+using Robust.Shared.Containers;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+using System.Linq;
+
+namespace Content.Server.Holopad;
+
+public sealed class HolopadSystem : SharedHolopadSystem
+{
+    [Dependency] private readonly TelephoneSystem _telephoneSystem = default!;
+    [Dependency] private readonly UserInterfaceSystem _userInterfaceSystem = default!;
+    [Dependency] private readonly TransformSystem _xformSystem = default!;
+    [Dependency] private readonly AppearanceSystem _appearanceSystem = default!;
+    [Dependency] private readonly SharedPointLightSystem _pointLightSystem = default!;
+    [Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
+    [Dependency] private readonly SharedStationAiSystem _stationAiSystem = default!;
+    [Dependency] private readonly AccessReaderSystem _accessReaderSystem = default!;
+    [Dependency] private readonly ChatSystem _chatSystem = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    private float _updateTimer = 1.0f;
+
+    private const float UpdateTime = 1.0f;
+    private const float MinTimeBetweenSyncRequests = 0.5f;
+    private TimeSpan _minTimeSpanBetweenSyncRequests;
+
+    private HashSet<EntityUid> _pendingRequestsForSpriteState = new();
+    private HashSet<EntityUid> _recentlyUpdatedHolograms = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _minTimeSpanBetweenSyncRequests = TimeSpan.FromSeconds(MinTimeBetweenSyncRequests);
+
+        // Holopad UI and bound user interface messages
+        SubscribeLocalEvent<HolopadComponent, BeforeActivatableUIOpenEvent>(OnUIOpen);
+        SubscribeLocalEvent<HolopadComponent, HolopadStartNewCallMessage>(OnHolopadStartNewCall);
+        SubscribeLocalEvent<HolopadComponent, HolopadAnswerCallMessage>(OnHolopadAnswerCall);
+        SubscribeLocalEvent<HolopadComponent, HolopadEndCallMessage>(OnHolopadEndCall);
+        SubscribeLocalEvent<HolopadComponent, HolopadActivateProjectorMessage>(OnHolopadActivateProjector);
+        SubscribeLocalEvent<HolopadComponent, HolopadStartBroadcastMessage>(OnHolopadStartBroadcast);
+        SubscribeLocalEvent<HolopadComponent, HolopadStationAiRequestMessage>(OnHolopadStationAiRequest);
+
+        // Holopad telephone events
+        SubscribeLocalEvent<HolopadComponent, TelephoneStateChangeEvent>(OnTelephoneStateChange);
+        SubscribeLocalEvent<HolopadComponent, TelephoneCallCommencedEvent>(OnHoloCallCommenced);
+        SubscribeLocalEvent<HolopadComponent, TelephoneCallEndedEvent>(OnHoloCallEnded);
+        SubscribeLocalEvent<HolopadComponent, TelephoneMessageSentEvent>(OnTelephoneMessageSent);
+
+        // Networked events
+        SubscribeNetworkEvent<HolopadUserTypingChangedEvent>(OnTypingChanged);
+        SubscribeNetworkEvent<PlayerSpriteStateMessage>(OnPlayerSpriteStateMessage);
+
+        // Component start/shutdown events
+        SubscribeLocalEvent<HolopadComponent, ComponentInit>(OnHolopadInit);
+        SubscribeLocalEvent<HolopadComponent, ComponentShutdown>(OnHolopadShutdown);
+        SubscribeLocalEvent<HolopadUserComponent, ComponentInit>(OnHolopadUserInit);
+        SubscribeLocalEvent<HolopadUserComponent, ComponentShutdown>(OnHolopadUserShutdown);
+
+        // Misc events
+        SubscribeLocalEvent<HolopadUserComponent, EmoteEvent>(OnEmote);
+        SubscribeLocalEvent<HolopadUserComponent, JumpToCoreEvent>(OnJumpToCore);
+        SubscribeLocalEvent<HolopadComponent, GetVerbsEvent<AlternativeVerb>>(AddToggleProjectorVerb);
+        SubscribeLocalEvent<HolopadComponent, EntRemovedFromContainerMessage>(OnAiRemove);
+    }
+
+    #region: Holopad UI bound user interface messages
+
+    private void OnUIOpen(Entity<HolopadComponent> entity, ref BeforeActivatableUIOpenEvent args)
+    {
+        UpdateUIState(entity);
+    }
+
+    private void OnHolopadStartNewCall(Entity<HolopadComponent> source, ref HolopadStartNewCallMessage args)
+    {
+        if (IsHolopadControlLocked(source, args.Actor))
+            return;
+
+        if (!TryComp<TelephoneComponent>(source, out var sourceTelephone))
+            return;
+
+        var receiver = GetEntity(args.Receiver);
+
+        if (!TryComp<TelephoneComponent>(receiver, out var receiverTelephone))
+            return;
+
+        LinkHolopadToUser(source, args.Actor);
+        _telephoneSystem.CallTelephone((source, sourceTelephone), (receiver, receiverTelephone), args.Actor);
+    }
+
+    private void OnHolopadAnswerCall(Entity<HolopadComponent> receiver, ref HolopadAnswerCallMessage args)
+    {
+        if (IsHolopadControlLocked(receiver, args.Actor))
+            return;
+
+        if (!TryComp<TelephoneComponent>(receiver, out var receiverTelephone))
+            return;
+
+        if (TryComp<StationAiHeldComponent>(args.Actor, out var userAiHeld))
+        {
+            var source = GetLinkedHolopads(receiver).FirstOrNull();
+
+            if (source != null)
+                ActivateProjector(source.Value, args.Actor);
+
+            return;
+        }
+
+        LinkHolopadToUser(receiver, args.Actor);
+        _telephoneSystem.AnswerTelephone((receiver, receiverTelephone), args.Actor);
+    }
+
+    private void OnHolopadEndCall(Entity<HolopadComponent> entity, ref HolopadEndCallMessage args)
+    {
+        if (!TryComp<TelephoneComponent>(entity, out var entityTelephone))
+            return;
+
+        if (IsHolopadControlLocked(entity, args.Actor))
+            return;
+
+        _telephoneSystem.EndTelephoneCalls((entity, entityTelephone));
+
+        // If the user is an AI, end all calls originating from its
+        // associated core to ensure that any broadcasts will end
+        if (!TryComp<StationAiHeldComponent>(args.Actor, out var stationAiHeld) ||
+            !_stationAiSystem.TryGetStationAiCore((args.Actor, stationAiHeld), out var stationAiCore))
+            return;
+
+        if (TryComp<TelephoneComponent>(stationAiCore, out var telephone))
+            _telephoneSystem.EndTelephoneCalls((stationAiCore.Value, telephone));
+    }
+
+    private void OnHolopadActivateProjector(Entity<HolopadComponent> entity, ref HolopadActivateProjectorMessage args)
+    {
+        ActivateProjector(entity, args.Actor);
+    }
+
+    private void OnHolopadStartBroadcast(Entity<HolopadComponent> source, ref HolopadStartBroadcastMessage args)
+    {
+        if (IsHolopadControlLocked(source, args.Actor) || IsHolopadBroadcastOnCoolDown(source))
+            return;
+
+        if (!_accessReaderSystem.IsAllowed(args.Actor, source))
+            return;
+
+        // AI broadcasting
+        if (TryComp<StationAiHeldComponent>(args.Actor, out var stationAiHeld))
+        {
+            if (!_stationAiSystem.TryGetStationAiCore((args.Actor, stationAiHeld), out var stationAiCore) ||
+                stationAiCore.Value.Comp.RemoteEntity == null ||
+                !TryComp<HolopadComponent>(stationAiCore, out var stationAiCoreHolopad))
+                return;
+
+            ExecuteBroadcast((stationAiCore.Value, stationAiCoreHolopad), args.Actor);
+
+            // Switch the AI's perspective from free roaming to the target holopad
+            _xformSystem.SetCoordinates(stationAiCore.Value.Comp.RemoteEntity.Value, Transform(source).Coordinates);
+            _stationAiSystem.SwitchRemoteEntityMode(stationAiCore.Value, false);
+
+            return;
+        }
+
+        // Crew broadcasting
+        ExecuteBroadcast(source, args.Actor);
+    }
+
+    private void OnHolopadStationAiRequest(Entity<HolopadComponent> entity, ref HolopadStationAiRequestMessage args)
+    {
+        if (IsHolopadControlLocked(entity, args.Actor))
+            return;
+
+        if (!TryComp<TelephoneComponent>(entity, out var telephone))
+            return;
+
+        var source = new Entity<TelephoneComponent>(entity, telephone);
+        var query = AllEntityQuery<StationAiCoreComponent, TelephoneComponent>();
+        var reachableAiCores = new HashSet<Entity<TelephoneComponent>>();
+
+        while (query.MoveNext(out var receiverUid, out var receiverStationAiCore, out var receiverTelephone))
+        {
+            var receiver = new Entity<TelephoneComponent>(receiverUid, receiverTelephone);
+
+            if (!_telephoneSystem.IsSourceAbleToReachReceiver(source, receiver))
+                continue;
+
+            if (_telephoneSystem.IsTelephoneEngaged(receiver))
+                continue;
+
+            reachableAiCores.Add((receiverUid, receiverTelephone));
+
+            if (!_stationAiSystem.TryGetInsertedAI((receiver, receiverStationAiCore), out var insertedAi))
+                continue;
+
+            if (_userInterfaceSystem.TryOpenUi(receiverUid, HolopadUiKey.AiRequestWindow, insertedAi.Value.Owner))
+                LinkHolopadToUser(entity, args.Actor);
+        }
+
+        if (!reachableAiCores.Any())
+            return;
+
+        _telephoneSystem.BroadcastCallToTelephones(source, reachableAiCores, args.Actor);
+    }
+
+    #endregion
+
+    #region: Holopad telephone events
+
+    private void OnTelephoneStateChange(Entity<HolopadComponent> holopad, ref TelephoneStateChangeEvent args)
+    {
+        // Update holopad visual and ambient states
+        switch (args.NewState)
+        {
+            case TelephoneState.Idle:
+                ShutDownHolopad(holopad);
+                SetHolopadAmbientState(holopad, false);
+                break;
+
+            case TelephoneState.EndingCall:
+                ShutDownHolopad(holopad);
+                break;
+
+            default:
+                SetHolopadAmbientState(holopad, this.IsPowered(holopad, EntityManager));
+                break;
+        }
+    }
+
+    private void OnHoloCallCommenced(Entity<HolopadComponent> source, ref TelephoneCallCommencedEvent args)
+    {
+        if (source.Comp.Hologram == null)
+            GenerateHologram(source);
+
+        // Receiver holopad holograms have to be generated now instead of waiting for their own event
+        // to fire because holographic avatars get synced immediately
+        if (TryComp<HolopadComponent>(args.Receiver, out var receivingHolopad) && receivingHolopad.Hologram == null)
+            GenerateHologram((args.Receiver, receivingHolopad));
+
+        if (source.Comp.User != null)
+        {
+            // Re-link the user to refresh the sprite data
+            LinkHolopadToUser(source, source.Comp.User.Value);
+        }
+    }
+
+    private void OnHoloCallEnded(Entity<HolopadComponent> entity, ref TelephoneCallEndedEvent args)
+    {
+        if (!TryComp<StationAiCoreComponent>(entity, out var stationAiCore))
+            return;
+
+        // Auto-close the AI request window
+        if (_stationAiSystem.TryGetInsertedAI((entity, stationAiCore), out var insertedAi))
+            _userInterfaceSystem.CloseUi(entity.Owner, HolopadUiKey.AiRequestWindow, insertedAi.Value.Owner);
+    }
+
+    private void OnTelephoneMessageSent(Entity<HolopadComponent> holopad, ref TelephoneMessageSentEvent args)
+    {
+        LinkHolopadToUser(holopad, args.MessageSource);
+    }
+
+    #endregion
+
+    #region: Networked events
+
+    private void OnTypingChanged(HolopadUserTypingChangedEvent ev, EntitySessionEventArgs args)
+    {
+        var uid = args.SenderSession.AttachedEntity;
+
+        if (!Exists(uid))
+            return;
+
+        if (!TryComp<HolopadUserComponent>(uid, out var holopadUser))
+            return;
+
+        foreach (var linkedHolopad in holopadUser.LinkedHolopads)
+        {
+            var receiverHolopads = GetLinkedHolopads(linkedHolopad);
+
+            foreach (var receiverHolopad in receiverHolopads)
+            {
+                if (receiverHolopad.Comp.Hologram == null)
+                    continue;
+
+                _appearanceSystem.SetData(receiverHolopad.Comp.Hologram.Value.Owner, TypingIndicatorVisuals.IsTyping, ev.IsTyping);
+            }
+        }
+    }
+
+    private void OnPlayerSpriteStateMessage(PlayerSpriteStateMessage ev, EntitySessionEventArgs args)
+    {
+        var uid = args.SenderSession.AttachedEntity;
+
+        if (!Exists(uid))
+            return;
+
+        if (!_pendingRequestsForSpriteState.Remove(uid.Value))
+            return;
+
+        if (!TryComp<HolopadUserComponent>(uid, out var holopadUser))
+            return;
+
+        SyncHolopadUserWithLinkedHolograms((uid.Value, holopadUser), ev.SpriteLayerData);
+    }
+
+    #endregion
+
+    #region: Component start/shutdown events
+
+    private void OnHolopadInit(Entity<HolopadComponent> entity, ref ComponentInit args)
+    {
+        if (entity.Comp.User != null)
+            LinkHolopadToUser(entity, entity.Comp.User.Value);
+    }
+
+    private void OnHolopadUserInit(Entity<HolopadUserComponent> entity, ref ComponentInit args)
+    {
+        foreach (var linkedHolopad in entity.Comp.LinkedHolopads)
+            LinkHolopadToUser(linkedHolopad, entity);
+    }
+
+    private void OnHolopadShutdown(Entity<HolopadComponent> entity, ref ComponentShutdown args)
+    {
+        ShutDownHolopad(entity);
+        SetHolopadAmbientState(entity, false);
+    }
+
+    private void OnHolopadUserShutdown(Entity<HolopadUserComponent> entity, ref ComponentShutdown args)
+    {
+        foreach (var linkedHolopad in entity.Comp.LinkedHolopads)
+            UnlinkHolopadFromUser(linkedHolopad, entity);
+    }
+
+    #endregion
+
+    #region: Misc events
+
+    private void OnEmote(Entity<HolopadUserComponent> entity, ref EmoteEvent args)
+    {
+        foreach (var linkedHolopad in entity.Comp.LinkedHolopads)
+        {
+            // Treat the ability to hear speech as the ability to also perceive emotes
+            // (these are almost always going to be linked)
+            if (!HasComp<ActiveListenerComponent>(linkedHolopad))
+                continue;
+
+            if (TryComp<TelephoneComponent>(linkedHolopad, out var linkedHolopadTelephone) && linkedHolopadTelephone.Muted)
+                continue;
+
+            foreach (var receiver in GetLinkedHolopads(linkedHolopad))
+            {
+                if (receiver.Comp.Hologram == null)
+                    continue;
+
+                // Name is based on the physical identity of the user
+                var ent = Identity.Entity(entity, EntityManager);
+                var name = Loc.GetString("holopad-hologram-name", ("name", ent));
+
+                // Force the emote, because if the user can do it, the hologram can too
+                _chatSystem.TryEmoteWithChat(receiver.Comp.Hologram.Value, args.Emote, ChatTransmitRange.Normal, false, name, true, true);
+            }
+        }
+    }
+
+    private void OnJumpToCore(Entity<HolopadUserComponent> entity, ref JumpToCoreEvent args)
+    {
+        if (!TryComp<StationAiHeldComponent>(entity, out var entityStationAiHeld))
+            return;
+
+        if (!_stationAiSystem.TryGetStationAiCore((entity, entityStationAiHeld), out var stationAiCore))
+            return;
+
+        if (!TryComp<TelephoneComponent>(stationAiCore, out var stationAiCoreTelephone))
+            return;
+
+        _telephoneSystem.EndTelephoneCalls((stationAiCore.Value, stationAiCoreTelephone));
+    }
+
+    private void AddToggleProjectorVerb(Entity<HolopadComponent> entity, ref GetVerbsEvent<AlternativeVerb> args)
+    {
+        if (!args.CanAccess || !args.CanInteract)
+            return;
+
+        if (!this.IsPowered(entity, EntityManager))
+            return;
+
+        if (!TryComp<TelephoneComponent>(entity, out var entityTelephone) ||
+            _telephoneSystem.IsTelephoneEngaged((entity, entityTelephone)))
+            return;
+
+        var user = args.User;
+
+        if (!TryComp<StationAiHeldComponent>(user, out var userAiHeld))
+            return;
+
+        if (!_stationAiSystem.TryGetStationAiCore((user, userAiHeld), out var stationAiCore) ||
+            stationAiCore.Value.Comp.RemoteEntity == null)
+            return;
+
+        AlternativeVerb verb = new()
+        {
+            Act = () => ActivateProjector(entity, user),
+            Text = Loc.GetString("activate-holopad-projector-verb"),
+            Icon = new SpriteSpecifier.Texture(new("/Textures/Interface/VerbIcons/vv.svg.192dpi.png")),
+        };
+
+        args.Verbs.Add(verb);
+    }
+
+    private void OnAiRemove(Entity<HolopadComponent> entity, ref EntRemovedFromContainerMessage args)
+    {
+        if (!HasComp<StationAiCoreComponent>(entity))
+            return;
+
+        if (!TryComp<TelephoneComponent>(entity, out var entityTelephone))
+            return;
+
+        _telephoneSystem.EndTelephoneCalls((entity, entityTelephone));
+    }
+
+    #endregion
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        _updateTimer += frameTime;
+
+        if (_updateTimer >= UpdateTime)
+        {
+            _updateTimer -= UpdateTime;
+
+            var query = AllEntityQuery<HolopadComponent, TelephoneComponent, TransformComponent>();
+            while (query.MoveNext(out var uid, out var holopad, out var telephone, out var xform))
+            {
+                UpdateUIState((uid, holopad), telephone);
+
+                if (holopad.User != null &&
+                    !HasComp<IgnoreUIRangeComponent>(holopad.User) &&
+                    !_xformSystem.InRange((holopad.User.Value, Transform(holopad.User.Value)), (uid, xform), telephone.ListeningRange))
+                {
+                    UnlinkHolopadFromUser((uid, holopad), holopad.User.Value);
+                }
+            }
+        }
+
+        _recentlyUpdatedHolograms.Clear();
+    }
+
+    public void UpdateUIState(Entity<HolopadComponent> entity, TelephoneComponent? telephone = null)
+    {
+        if (!Resolve(entity.Owner, ref telephone, false))
+            return;
+
+        var source = new Entity<TelephoneComponent>(entity, telephone);
+        var holopads = new Dictionary<NetEntity, string>();
+
+        var query = AllEntityQuery<HolopadComponent, TelephoneComponent>();
+        while (query.MoveNext(out var receiverUid, out var _, out var receiverTelephone))
+        {
+            var receiver = new Entity<TelephoneComponent>(receiverUid, receiverTelephone);
+
+            if (receiverTelephone.UnlistedNumber)
+                continue;
+
+            if (source == receiver)
+                continue;
+
+            if (!_telephoneSystem.IsSourceInRangeOfReceiver(source, receiver))
+                continue;
+
+            var name = MetaData(receiverUid).EntityName;
+
+            if (TryComp<LabelComponent>(receiverUid, out var label) && !string.IsNullOrEmpty(label.CurrentLabel))
+                name = label.CurrentLabel;
+
+            holopads.Add(GetNetEntity(receiverUid), name);
+        }
+
+        var uiKey = HasComp<StationAiCoreComponent>(entity) ? HolopadUiKey.AiActionWindow : HolopadUiKey.InteractionWindow;
+        _userInterfaceSystem.SetUiState(entity.Owner, uiKey, new HolopadBoundInterfaceState(holopads));
+    }
+
+    private void GenerateHologram(Entity<HolopadComponent> entity)
+    {
+        if (entity.Comp.Hologram != null ||
+            entity.Comp.HologramProtoId == null)
+            return;
+
+        var uid = Spawn(entity.Comp.HologramProtoId, Transform(entity).Coordinates);
+
+        // Safeguard - spawned holograms must have this component
+        if (!TryComp<HolopadHologramComponent>(uid, out var component))
+        {
+            Del(uid);
+            return;
+        }
+
+        entity.Comp.Hologram = new Entity<HolopadHologramComponent>(uid, component);
+    }
+
+    private void DeleteHologram(Entity<HolopadHologramComponent> hologram, Entity<HolopadComponent> attachedHolopad)
+    {
+        attachedHolopad.Comp.Hologram = null;
+
+        QueueDel(hologram);
+    }
+
+    private void LinkHolopadToUser(Entity<HolopadComponent> entity, EntityUid user)
+    {
+        if (!TryComp<HolopadUserComponent>(user, out var holopadUser))
+            holopadUser = AddComp<HolopadUserComponent>(user);
+
+        if (user != entity.Comp.User?.Owner)
+        {
+            // Removes the old user from the holopad
+            UnlinkHolopadFromUser(entity, entity.Comp.User);
+
+            // Assigns the new user in their place
+            holopadUser.LinkedHolopads.Add(entity);
+            entity.Comp.User = (user, holopadUser);
+        }
+
+        if (TryComp<HolographicAvatarComponent>(user, out var avatar))
+        {
+            SyncHolopadUserWithLinkedHolograms((user, holopadUser), avatar.LayerData);
+            return;
+        }
+
+        // We have no apriori sprite data for the hologram, request
+        // the current appearance of the user from the client
+        RequestHolopadUserSpriteUpdate((user, holopadUser));
+    }
+
+    private void UnlinkHolopadFromUser(Entity<HolopadComponent> entity, Entity<HolopadUserComponent>? user)
+    {
+        if (user == null)
+            return;
+
+        entity.Comp.User = null;
+
+        foreach (var linkedHolopad in GetLinkedHolopads(entity))
+        {
+            if (linkedHolopad.Comp.Hologram != null)
+            {
+                _appearanceSystem.SetData(linkedHolopad.Comp.Hologram.Value.Owner, TypingIndicatorVisuals.IsTyping, false);
+
+                // Send message with no sprite data to the client
+                // This will set the holgram sprite to a generic icon
+                var ev = new PlayerSpriteStateMessage(GetNetEntity(linkedHolopad.Comp.Hologram.Value));
+                RaiseNetworkEvent(ev);
+            }
+        }
+
+        if (!HasComp<HolopadUserComponent>(user))
+            return;
+
+        user.Value.Comp.LinkedHolopads.Remove(entity);
+
+        if (!user.Value.Comp.LinkedHolopads.Any())
+        {
+            _pendingRequestsForSpriteState.Remove(user.Value);
+
+            if (user.Value.Comp.LifeStage < ComponentLifeStage.Stopping)
+                RemComp<HolopadUserComponent>(user.Value);
+        }
+    }
+
+    private void ShutDownHolopad(Entity<HolopadComponent> entity)
+    {
+        entity.Comp.ControlLockoutOwner = null;
+
+        if (entity.Comp.Hologram != null)
+            DeleteHologram(entity.Comp.Hologram.Value, entity);
+
+        if (entity.Comp.User != null)
+            UnlinkHolopadFromUser(entity, entity.Comp.User.Value);
+
+        if (TryComp<StationAiCoreComponent>(entity, out var stationAiCore))
+        {
+            _stationAiSystem.SwitchRemoteEntityMode((entity.Owner, stationAiCore), true);
+
+            if (TryComp<TelephoneComponent>(entity, out var stationAiCoreTelphone))
+                _telephoneSystem.EndTelephoneCalls((entity, stationAiCoreTelphone));
+        }
+
+        Dirty(entity);
+    }
+
+    private void RequestHolopadUserSpriteUpdate(Entity<HolopadUserComponent> user)
+    {
+        if (!_pendingRequestsForSpriteState.Add(user))
+            return;
+
+        var ev = new PlayerSpriteStateRequest(GetNetEntity(user));
+        RaiseNetworkEvent(ev);
+    }
+
+    private void SyncHolopadUserWithLinkedHolograms(Entity<HolopadUserComponent> entity, PrototypeLayerData[]? spriteLayerData)
+    {
+        foreach (var linkedHolopad in entity.Comp.LinkedHolopads)
+        {
+            foreach (var receivingHolopad in GetLinkedHolopads(linkedHolopad))
+            {
+                if (receivingHolopad.Comp.Hologram == null || !_recentlyUpdatedHolograms.Add(receivingHolopad.Comp.Hologram.Value))
+                    continue;
+
+                var netHologram = GetNetEntity(receivingHolopad.Comp.Hologram.Value);
+                var ev = new PlayerSpriteStateMessage(netHologram, spriteLayerData);
+                RaiseNetworkEvent(ev);
+            }
+        }
+    }
+
+    private void ActivateProjector(Entity<HolopadComponent> entity, EntityUid user)
+    {
+        if (!TryComp<TelephoneComponent>(entity, out var receiverTelephone))
+            return;
+
+        var receiver = new Entity<TelephoneComponent>(entity, receiverTelephone);
+
+        if (!TryComp<StationAiHeldComponent>(user, out var userAiHeld))
+            return;
+
+        if (!_stationAiSystem.TryGetStationAiCore((user, userAiHeld), out var stationAiCore) ||
+            stationAiCore.Value.Comp.RemoteEntity == null)
+            return;
+
+        if (!TryComp<TelephoneComponent>(stationAiCore, out var stationAiTelephone))
+            return;
+
+        if (!TryComp<HolopadComponent>(stationAiCore, out var stationAiHolopad))
+            return;
+
+        var source = new Entity<TelephoneComponent>(stationAiCore.Value, stationAiTelephone);
+
+        // Terminate any calls that the core is hosting and immediately connect to the receiver
+        _telephoneSystem.TerminateTelephoneCalls(source);
+
+        var callOptions = new TelephoneCallOptions()
+        {
+            ForceConnect = true,
+            MuteReceiver = true
+        };
+
+        _telephoneSystem.CallTelephone(source, receiver, user, callOptions);
+
+        if (!_telephoneSystem.IsSourceConnectedToReceiver(source, receiver))
+            return;
+
+        LinkHolopadToUser((stationAiCore.Value, stationAiHolopad), user);
+
+        // Switch the AI's perspective from free roaming to the target holopad
+        _xformSystem.SetCoordinates(stationAiCore.Value.Comp.RemoteEntity.Value, Transform(entity).Coordinates);
+        _stationAiSystem.SwitchRemoteEntityMode(stationAiCore.Value, false);
+
+        // Open the holopad UI if it hasn't been opened yet
+        if (TryComp<UserInterfaceComponent>(entity, out var entityUserInterfaceComponent))
+            _userInterfaceSystem.OpenUi((entity, entityUserInterfaceComponent), HolopadUiKey.InteractionWindow, user);
+    }
+
+    private void ExecuteBroadcast(Entity<HolopadComponent> source, EntityUid user)
+    {
+        if (!TryComp<TelephoneComponent>(source, out var sourceTelephone))
+            return;
+
+        var sourceTelephoneEntity = new Entity<TelephoneComponent>(source, sourceTelephone);
+        _telephoneSystem.TerminateTelephoneCalls(sourceTelephoneEntity);
+
+        // Find all holopads in range of the source
+        var sourceXform = Transform(source);
+        var receivers = new HashSet<Entity<TelephoneComponent>>();
+
+        var query = AllEntityQuery<HolopadComponent, TelephoneComponent, TransformComponent>();
+        while (query.MoveNext(out var receiver, out var receiverHolopad, out var receiverTelephone, out var receiverXform))
+        {
+            var receiverTelephoneEntity = new Entity<TelephoneComponent>(receiver, receiverTelephone);
+
+            if (sourceTelephoneEntity == receiverTelephoneEntity ||
+                receiverTelephone.UnlistedNumber ||
+                !_telephoneSystem.IsSourceAbleToReachReceiver(sourceTelephoneEntity, receiverTelephoneEntity))
+                continue;
+
+            // If any holopads in range are on broadcast cooldown, exit
+            if (IsHolopadBroadcastOnCoolDown((receiver, receiverHolopad)))
+                return;
+
+            receivers.Add(receiverTelephoneEntity);
+        }
+
+        var options = new TelephoneCallOptions()
+        {
+            ForceConnect = true,
+            MuteReceiver = true,
+        };
+
+        _telephoneSystem.BroadcastCallToTelephones(sourceTelephoneEntity, receivers, user, options);
+
+        if (!_telephoneSystem.IsTelephoneEngaged(sourceTelephoneEntity))
+            return;
+
+        // Link to the user after all the calls have been placed,
+        // so we only need to sync all the holograms once
+        LinkHolopadToUser(source, user);
+
+        // Lock out the controls of all involved holopads for a set duration
+        source.Comp.ControlLockoutOwner = user;
+        source.Comp.ControlLockoutStartTime = _timing.CurTime;
+
+        Dirty(source);
+
+        foreach (var receiver in GetLinkedHolopads(source))
+        {
+            receiver.Comp.ControlLockoutOwner = user;
+            receiver.Comp.ControlLockoutStartTime = _timing.CurTime;
+
+            Dirty(receiver);
+        }
+    }
+
+    private HashSet<Entity<HolopadComponent>> GetLinkedHolopads(Entity<HolopadComponent> entity)
+    {
+        var linkedHolopads = new HashSet<Entity<HolopadComponent>>();
+
+        if (!TryComp<TelephoneComponent>(entity, out var holopadTelephone))
+            return linkedHolopads;
+
+        foreach (var linkedEnt in holopadTelephone.LinkedTelephones)
+        {
+            if (!TryComp<HolopadComponent>(linkedEnt, out var linkedHolopad))
+                continue;
+
+            linkedHolopads.Add((linkedEnt, linkedHolopad));
+        }
+
+        return linkedHolopads;
+    }
+
+    private void SetHolopadAmbientState(Entity<HolopadComponent> entity, bool isEnabled)
+    {
+        if (TryComp<PointLightComponent>(entity, out var pointLight))
+            _pointLightSystem.SetEnabled(entity, isEnabled, pointLight);
+
+        if (TryComp<AmbientSoundComponent>(entity, out var ambientSound))
+            _ambientSoundSystem.SetAmbience(entity, isEnabled, ambientSound);
+    }
+}
diff --git a/Content.Server/Silicons/StationAi/AiVisionWireAction.cs b/Content.Server/Silicons/StationAi/AiVisionWireAction.cs
index 3523f4d38f..c3d4a565bb 100644
--- a/Content.Server/Silicons/StationAi/AiVisionWireAction.cs
+++ b/Content.Server/Silicons/StationAi/AiVisionWireAction.cs
@@ -12,8 +12,8 @@ namespace Content.Server.Silicons.StationAi;
 public sealed partial class AiVisionWireAction : ComponentWireAction<StationAiVisionComponent>
 {
     public override string Name { get; set; } = "wire-name-ai-vision-light";
-    public override Color Color { get; set; } = Color.DeepSkyBlue;
-    public override object StatusKey => AirlockWireStatus.AiControlIndicator;
+    public override Color Color { get; set; } = Color.White;
+    public override object StatusKey => AirlockWireStatus.AiVisionIndicator;
 
     public override StatusLightState? GetLightState(Wire wire, StationAiVisionComponent component)
     {
diff --git a/Content.Server/Silicons/StationAi/StationAiSystem.cs b/Content.Server/Silicons/StationAi/StationAiSystem.cs
index a10833dc63..9c15112b30 100644
--- a/Content.Server/Silicons/StationAi/StationAiSystem.cs
+++ b/Content.Server/Silicons/StationAi/StationAiSystem.cs
@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Server.Chat.Managers;
+using Content.Server.Chat.Systems;
 using Content.Shared.Chat;
 using Content.Shared.Mind;
 using Content.Shared.Roles;
@@ -8,6 +9,7 @@ using Content.Shared.StationAi;
 using Robust.Shared.Audio;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Player;
+using static Content.Server.Chat.Systems.ChatSystem;
 
 namespace Content.Server.Silicons.StationAi;
 
@@ -15,11 +17,50 @@ public sealed class StationAiSystem : SharedStationAiSystem
 {
     [Dependency] private readonly IChatManager _chats = default!;
     [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedTransformSystem _xforms = default!;
     [Dependency] private readonly SharedMindSystem _mind = default!;
     [Dependency] private readonly SharedRoleSystem _roles = default!;
 
     private readonly HashSet<Entity<StationAiCoreComponent>> _ais = new();
 
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ExpandICChatRecipientsEvent>(OnExpandICChatRecipients);
+    }
+
+    private void OnExpandICChatRecipients(ExpandICChatRecipientsEvent ev)
+    {
+        var xformQuery = GetEntityQuery<TransformComponent>();
+        var sourceXform = Transform(ev.Source);
+        var sourcePos = _xforms.GetWorldPosition(sourceXform, xformQuery);
+
+        // This function ensures that chat popups appear on camera views that have connected microphones.
+        var query = EntityManager.EntityQueryEnumerator<StationAiCoreComponent, TransformComponent>();
+        while (query.MoveNext(out var ent, out var entStationAiCore, out var entXform))
+        {
+            var stationAiCore = new Entity<StationAiCoreComponent>(ent, entStationAiCore);
+
+            if (!TryGetInsertedAI(stationAiCore, out var insertedAi) || !TryComp(insertedAi, out ActorComponent? actor))
+                return;
+
+            if (stationAiCore.Comp.RemoteEntity == null || stationAiCore.Comp.Remote)
+                return;
+
+            var xform = Transform(stationAiCore.Comp.RemoteEntity.Value);
+
+            var range = (xform.MapID != sourceXform.MapID)
+                ? -1
+                : (sourcePos - _xforms.GetWorldPosition(xform, xformQuery)).Length();
+
+            if (range < 0 || range > ev.VoiceRange)
+                continue;
+
+            ev.Recipients.TryAdd(actor.PlayerSession, new ICChatRecipientData(range, false));
+        }
+    }
+
     public override bool SetVisionEnabled(Entity<StationAiVisionComponent> entity, bool enabled, bool announce = false)
     {
         if (!base.SetVisionEnabled(entity, enabled, announce))
diff --git a/Content.Server/Telephone/TelephoneSystem.cs b/Content.Server/Telephone/TelephoneSystem.cs
new file mode 100644
index 0000000000..8507f4d507
--- /dev/null
+++ b/Content.Server/Telephone/TelephoneSystem.cs
@@ -0,0 +1,468 @@
+using Content.Server.Access.Systems;
+using Content.Server.Administration.Logs;
+using Content.Server.Chat.Systems;
+using Content.Server.Interaction;
+using Content.Server.Power.EntitySystems;
+using Content.Server.Speech;
+using Content.Server.Speech.Components;
+using Content.Shared.Chat;
+using Content.Shared.Database;
+using Content.Shared.Mind.Components;
+using Content.Shared.Power;
+using Content.Shared.Speech;
+using Content.Shared.Telephone;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Replays;
+using System.Linq;
+using Content.Shared.Silicons.StationAi;
+using Content.Shared.Silicons.Borgs.Components;
+
+namespace Content.Server.Telephone;
+
+public sealed class TelephoneSystem : SharedTelephoneSystem
+{
+    [Dependency] private readonly AppearanceSystem _appearanceSystem = default!;
+    [Dependency] private readonly InteractionSystem _interaction = default!;
+    [Dependency] private readonly IdCardSystem _idCardSystem = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly ChatSystem _chat = default!;
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly IReplayRecordingManager _replay = default!;
+
+    // Has set used to prevent telephone feedback loops
+    private HashSet<(EntityUid, string, Entity<TelephoneComponent>)> _recentChatMessages = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<TelephoneComponent, ComponentShutdown>(OnComponentShutdown);
+        SubscribeLocalEvent<TelephoneComponent, PowerChangedEvent>(OnPowerChanged);
+        SubscribeLocalEvent<TelephoneComponent, ListenAttemptEvent>(OnAttemptListen);
+        SubscribeLocalEvent<TelephoneComponent, ListenEvent>(OnListen);
+        SubscribeLocalEvent<TelephoneComponent, TelephoneMessageReceivedEvent>(OnTelephoneMessageReceived);
+    }
+
+    #region: Events
+
+    private void OnComponentShutdown(Entity<TelephoneComponent> entity, ref ComponentShutdown ev)
+    {
+        TerminateTelephoneCalls(entity);
+    }
+
+    private void OnPowerChanged(Entity<TelephoneComponent> entity, ref PowerChangedEvent ev)
+    {
+        if (!ev.Powered)
+            TerminateTelephoneCalls(entity);
+    }
+
+    private void OnAttemptListen(Entity<TelephoneComponent> entity, ref ListenAttemptEvent args)
+    {
+        if (!IsTelephonePowered(entity) ||
+            !IsTelephoneEngaged(entity) ||
+            entity.Comp.Muted ||
+            !_interaction.InRangeUnobstructed(args.Source, entity.Owner, 0))
+        {
+            args.Cancel();
+        }
+    }
+
+    private void OnListen(Entity<TelephoneComponent> entity, ref ListenEvent args)
+    {
+        if (args.Source == entity.Owner)
+            return;
+
+        // Ignore background chatter from non-player entities
+        if (!HasComp<MindContainerComponent>(args.Source))
+            return;
+
+        // Simple check to make sure that we haven't sent this message already this frame
+        if (!_recentChatMessages.Add((args.Source, args.Message, entity)))
+            return;
+
+        SendTelephoneMessage(args.Source, args.Message, entity);
+    }
+
+    private void OnTelephoneMessageReceived(Entity<TelephoneComponent> entity, ref TelephoneMessageReceivedEvent args)
+    {
+        // Prevent message feedback loops
+        if (entity == args.TelephoneSource)
+            return;
+
+        if (!IsTelephonePowered(entity) ||
+            !IsSourceConnectedToReceiver(args.TelephoneSource, entity))
+            return;
+
+        var nameEv = new TransformSpeakerNameEvent(args.MessageSource, Name(args.MessageSource));
+        RaiseLocalEvent(args.MessageSource, nameEv);
+
+        var name = Loc.GetString("speech-name-relay",
+            ("speaker", Name(entity)),
+            ("originalName", nameEv.VoiceName));
+
+        var volume = entity.Comp.SpeakerVolume == TelephoneVolume.Speak ? InGameICChatType.Speak : InGameICChatType.Whisper;
+        _chat.TrySendInGameICMessage(entity, args.Message, volume, ChatTransmitRange.GhostRangeLimit, nameOverride: name, checkRadioPrefix: false);
+    }
+
+    #endregion
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var query = EntityManager.EntityQueryEnumerator<TelephoneComponent>();
+        while (query.MoveNext(out var uid, out var telephone))
+        {
+            var entity = new Entity<TelephoneComponent>(uid, telephone);
+
+            if (IsTelephoneEngaged(entity))
+            {
+                foreach (var receiver in telephone.LinkedTelephones)
+                {
+                    if (!IsSourceInRangeOfReceiver(entity, receiver) &&
+                        !IsSourceInRangeOfReceiver(receiver, entity))
+                    {
+                        EndTelephoneCall(entity, receiver);
+                    }
+                }
+            }
+
+            switch (telephone.CurrentState)
+            {
+                // Try to play ring tone if ringing
+                case TelephoneState.Ringing:
+                    if (_timing.CurTime > telephone.StateStartTime + TimeSpan.FromSeconds(telephone.RingingTimeout))
+                        EndTelephoneCalls(entity);
+
+                    else if (telephone.RingTone != null &&
+                        _timing.CurTime > telephone.NextRingToneTime)
+                    {
+                        _audio.PlayPvs(telephone.RingTone, uid);
+                        telephone.NextRingToneTime = _timing.CurTime + TimeSpan.FromSeconds(telephone.RingInterval);
+                    }
+
+                    break;
+
+                // Try to hang up if their has been no recent in-call activity 
+                case TelephoneState.InCall:
+                    if (_timing.CurTime > telephone.StateStartTime + TimeSpan.FromSeconds(telephone.IdlingTimeout))
+                        EndTelephoneCalls(entity);
+
+                    break;
+
+                // Try to terminate if the telephone has finished hanging up
+                case TelephoneState.EndingCall:
+                    if (_timing.CurTime > telephone.StateStartTime + TimeSpan.FromSeconds(telephone.HangingUpTimeout))
+                        TerminateTelephoneCalls(entity);
+
+                    break;
+            }
+        }
+
+        _recentChatMessages.Clear();
+    }
+
+    public void BroadcastCallToTelephones(Entity<TelephoneComponent> source, HashSet<Entity<TelephoneComponent>> receivers, EntityUid user, TelephoneCallOptions? options = null)
+    {
+        if (IsTelephoneEngaged(source))
+            return;
+
+        foreach (var receiver in receivers)
+            TryCallTelephone(source, receiver, user, options);
+
+        // If no connections could be made, hang up the telephone
+        if (!IsTelephoneEngaged(source))
+            EndTelephoneCalls(source);
+    }
+
+    public void CallTelephone(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver, EntityUid user, TelephoneCallOptions? options = null)
+    {
+        if (IsTelephoneEngaged(source))
+            return;
+
+        if (!TryCallTelephone(source, receiver, user, options))
+            EndTelephoneCalls(source);
+    }
+
+    private bool TryCallTelephone(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver, EntityUid user, TelephoneCallOptions? options = null)
+    {
+        if (!IsSourceAbleToReachReceiver(source, receiver))
+            return false;
+
+        if (IsTelephoneEngaged(receiver) &&
+            options?.ForceConnect != true &&
+            options?.ForceJoin != true)
+            return false;
+
+        var evCallAttempt = new TelephoneCallAttemptEvent(source, receiver, user);
+        RaiseLocalEvent(source, ref evCallAttempt);
+
+        if (evCallAttempt.Cancelled)
+            return false;
+
+        if (options?.ForceConnect == true)
+            TerminateTelephoneCalls(receiver);
+
+        source.Comp.LinkedTelephones.Add(receiver);
+        source.Comp.Muted = options?.MuteSource == true;
+
+        receiver.Comp.LastCallerId = GetNameAndJobOfCallingEntity(user); // This will be networked when the state changes
+        receiver.Comp.LinkedTelephones.Add(source);
+        receiver.Comp.Muted = options?.MuteReceiver == true;
+
+        // Try to open a line of communication immediately
+        if (options?.ForceConnect == true ||
+            (options?.ForceJoin == true && receiver.Comp.CurrentState == TelephoneState.InCall))
+        {
+            CommenceTelephoneCall(source, receiver);
+            return true;
+        }
+
+        // Otherwise start ringing the receiver
+        SetTelephoneState(source, TelephoneState.Calling);
+        SetTelephoneState(receiver, TelephoneState.Ringing);
+
+        return true;
+    }
+
+    public void AnswerTelephone(Entity<TelephoneComponent> receiver, EntityUid user)
+    {
+        if (receiver.Comp.CurrentState != TelephoneState.Ringing)
+            return;
+
+        // If the telephone isn't linked, or is linked to more than one telephone,
+        // you shouldn't need to answer the call. If you do need to answer it,
+        // you'll need to be handled this a different way
+        if (receiver.Comp.LinkedTelephones.Count != 1)
+            return;
+
+        var source = receiver.Comp.LinkedTelephones.First();
+        CommenceTelephoneCall(source, receiver);
+    }
+
+    private void CommenceTelephoneCall(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver)
+    {
+        SetTelephoneState(source, TelephoneState.InCall);
+        SetTelephoneState(receiver, TelephoneState.InCall);
+
+        SetTelephoneMicrophoneState(source, true);
+        SetTelephoneMicrophoneState(receiver, true);
+
+        var evSource = new TelephoneCallCommencedEvent(receiver);
+        var evReceiver = new TelephoneCallCommencedEvent(source);
+
+        RaiseLocalEvent(source, ref evSource);
+        RaiseLocalEvent(receiver, ref evReceiver);
+    }
+
+    public void EndTelephoneCall(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver)
+    {
+        source.Comp.LinkedTelephones.Remove(receiver);
+        receiver.Comp.LinkedTelephones.Remove(source);
+
+        if (!IsTelephoneEngaged(source))
+            EndTelephoneCalls(source);
+
+        if (!IsTelephoneEngaged(receiver))
+            EndTelephoneCalls(receiver);
+    }
+
+    public void EndTelephoneCalls(Entity<TelephoneComponent> entity)
+    {
+        HandleEndingTelephoneCalls(entity, TelephoneState.EndingCall);
+
+        var ev = new TelephoneCallEndedEvent();
+        RaiseLocalEvent(entity, ref ev);
+    }
+
+    public void TerminateTelephoneCalls(Entity<TelephoneComponent> entity)
+    {
+        HandleEndingTelephoneCalls(entity, TelephoneState.Idle);
+    }
+
+    private void HandleEndingTelephoneCalls(Entity<TelephoneComponent> entity, TelephoneState newState)
+    {
+        if (entity.Comp.CurrentState == newState)
+            return;
+
+        foreach (var linkedTelephone in entity.Comp.LinkedTelephones)
+        {
+            if (!linkedTelephone.Comp.LinkedTelephones.Remove(entity))
+                continue;
+
+            if (!IsTelephoneEngaged(linkedTelephone))
+                EndTelephoneCalls(linkedTelephone);
+        }
+
+        entity.Comp.LinkedTelephones.Clear();
+        entity.Comp.Muted = false;
+
+        SetTelephoneState(entity, newState);
+        SetTelephoneMicrophoneState(entity, false);
+    }
+
+    private void SendTelephoneMessage(EntityUid messageSource, string message, Entity<TelephoneComponent> source, bool escapeMarkup = true)
+    {
+        // This method assumes that you've already checked that this
+        // telephone is able to transmit messages and that it can
+        // send messages to any telephones linked to it
+
+        var ev = new TransformSpeakerNameEvent(messageSource, MetaData(messageSource).EntityName);
+        RaiseLocalEvent(messageSource, ev);
+
+        var name = ev.VoiceName;
+        name = FormattedMessage.EscapeText(name);
+
+        SpeechVerbPrototype speech;
+        if (ev.SpeechVerb != null && _prototype.TryIndex(ev.SpeechVerb, out var evntProto))
+            speech = evntProto;
+        else
+            speech = _chat.GetSpeechVerb(messageSource, message);
+
+        var content = escapeMarkup
+            ? FormattedMessage.EscapeText(message)
+            : message;
+
+        var wrappedMessage = Loc.GetString(speech.Bold ? "chat-telephone-message-wrap-bold" : "chat-telephone-message-wrap",
+            ("color", Color.White),
+            ("fontType", speech.FontId),
+            ("fontSize", speech.FontSize),
+            ("verb", Loc.GetString(_random.Pick(speech.SpeechVerbStrings))),
+            ("name", name),
+            ("message", content));
+
+        var chat = new ChatMessage(
+            ChatChannel.Local,
+            message,
+            wrappedMessage,
+            NetEntity.Invalid,
+            null);
+
+        var chatMsg = new MsgChatMessage { Message = chat };
+
+        var evSentMessage = new TelephoneMessageSentEvent(message, chatMsg, messageSource);
+        RaiseLocalEvent(source, ref evSentMessage);
+        source.Comp.StateStartTime = _timing.CurTime;
+
+        var evReceivedMessage = new TelephoneMessageReceivedEvent(message, chatMsg, messageSource, source);
+
+        foreach (var receiver in source.Comp.LinkedTelephones)
+        {
+            RaiseLocalEvent(receiver, ref evReceivedMessage);
+            receiver.Comp.StateStartTime = _timing.CurTime;
+        }
+
+        if (name != Name(messageSource))
+            _adminLogger.Add(LogType.Chat, LogImpact.Low, $"Telephone message from {ToPrettyString(messageSource):user} as {name} on {source}: {message}");
+        else
+            _adminLogger.Add(LogType.Chat, LogImpact.Low, $"Telephone message from {ToPrettyString(messageSource):user} on {source}: {message}");
+
+        _replay.RecordServerMessage(chat);
+    }
+
+    private void SetTelephoneState(Entity<TelephoneComponent> entity, TelephoneState newState)
+    {
+        var oldState = entity.Comp.CurrentState;
+
+        entity.Comp.CurrentState = newState;
+        entity.Comp.StateStartTime = _timing.CurTime;
+        Dirty(entity);
+
+        _appearanceSystem.SetData(entity, TelephoneVisuals.Key, entity.Comp.CurrentState);
+
+        var ev = new TelephoneStateChangeEvent(oldState, newState);
+        RaiseLocalEvent(entity, ref ev);
+    }
+
+    private void SetTelephoneMicrophoneState(Entity<TelephoneComponent> entity, bool microphoneOn)
+    {
+        if (microphoneOn && !HasComp<ActiveListenerComponent>(entity))
+        {
+            var activeListener = AddComp<ActiveListenerComponent>(entity);
+            activeListener.Range = entity.Comp.ListeningRange;
+        }
+
+        if (!microphoneOn && HasComp<ActiveListenerComponent>(entity))
+        {
+            RemComp<ActiveListenerComponent>(entity);
+        }
+    }
+
+    private (string?, string?) GetNameAndJobOfCallingEntity(EntityUid uid)
+    {
+        string? presumedName = null;
+        string? presumedJob = null;
+
+        if (HasComp<StationAiHeldComponent>(uid) || HasComp<BorgChassisComponent>(uid))
+        {
+            presumedName = Name(uid);
+            return (presumedName, presumedJob);
+        }
+
+        if (_idCardSystem.TryFindIdCard(uid, out var idCard))
+        {
+            presumedName = string.IsNullOrWhiteSpace(idCard.Comp.FullName) ? null : idCard.Comp.FullName;
+            presumedJob = idCard.Comp.LocalizedJobTitle;
+        }
+
+        return (presumedName, presumedJob);
+    }
+
+    public bool IsSourceAbleToReachReceiver(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver)
+    {
+        if (source == receiver ||
+            !IsTelephonePowered(source) ||
+            !IsTelephonePowered(receiver) ||
+            !IsSourceInRangeOfReceiver(source, receiver))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    public bool IsSourceInRangeOfReceiver(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver)
+    {
+        var sourceXform = Transform(source);
+        var receiverXform = Transform(receiver);
+
+        switch (source.Comp.TransmissionRange)
+        {
+            case TelephoneRange.Grid:
+                return sourceXform.GridUid != null &&
+                    receiverXform.GridUid == sourceXform.GridUid &&
+                    receiver.Comp.TransmissionRange != TelephoneRange.Long;
+
+            case TelephoneRange.Map:
+                return sourceXform.MapID == receiverXform.MapID &&
+                    receiver.Comp.TransmissionRange != TelephoneRange.Long;
+
+            case TelephoneRange.Long:
+                return sourceXform.MapID != receiverXform.MapID &&
+                    receiver.Comp.TransmissionRange == TelephoneRange.Long;
+
+            case TelephoneRange.Unlimited:
+                return true;
+        }
+
+        return false;
+    }
+
+    public bool IsSourceConnectedToReceiver(Entity<TelephoneComponent> source, Entity<TelephoneComponent> receiver)
+    {
+        return source.Comp.LinkedTelephones.Contains(receiver);
+    }
+
+    public bool IsTelephonePowered(Entity<TelephoneComponent> entity)
+    {
+        return this.IsPowered(entity, EntityManager) || !entity.Comp.RequiresPower;
+    }
+}
diff --git a/Content.Shared/Doors/AirlockWireStatus.cs b/Content.Shared/Doors/AirlockWireStatus.cs
index d3fa15ed1b..3a8570ebd1 100644
--- a/Content.Shared/Doors/AirlockWireStatus.cs
+++ b/Content.Shared/Doors/AirlockWireStatus.cs
@@ -1,4 +1,4 @@
-using Robust.Shared.Serialization;
+using Robust.Shared.Serialization;
 
 namespace Content.Shared.Doors
 {
@@ -9,6 +9,7 @@ namespace Content.Shared.Doors
         BoltIndicator,
         BoltLightIndicator,
         AiControlIndicator,
+        AiVisionIndicator,
         TimingIndicator,
         SafetyIndicator,
     }
diff --git a/Content.Shared/Holopad/HolographicAvatarComponent.cs b/Content.Shared/Holopad/HolographicAvatarComponent.cs
new file mode 100644
index 0000000000..be7f5bcb91
--- /dev/null
+++ b/Content.Shared/Holopad/HolographicAvatarComponent.cs
@@ -0,0 +1,13 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Holopad;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HolographicAvatarComponent : Component
+{
+    /// <summary>
+    /// The prototype sprite layer data for the hologram
+    /// </summary>
+    [DataField]
+    public PrototypeLayerData[] LayerData;
+}
diff --git a/Content.Shared/Holopad/HolopadComponent.cs b/Content.Shared/Holopad/HolopadComponent.cs
new file mode 100644
index 0000000000..98f05b03f9
--- /dev/null
+++ b/Content.Shared/Holopad/HolopadComponent.cs
@@ -0,0 +1,133 @@
+using Content.Shared.Telephone;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Holopad;
+
+/// <summary>
+/// Holds data pertaining to holopads
+/// </summary>
+/// <remarks>
+/// Holopads also require a <see cref="TelephoneComponent"/> to function
+/// </remarks>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedHolopadSystem))]
+public sealed partial class HolopadComponent : Component
+{
+    /// <summary>
+    /// The entity being projected by the holopad
+    /// </summary>
+    [ViewVariables]
+    public Entity<HolopadHologramComponent>? Hologram;
+
+    /// <summary>
+    /// The entity using the holopad
+    /// </summary>
+    [ViewVariables]
+    public Entity<HolopadUserComponent>? User;
+
+    /// <summary>
+    /// Proto ID for the user's hologram
+    /// </summary>
+    [DataField]
+    public EntProtoId? HologramProtoId;
+
+    /// <summary>
+    /// The entity that has locked out the controls of this device
+    /// </summary>
+    [ViewVariables, AutoNetworkedField]
+    public EntityUid? ControlLockoutOwner = null;
+
+    /// <summary>
+    /// The game tick the control lockout was initiated
+    /// </summary>
+    [ViewVariables, AutoNetworkedField]
+    public TimeSpan ControlLockoutStartTime;
+
+    /// <summary>
+    /// The duration that the control lockout will last in seconds
+    /// </summary>
+    [DataField]
+    public float ControlLockoutDuration { get; private set; } = 90f;
+
+    /// <summary>
+    /// The duration before the controls can be lockout again in seconds
+    /// </summary>
+    [DataField]
+    public float ControlLockoutCoolDown { get; private set; } = 180f;
+}
+
+#region: Event messages
+
+/// <summary>
+///     Data from by the server to the client for the holopad UI
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadBoundInterfaceState : BoundUserInterfaceState
+{
+    public readonly Dictionary<NetEntity, string> Holopads;
+
+    public HolopadBoundInterfaceState(Dictionary<NetEntity, string> holopads)
+    {
+        Holopads = holopads;
+    }
+}
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadStartNewCallMessage : BoundUserInterfaceMessage
+{
+    public readonly NetEntity Receiver;
+
+    public HolopadStartNewCallMessage(NetEntity receiver)
+    {
+        Receiver = receiver;
+    }
+}
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadAnswerCallMessage : BoundUserInterfaceMessage { }
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadEndCallMessage : BoundUserInterfaceMessage { }
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadStartBroadcastMessage : BoundUserInterfaceMessage { }
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadActivateProjectorMessage : BoundUserInterfaceMessage { }
+
+/// <summary>
+///     Triggers the server to send updated power monitoring console data to the client for the single player session
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadStationAiRequestMessage : BoundUserInterfaceMessage { }
+
+#endregion
+
+/// <summary>
+/// Key to the Holopad UI
+/// </summary>
+[Serializable, NetSerializable]
+public enum HolopadUiKey : byte
+{
+    InteractionWindow,
+    InteractionWindowForAi,
+    AiActionWindow,
+    AiRequestWindow
+}
diff --git a/Content.Shared/Holopad/HolopadHologramComponent.cs b/Content.Shared/Holopad/HolopadHologramComponent.cs
new file mode 100644
index 0000000000..a75ae27623
--- /dev/null
+++ b/Content.Shared/Holopad/HolopadHologramComponent.cs
@@ -0,0 +1,71 @@
+using Robust.Shared.GameStates;
+using System.Numerics;
+
+namespace Content.Shared.Holopad;
+
+/// <summary>
+/// Holds data pertaining to holopad holograms
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HolopadHologramComponent : Component
+{
+    /// <summary>
+    /// Default RSI path
+    /// </summary>
+    [DataField]
+    public string RsiPath = string.Empty;
+
+    /// <summary>
+    /// Default RSI state
+    /// </summary>
+    [DataField]
+    public string RsiState = string.Empty;
+
+    /// <summary>
+    /// Name of the shader to use
+    /// </summary>
+    [DataField]
+    public string ShaderName = string.Empty;
+
+    /// <summary>
+    /// The primary color
+    /// </summary>
+    [DataField]
+    public Color Color1 = Color.White;
+
+    /// <summary>
+    /// The secondary color
+    /// </summary>
+    [DataField]
+    public Color Color2 = Color.White;
+
+    /// <summary>
+    /// The shared color alpha
+    /// </summary>
+    [DataField]
+    public float Alpha = 1f;
+
+    /// <summary>
+    /// The color brightness
+    /// </summary>
+    [DataField]
+    public float Intensity = 1f;
+
+    /// <summary>
+    /// The scroll rate of the hologram shader
+    /// </summary>
+    [DataField]
+    public float ScrollRate = 1f;
+
+    /// <summary>
+    /// The sprite offset
+    /// </summary>
+    [DataField]
+    public Vector2 Offset = new Vector2();
+
+    /// <summary>
+    /// A user that are linked to this hologram
+    /// </summary>
+    [ViewVariables]
+    public Entity<HolopadComponent>? LinkedHolopad;
+}
diff --git a/Content.Shared/Holopad/HolopadUserComponent.cs b/Content.Shared/Holopad/HolopadUserComponent.cs
new file mode 100644
index 0000000000..9ff20c2e7b
--- /dev/null
+++ b/Content.Shared/Holopad/HolopadUserComponent.cs
@@ -0,0 +1,104 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Holopad;
+
+/// <summary>
+/// Holds data pertaining to entities that are using holopads
+/// </summary>
+/// <remarks>
+/// This component is added and removed automatically from entities
+/// </remarks>
+[RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedHolopadSystem))]
+public sealed partial class HolopadUserComponent : Component
+{
+    /// <summary>
+    /// A list of holopads that the user is interacting with
+    /// </summary>
+    [ViewVariables]
+    public HashSet<Entity<HolopadComponent>> LinkedHolopads = new();
+}
+
+/// <summary>
+/// A networked event raised when the visual state of a hologram is being updated
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadHologramVisualsUpdateEvent : EntityEventArgs
+{
+    /// <summary>
+    /// The hologram being updated
+    /// </summary>
+    public readonly NetEntity Hologram;
+
+    /// <summary>
+    /// The target the hologram is copying
+    /// </summary>
+    public readonly NetEntity? Target;
+
+    public HolopadHologramVisualsUpdateEvent(NetEntity hologram, NetEntity? target = null)
+    {
+        Hologram = hologram;
+        Target = target;
+    }
+}
+
+/// <summary>
+/// A networked event raised when the visual state of a hologram is being updated
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class HolopadUserTypingChangedEvent : EntityEventArgs
+{
+    /// <summary>
+    /// The hologram being updated
+    /// </summary>
+    public readonly NetEntity User;
+
+    /// <summary>
+    /// The typing indicator state
+    /// </summary>
+    public readonly bool IsTyping;
+
+    public HolopadUserTypingChangedEvent(NetEntity user, bool isTyping)
+    {
+        User = user;
+        IsTyping = isTyping;
+    }
+}
+
+/// <summary>
+/// A networked event raised by the server to request the current visual state of a target player entity
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlayerSpriteStateRequest : EntityEventArgs
+{
+    /// <summary>
+    /// The player entity in question
+    /// </summary>
+    public readonly NetEntity TargetPlayer;
+
+    public PlayerSpriteStateRequest(NetEntity targetPlayer)
+    {
+        TargetPlayer = targetPlayer;
+    }
+}
+
+/// <summary>
+/// The client's response to a <see cref="PlayerSpriteStateRequest"/>
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class PlayerSpriteStateMessage : EntityEventArgs
+{
+    public readonly NetEntity SpriteEntity;
+
+    /// <summary>
+    /// Data needed to reconstruct the player's sprite component layers
+    /// </summary>
+    public readonly PrototypeLayerData[]? SpriteLayerData;
+
+    public PlayerSpriteStateMessage(NetEntity spriteEntity, PrototypeLayerData[]? spriteLayerData = null)
+    {
+        SpriteEntity = spriteEntity;
+        SpriteLayerData = spriteLayerData;
+    }
+}
diff --git a/Content.Shared/Holopad/SharedHolopadSystem.cs b/Content.Shared/Holopad/SharedHolopadSystem.cs
new file mode 100644
index 0000000000..ea122828bf
--- /dev/null
+++ b/Content.Shared/Holopad/SharedHolopadSystem.cs
@@ -0,0 +1,43 @@
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Holopad;
+
+public abstract class SharedHolopadSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    public bool IsHolopadControlLocked(Entity<HolopadComponent> entity, EntityUid? user = null)
+    {
+        if (entity.Comp.ControlLockoutStartTime == TimeSpan.Zero)
+            return false;
+
+        if (entity.Comp.ControlLockoutStartTime + TimeSpan.FromSeconds(entity.Comp.ControlLockoutDuration) < _timing.CurTime)
+            return false;
+
+        if (entity.Comp.ControlLockoutOwner == null || entity.Comp.ControlLockoutOwner == user)
+            return false;
+
+        return true;
+    }
+
+    public TimeSpan GetHolopadControlLockedPeriod(Entity<HolopadComponent> entity)
+    {
+        return entity.Comp.ControlLockoutStartTime + TimeSpan.FromSeconds(entity.Comp.ControlLockoutDuration) - _timing.CurTime;
+    }
+
+    public bool IsHolopadBroadcastOnCoolDown(Entity<HolopadComponent> entity)
+    {
+        if (entity.Comp.ControlLockoutStartTime == TimeSpan.Zero)
+            return false;
+
+        if (entity.Comp.ControlLockoutStartTime + TimeSpan.FromSeconds(entity.Comp.ControlLockoutCoolDown) < _timing.CurTime)
+            return false;
+
+        return true;
+    }
+
+    public TimeSpan GetHolopadBroadcastCoolDown(Entity<HolopadComponent> entity)
+    {
+        return entity.Comp.ControlLockoutStartTime + TimeSpan.FromSeconds(entity.Comp.ControlLockoutCoolDown) - _timing.CurTime;
+    }
+}
diff --git a/Content.Shared/Silicons/StationAi/SharedStationAiSystem.cs b/Content.Shared/Silicons/StationAi/SharedStationAiSystem.cs
index 5fca5cad28..4937e6e84c 100644
--- a/Content.Shared/Silicons/StationAi/SharedStationAiSystem.cs
+++ b/Content.Shared/Silicons/StationAi/SharedStationAiSystem.cs
@@ -20,12 +20,15 @@ using Content.Shared.Verbs;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Network;
 using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
 using Robust.Shared.Timing;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Content.Shared.Silicons.StationAi;
 
@@ -68,6 +71,8 @@ public abstract partial class SharedStationAiSystem : EntitySystem
     [ValidatePrototypeId<EntityPrototype>]
     private static readonly EntProtoId DefaultAi = "StationAiBrain";
 
+    private const float MaxVisionMultiplier = 5f;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -344,16 +349,47 @@ public abstract partial class SharedStationAiSystem : EntitySystem
         AttachEye(ent);
     }
 
-    private bool SetupEye(Entity<StationAiCoreComponent> ent)
+    public void SwitchRemoteEntityMode(Entity<StationAiCoreComponent> ent, bool isRemote)
+    {
+        if (isRemote == ent.Comp.Remote)
+            return;
+
+        ent.Comp.Remote = isRemote;
+
+        EntityCoordinates? coords = ent.Comp.RemoteEntity != null ? Transform(ent.Comp.RemoteEntity.Value).Coordinates : null;
+
+        // Attach new eye
+        ClearEye(ent);
+
+        if (SetupEye(ent, coords))
+            AttachEye(ent);
+
+        // Adjust user FoV
+        var user = GetInsertedAI(ent);
+
+        if (TryComp<EyeComponent>(user, out var eye))
+            _eye.SetDrawFov(user.Value, !isRemote);
+    }
+
+    private bool SetupEye(Entity<StationAiCoreComponent> ent, EntityCoordinates? coords = null)
     {
         if (_net.IsClient)
             return false;
+
         if (ent.Comp.RemoteEntity != null)
             return false;
 
-        if (ent.Comp.RemoteEntityProto != null)
+        var proto = ent.Comp.RemoteEntityProto;
+
+        if (coords == null)
+            coords = Transform(ent.Owner).Coordinates;
+
+        if (!ent.Comp.Remote)
+            proto = ent.Comp.PhysicalEntityProto;
+
+        if (proto != null)
         {
-            ent.Comp.RemoteEntity = SpawnAtPosition(ent.Comp.RemoteEntityProto, Transform(ent.Owner).Coordinates);
+            ent.Comp.RemoteEntity = SpawnAtPosition(proto, coords.Value);
             Dirty(ent);
         }
 
@@ -364,6 +400,7 @@ public abstract partial class SharedStationAiSystem : EntitySystem
     {
         if (_net.IsClient)
             return;
+
         QueueDel(ent.Comp.RemoteEntity);
         ent.Comp.RemoteEntity = null;
         Dirty(ent);
@@ -392,6 +429,17 @@ public abstract partial class SharedStationAiSystem : EntitySystem
         _mover.SetRelay(user, ent.Comp.RemoteEntity.Value);
     }
 
+    private EntityUid? GetInsertedAI(Entity<StationAiCoreComponent> ent)
+    {
+        if (!_containers.TryGetContainer(ent.Owner, StationAiHolderComponent.Container, out var container) ||
+            container.ContainedEntities.Count != 1)
+        {
+            return null;
+        }
+
+        return container.ContainedEntities[0];
+    }
+
     private void OnAiInsert(Entity<StationAiCoreComponent> ent, ref EntInsertedIntoContainerMessage args)
     {
         if (args.Container.ID != StationAiCoreComponent.Container)
@@ -400,6 +448,7 @@ public abstract partial class SharedStationAiSystem : EntitySystem
         if (_timing.ApplyingState)
             return;
 
+        ent.Comp.Remote = true;
         SetupEye(ent);
 
         // Just so text and the likes works properly
@@ -413,6 +462,8 @@ public abstract partial class SharedStationAiSystem : EntitySystem
         if (_timing.ApplyingState)
             return;
 
+        ent.Comp.Remote = true;
+
         // Reset name to whatever
         _metadata.SetEntityName(ent.Owner, Prototype(ent.Owner)?.Name ?? string.Empty);
 
@@ -424,6 +475,7 @@ public abstract partial class SharedStationAiSystem : EntitySystem
             _eye.SetDrawFov(args.Entity, true, eyeComp);
             _eye.SetTarget(args.Entity, null, eyeComp);
         }
+
         ClearEye(ent);
     }
 
@@ -478,6 +530,36 @@ public abstract partial class SharedStationAiSystem : EntitySystem
 
         return _blocker.CanComplexInteract(entity.Owner);
     }
+
+    public bool TryGetStationAiCore(Entity<StationAiHeldComponent?> ent, [NotNullWhen(true)] out Entity<StationAiCoreComponent>? parentEnt)
+    {
+        parentEnt = null;
+        var parent = Transform(ent).ParentUid;
+
+        if (!parent.IsValid())
+            return false;
+
+        if (!TryComp<StationAiCoreComponent>(parent, out var stationAiCore))
+            return false;
+
+        parentEnt = new Entity<StationAiCoreComponent>(parent, stationAiCore);
+
+        return true;
+    }
+
+    public bool TryGetInsertedAI(Entity<StationAiCoreComponent> ent, [NotNullWhen(true)] out Entity<StationAiHeldComponent>? insertedAi)
+    {
+        insertedAi = null;
+        var insertedEnt = GetInsertedAI(ent);
+
+        if (TryComp<StationAiHeldComponent>(insertedEnt, out var stationAiHeld))
+        {
+            insertedAi = (insertedEnt.Value, stationAiHeld);
+            return true;
+        }
+
+        return false;
+    }
 }
 
 public sealed partial class JumpToCoreEvent : InstantActionEvent
diff --git a/Content.Shared/Silicons/StationAi/StationAiCoreComponent.cs b/Content.Shared/Silicons/StationAi/StationAiCoreComponent.cs
index b7a8b4cd5f..e97e7626b8 100644
--- a/Content.Shared/Silicons/StationAi/StationAiCoreComponent.cs
+++ b/Content.Shared/Silicons/StationAi/StationAiCoreComponent.cs
@@ -15,6 +15,7 @@ public sealed partial class StationAiCoreComponent : Component
 
     /// <summary>
     /// Can it move its camera around and interact remotely with things.
+    /// When false, the AI is being projected into a local area, such as a holopad
     /// </summary>
     [DataField, AutoNetworkedField]
     public bool Remote = true;
@@ -25,8 +26,17 @@ public sealed partial class StationAiCoreComponent : Component
     [DataField, AutoNetworkedField]
     public EntityUid? RemoteEntity;
 
+    /// <summary>
+    /// Prototype that represents the 'eye' of the AI
+    /// </summary>
     [DataField(readOnly: true)]
     public EntProtoId? RemoteEntityProto = "StationAiHolo";
 
+    /// <summary>
+    /// Prototype that represents the physical avatar of the AI
+    /// </summary>
+    [DataField(readOnly: true)]
+    public EntProtoId? PhysicalEntityProto = "StationAiHoloLocal";
+
     public const string Container = "station_ai_mind_slot";
 }
diff --git a/Content.Shared/Speech/SpeechComponent.cs b/Content.Shared/Speech/SpeechComponent.cs
index 0882120718..8c12fc918a 100644
--- a/Content.Shared/Speech/SpeechComponent.cs
+++ b/Content.Shared/Speech/SpeechComponent.cs
@@ -56,5 +56,11 @@ namespace Content.Shared.Speech
         public float SoundCooldownTime { get; set; } = 0.5f;
 
         public TimeSpan LastTimeSoundPlayed = TimeSpan.Zero;
+
+        /// <summary>
+        /// Additional vertical offset for speech bubbles generated by this entity
+        /// </summary>
+        [DataField]
+        public float SpeechBubbleOffset = 0f;
     }
 }
diff --git a/Content.Shared/Telephone/SharedTelephoneSystem.cs b/Content.Shared/Telephone/SharedTelephoneSystem.cs
new file mode 100644
index 0000000000..ab423623cb
--- /dev/null
+++ b/Content.Shared/Telephone/SharedTelephoneSystem.cs
@@ -0,0 +1,39 @@
+using System.Linq;
+
+namespace Content.Shared.Telephone;
+
+public abstract class SharedTelephoneSystem : EntitySystem
+{
+    public bool IsTelephoneEngaged(Entity<TelephoneComponent> entity)
+    {
+        return entity.Comp.LinkedTelephones.Any();
+    }
+
+    public string GetFormattedCallerIdForEntity(string? presumedName, string? presumedJob, Color fontColor, string fontType = "Default", int fontSize = 12)
+    {
+        var callerId = Loc.GetString("chat-telephone-unknown-caller",
+            ("color", fontColor),
+            ("fontType", fontType),
+            ("fontSize", fontSize));
+
+        if (presumedName == null)
+            return callerId;
+
+        if (presumedJob != null)
+            callerId = Loc.GetString("chat-telephone-caller-id-with-job",
+                ("callerName", presumedName),
+                ("callerJob", presumedJob),
+                ("color", fontColor),
+                ("fontType", fontType),
+                ("fontSize", fontSize));
+
+        else
+            callerId = Loc.GetString("chat-telephone-caller-id-without-job",
+                ("callerName", presumedName),
+                ("color", fontColor),
+                ("fontType", fontType),
+                ("fontSize", fontSize));
+
+        return callerId;
+    }
+}
diff --git a/Content.Shared/Telephone/TelephoneComponent.cs b/Content.Shared/Telephone/TelephoneComponent.cs
new file mode 100644
index 0000000000..7eacdb0aee
--- /dev/null
+++ b/Content.Shared/Telephone/TelephoneComponent.cs
@@ -0,0 +1,203 @@
+using Content.Shared.Chat;
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Telephone;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedTelephoneSystem))]
+public sealed partial class TelephoneComponent : Component
+{
+    /// <summary>
+    /// Sets how long the telephone will ring before it automatically hangs up
+    /// </summary>
+    [DataField]
+    public float RingingTimeout = 30;
+
+    /// <summary>
+    /// Sets how long the telephone can remain idle in-call before it automatically hangs up
+    /// </summary>
+    [DataField]
+    public float IdlingTimeout = 60;
+
+    /// <summary>
+    /// Sets how long the telephone will stay in the hanging up state before return to idle
+    /// </summary>
+    [DataField]
+    public float HangingUpTimeout = 2;
+
+    /// <summary>
+    /// Tone played while the phone is ringing
+    /// </summary>
+    [DataField]
+    public SoundSpecifier? RingTone = null;
+
+    /// <summary>
+    /// Sets the number of seconds before the next ring tone is played
+    /// </summary>
+    [DataField]
+    public float RingInterval = 2f;
+
+    /// <summary>
+    /// The time at which the next tone will be played
+    /// </summary>
+    [DataField]
+    public TimeSpan NextRingToneTime;
+
+    /// <summary>
+    /// The volume at which relayed messages are played
+    /// </summary>
+    [DataField]
+    public TelephoneVolume SpeakerVolume = TelephoneVolume.Whisper;
+
+    /// <summary>
+    /// The range at which the telephone can connect to another
+    /// </summary>
+    [DataField]
+    public TelephoneRange TransmissionRange = TelephoneRange.Grid;
+
+    /// <summary>
+    /// The range at which the telephone picks up voices
+    /// </summary>
+    [DataField]
+    public float ListeningRange = 2;
+
+    /// <summary>
+    /// Specifies whether this telephone require power to fucntion
+    /// </summary>
+    [DataField]
+    public bool RequiresPower = true;
+
+    /// <summary>
+    /// This telephone does not appear on public telephone directories
+    /// </summary>
+    [DataField]
+    public bool UnlistedNumber = false;
+
+    /// <summary>
+    /// Telephone number for this device
+    /// </summary>
+    /// <remarks>
+    /// For future use - a system for generating and handling telephone numbers has not been implemented yet
+    /// </remarks>
+    [ViewVariables]
+    public int TelephoneNumber = -1;
+
+    /// <summary>
+    /// Linked telephone
+    /// </summary>
+    [ViewVariables]
+    public HashSet<Entity<TelephoneComponent>> LinkedTelephones = new();
+
+    /// <summary>
+    /// Defines the current state the telephone is in
+    /// </summary>
+    [ViewVariables, AutoNetworkedField]
+    public TelephoneState CurrentState = TelephoneState.Idle;
+
+    /// <summary>
+    /// The game tick the current state started
+    /// </summary>
+    [ViewVariables]
+    public TimeSpan StateStartTime;
+
+    /// <summary>
+    /// Sets whether the telphone can pick up nearby speech
+    /// </summary>
+    [ViewVariables]
+    public bool Muted = false;
+
+    /// <summary>
+    /// The presumed name and/or job of the last person to call this telephone
+    /// </summary>
+    [ViewVariables, AutoNetworkedField]
+    public (string?, string?) LastCallerId;
+}
+
+#region: Telephone events
+
+/// <summary>
+/// Raised when one telephone is attempting to call another
+/// </summary>
+[ByRefEvent]
+public record struct TelephoneCallAttemptEvent(Entity<TelephoneComponent> Source, Entity<TelephoneComponent> Receiver, EntityUid? User)
+{
+    public bool Cancelled = false;
+}
+
+/// <summary>
+/// Raised when a telephone's state changes
+/// </summary>
+[ByRefEvent]
+public record struct TelephoneStateChangeEvent(TelephoneState OldState, TelephoneState NewState);
+
+/// <summary>
+/// Raised when communication between one telephone and another begins
+/// </summary>
+[ByRefEvent]
+public record struct TelephoneCallCommencedEvent(Entity<TelephoneComponent> Receiver);
+
+/// <summary>
+/// Raised when a telephone hangs up
+/// </summary>
+[ByRefEvent]
+public record struct TelephoneCallEndedEvent();
+
+/// <summary>
+/// Raised when a chat message is sent by a telephone to another
+/// </summary>
+[ByRefEvent]
+public readonly record struct TelephoneMessageSentEvent(string Message, MsgChatMessage ChatMsg, EntityUid MessageSource);
+
+/// <summary>
+/// Raised when a chat message is received by a telephone from another
+/// </summary>
+[ByRefEvent]
+public readonly record struct TelephoneMessageReceivedEvent(string Message, MsgChatMessage ChatMsg, EntityUid MessageSource, Entity<TelephoneComponent> TelephoneSource);
+
+#endregion
+
+/// <summary>
+/// Options for tailoring telephone calls
+/// </summary>
+[Serializable, NetSerializable]
+public struct TelephoneCallOptions
+{
+    public bool ForceConnect;   // The source immediately starts a call with the receiver, potentially interrupting a call that is already in progress 
+    public bool ForceJoin;      // The source smoothly joins a call in progress, or starts a normal call with the receiver if there is none
+    public bool MuteSource;     // Chatter from the source is not transmitted - could be used for eavesdropping when combined with 'ForceJoin'
+    public bool MuteReceiver;   // Chatter from the receiver is not transmitted - useful for broadcasting messages to multiple receivers
+}
+
+[Serializable, NetSerializable]
+public enum TelephoneVisuals : byte
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public enum TelephoneState : byte
+{
+    Idle,
+    Calling,
+    Ringing,
+    InCall,
+    EndingCall
+}
+
+[Serializable, NetSerializable]
+public enum TelephoneVolume : byte
+{
+    Whisper,
+    Speak
+}
+
+[Serializable, NetSerializable]
+public enum TelephoneRange : byte
+{
+    Grid,       // Can call grid/map range telephones that are on the same grid 
+    Map,        // Can call grid/map range telephones that are on the same map 
+    Long,       // Can only long range telephones that are on a different map
+    Unlimited   // Can call any telephone
+}
diff --git a/Resources/Audio/Machines/attributions.yml b/Resources/Audio/Machines/attributions.yml
index bcbf1036c3..fe144d4338 100644
--- a/Resources/Audio/Machines/attributions.yml
+++ b/Resources/Audio/Machines/attributions.yml
@@ -172,6 +172,11 @@
   license: "CC0-1.0"
   copyright: "by Ko4erga"
   source: "https://github.com/space-wizards/space-station-14/pull/30431"
+  
+- files: ["double_ring.ogg"]
+  license: "CC0-1.0"
+  copyright: "Created by fspera, converted to OGG and modified by chromiumboy."
+  source: "https://freesound.org/people/fspera/sounds/528111/"
 
 - files:
   - airlock_emergencyoff.ogg
diff --git a/Resources/Audio/Machines/double_ring.ogg b/Resources/Audio/Machines/double_ring.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..bfe1b21f4106349a0cc183c471bd97bb9b1fd914
GIT binary patch
literal 16754
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

literal 0
HcmV?d00001

diff --git a/Resources/Locale/en-US/holopad/holopad.ftl b/Resources/Locale/en-US/holopad/holopad.ftl
new file mode 100644
index 0000000000..01a1e13dcb
--- /dev/null
+++ b/Resources/Locale/en-US/holopad/holopad.ftl
@@ -0,0 +1,40 @@
+# Window headers
+holopad-window-title = {CAPITALIZE($title)}
+holopad-window-subtitle = [color=white][bold]Holographic communication system[/bold][/color]
+holopad-window-options = [color=darkgray][font size=10][italic]Please select an option from the list below[/italic][/font][/color]
+
+# Call status
+holopad-window-no-calls-in-progress = No holo-calls in progress
+holopad-window-incoming-call = Incoming holo-call from:
+holopad-window-outgoing-call = Attempting to establish a connection...
+holopad-window-call-in-progress = Holo-call in progress
+holopad-window-call-ending = Disconnecting...
+holopad-window-call-rejected = Unable to establish a connection
+holopad-window-ai-request = Your presence is requested by:
+holopad-window-emergency-broadcast-in-progress = [color=#cf2f2f][bold]Emergency broadcast in progress[/bold][/color]
+holopad-window-controls-locked-out = Control of this device has been locked to:
+holopad-window-controls-unlock-countdown = It will automatically unlock in: {$countdown}
+
+# Buttons
+holopad-window-answer-call = Answer call
+holopad-window-end-call = End call
+holopad-window-request-station-ai = Request station AI
+holopad-window-activate-projector = Activate projector
+holopad-window-emergency-broadcast = Emergency broadcast
+holopad-window-emergency-broadcast-with-countdown = Emergency broadcast ({$countdown})
+holopad-window-access-denied = Access denied
+
+# Contact list
+holopad-window-select-contact-from-list = Select a contact to initiate a holo-call
+holopad-window-fetching-contacts-list = No holopads are currently contactable
+holopad-window-contact-label = {CAPITALIZE($label)}
+
+# Flavor
+holopad-window-flavor-left = ⚠ Do not enter while projector is active
+holopad-window-flavor-right = v3.0.9
+
+# Holograms
+holopad-hologram-name = hologram of {THE($name)}
+
+# Holopad actions
+activate-holopad-projector-verb = Activate holopad projector
\ No newline at end of file
diff --git a/Resources/Locale/en-US/telephone/telephone.ftl b/Resources/Locale/en-US/telephone/telephone.ftl
new file mode 100644
index 0000000000..915d54843f
--- /dev/null
+++ b/Resources/Locale/en-US/telephone/telephone.ftl
@@ -0,0 +1,8 @@
+# Chat window telephone wrap (prefix and postfix)
+chat-telephone-message-wrap = [color={$color}][bold]{$name}[/bold] {$verb}, [font={$fontType} size={$fontSize}]"{$message}"[/font][/color]
+chat-telephone-message-wrap-bold = [color={$color}][bold]{$name}[/bold] {$verb}, [font={$fontType} size={$fontSize}][bold]"{$message}"[/bold][/font][/color]
+
+# Caller ID
+chat-telephone-unknown-caller = [color={$color}][font={$fontType} size={$fontSize}][bolditalic]Unknown caller[/bolditalic][/font][/color]
+chat-telephone-caller-id-with-job = [color={$color}][font={$fontType} size={$fontSize}][bold]{CAPITALIZE($callerName)} ({CAPITALIZE($callerJob)})[/bold][/font][/color]
+chat-telephone-caller-id-without-job = [color={$color}][font={$fontType} size={$fontSize}][bold]{CAPITALIZE($callerName)}[/bold][/font][/color]
\ No newline at end of file
diff --git a/Resources/Locale/en-US/wires/wire-names.ftl b/Resources/Locale/en-US/wires/wire-names.ftl
index 670f01d736..08e5af4000 100644
--- a/Resources/Locale/en-US/wires/wire-names.ftl
+++ b/Resources/Locale/en-US/wires/wire-names.ftl
@@ -41,6 +41,7 @@ wires-board-name-flatpacker = Flatpacker
 wires-board-name-spaceheater = Space Heater
 wires-board-name-jukebox = Jukebox
 wires-board-name-computer = Computer
+wires-board-name-holopad = Holopad
 wires-board-name-barsign = Bar Sign
 
 # names that get displayed in the wire hacking hud & admin logs.
diff --git a/Resources/Prototypes/Entities/Mobs/Player/silicon.yml b/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
index 7b03455a08..9a9d66c42d 100644
--- a/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
+++ b/Resources/Prototypes/Entities/Mobs/Player/silicon.yml
@@ -70,6 +70,10 @@
     canShuttle: false
     title: comms-console-announcement-title-station-ai
     color: "#5ed7aa"
+  - type: HolographicAvatar
+    layerData:
+    - sprite: Mobs/Silicon/station_ai.rsi
+      state: default
   - type: ShowJobIcons
 
 - type: entity
@@ -364,6 +368,19 @@
         unshaded:
           Empty: { state: ai_empty }
           Occupied: { state: ai }
+  - type: Telephone
+    listeningRange: 0
+    speakerVolume: Speak
+    unlistedNumber: true
+    requiresPower: false
+  - type: Holopad
+  - type: StationAiWhitelist  
+  - type: UserInterface
+    interfaces:
+        enum.HolopadUiKey.AiRequestWindow:
+          type: HolopadBoundUserInterface
+        enum.HolopadUiKey.AiActionWindow:
+          type: HolopadBoundUserInterface
 
 # The job-ready version of an AI spawn.
 - type: entity
@@ -446,6 +463,28 @@
       shader: unshaded
       map: ["base"]
 
+# The holographic representation of the AI that is projected from a holopad.
+- type: entity
+  id: StationAiHoloLocal
+  name: AI hologram
+  description: A holographic representation of an AI.
+  categories: [ HideSpawnMenu ]
+  suffix: DO NOT MAP
+  components:
+  - type: Transform
+    anchored: true
+  - type: WarpPoint
+    follow: true
+  - type: Eye
+  - type: ContentEye
+  - type: Examiner
+  - type: Actions
+  - type: Alerts
+  - type: FTLSmashImmune
+  - type: CargoSellBlacklist
+  - type: StationAiVision
+    range: 20
+
 # Borgs
 - type: entity
   id: PlayerBorgBattery
diff --git a/Resources/Prototypes/Entities/Objects/Devices/Circuitboards/Machine/holopad.yml b/Resources/Prototypes/Entities/Objects/Devices/Circuitboards/Machine/holopad.yml
new file mode 100644
index 0000000000..450a43c8d1
--- /dev/null
+++ b/Resources/Prototypes/Entities/Objects/Devices/Circuitboards/Machine/holopad.yml
@@ -0,0 +1,12 @@
+- type: entity
+  id: HolopadMachineCircuitboard
+  parent: BaseMachineCircuitboard
+  name: holopad machine board
+  description: A machine printed circuit board for a holopad.
+  components:
+    - type: MachineBoard
+      prototype: Holopad
+      stackRequirements:
+        Capacitor: 4
+        Cable: 4
+        Glass: 2
\ No newline at end of file
diff --git a/Resources/Prototypes/Entities/Structures/Machines/holopad.yml b/Resources/Prototypes/Entities/Structures/Machines/holopad.yml
new file mode 100644
index 0000000000..f59120fd4b
--- /dev/null
+++ b/Resources/Prototypes/Entities/Structures/Machines/holopad.yml
@@ -0,0 +1,158 @@
+- type: entity
+  parent: [ BaseMachinePowered, ConstructibleMachine ]
+  id: Holopad
+  name: holopad
+  description: "A floor-mounted device for projecting holographic images."
+  components:
+  - type: Transform
+    anchored: true
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeCircle
+          radius: 0.25
+        mask:
+        - SubfloorMask
+        layer:
+        - LowImpassable
+        hard: false
+  - type: ApcPowerReceiver
+    powerLoad: 300
+  - type: StationAiVision
+  - type: Sprite
+    sprite: Structures/Machines/holopad.rsi
+    snapCardinals: true
+    layers:
+    - state: base
+    - map: [ "lights" ]
+      state: blank
+      shader: unshaded
+    - map: [ "enum.PowerDeviceVisualLayers.Powered" ]
+      state: unpowered
+    - map: [ "enum.WiresVisualLayers.MaintenancePanel" ]
+      state: panel_open
+  - type: Appearance
+  - type: GenericVisualizer
+    visuals:
+      enum.TelephoneVisuals.Key:
+        lights:
+          Idle: { state: blank }
+          Calling: { state: lights_calling }
+          Ringing: { state: lights_ringing }
+          InCall: { state: lights_in_call }
+          EndingCall: { state: lights_hanging_up }
+      enum.PowerDeviceVisuals.Powered:
+        enum.PowerDeviceVisualLayers.Powered:
+          False: { visible: true }
+          True: { visible: false }
+      enum.WiresVisuals.MaintenancePanelState:
+        enum.WiresVisualLayers.MaintenancePanel:
+          True: { visible: false }
+          False: { visible: true }
+  - type: Machine
+    board: HolopadMachineCircuitboard
+  - type: StationAiWhitelist
+  - type: PointLight
+    radius: 1.3
+    energy: 1.8
+    color: "#afe1fe"
+    enabled: false
+  - type: AmbientSound
+    enabled: false
+    volume: -5
+    range: 3
+    sound:
+      path: /Audio/Ambience/Objects/buzzing.ogg
+  - type: Holopad
+    hologramProtoId: HolopadHologram
+  - type: Speech
+    speechVerb: Robotic
+    speechSounds: Borg
+    speechBubbleOffset: 0.45
+  - type: Telephone
+    transmissionRange: Map
+    ringTone: /Audio/Machines/double_ring.ogg
+    listeningRange: 4
+    speakerVolume: Speak
+  - type: AccessReader
+    access: [[ "Command" ]]
+  - type: ActivatableUI
+    key: enum.HolopadUiKey.InteractionWindow
+  - type: ActivatableUIRequiresPower
+  - type: UserInterface
+    interfaces:
+        enum.HolopadUiKey.InteractionWindow:
+          type: HolopadBoundUserInterface
+        enum.WiresUiKey.Key:
+          type: WiresBoundUserInterface
+  - type: WiresPanel
+  - type: WiresVisuals
+  - type: Wires
+    boardName: wires-board-name-holopad
+    layoutId: Holopad 
+  - type: Destructible
+    thresholds:
+    - trigger:
+        !type:DamageTrigger
+        damage: 100
+      behaviors:
+      - !type:PlaySoundBehavior
+        sound:
+          collection: MetalBreak
+      - !type:ChangeConstructionNodeBehavior
+        node: machineFrame
+      - !type:DoActsBehavior
+        acts: ["Destruction"]
+ 
+- type: entity
+  name: long-range holopad
+  description: "A floor-mounted device for projecting holographic images to other devices that are far away."
+  parent: Holopad
+  id: HolopadLongRange
+  suffix: For calls between maps
+  components:
+  - type: Telephone
+    transmissionRange: Long
+    
+- type: entity
+  name: quantum entangling holopad
+  description: "An experimental floor-mounted device for projecting holographic images at extreme distances."
+  parent: Holopad
+  id: HolopadUnlimitedRange
+  suffix: Unlimited range
+  components:
+  - type: Telephone
+    transmissionRange: Unlimited
+  - type: AccessReader
+    access: [[]]
+
+# These are spawned by holopads
+- type: entity
+  id: HolopadHologram
+  categories: [ HideSpawnMenu ]
+  suffix: DO NOT MAP    
+  components:
+  - type: Transform
+    anchored: true
+  - type: Sprite
+    noRot: true
+    drawdepth: Mobs
+    offset: -0.02, 0.45
+    overrideDir: South
+    enableOverrideDir: true
+  - type: Appearance
+  - type: TypingIndicator
+    proto: robot
+  - type: HolopadHologram
+    rsiPath: Structures/Machines/holopad.rsi
+    rsiState: icon_in_call
+    shaderName: Hologram
+    color1: "#65b8e2"
+    color2: "#3a6981"
+    alpha: 0.9
+    intensity: 2
+    scrollRate: 0.125
+  - type: Tag
+    tags:
+    - HideContextMenu
\ No newline at end of file
diff --git a/Resources/Prototypes/Shaders/shaders.yml b/Resources/Prototypes/Shaders/shaders.yml
index 136821efbb..6e0bbd55b4 100644
--- a/Resources/Prototypes/Shaders/shaders.yml
+++ b/Resources/Prototypes/Shaders/shaders.yml
@@ -104,3 +104,8 @@
   id: Cataracts
   kind: source
   path: "/Textures/Shaders/cataracts.swsl"
+
+- type: shader
+  id: Hologram
+  kind: source
+  path: "/Textures/Shaders/hologram.swsl"
\ No newline at end of file
diff --git a/Resources/Prototypes/Wires/layouts.yml b/Resources/Prototypes/Wires/layouts.yml
index 32b01cba81..32c1488683 100644
--- a/Resources/Prototypes/Wires/layouts.yml
+++ b/Resources/Prototypes/Wires/layouts.yml
@@ -190,10 +190,18 @@
   - !type:PowerWireAction
   - !type:AiInteractWireAction
 
+- type: wireLayout
+  id: Holopad
+  dummyWires: 2
+  wires:
+  - !type:PowerWireAction
+  - !type:AiInteractWireAction
+  - !type:AiVisionWireAction
+
 - type: wireLayout
   id: BarSign
   dummyWires: 2
   wires:
   - !type:PowerWireAction
   - !type:AiInteractWireAction
-  - !type:AccessWireAction
+  - !type:AccessWireAction
\ No newline at end of file
diff --git a/Resources/Textures/Shaders/hologram.swsl b/Resources/Textures/Shaders/hologram.swsl
new file mode 100644
index 0000000000..06fdccc2fa
--- /dev/null
+++ b/Resources/Textures/Shaders/hologram.swsl
@@ -0,0 +1,23 @@
+light_mode unshaded;
+
+uniform highp vec3 color1;
+uniform highp vec3 color2;
+uniform highp float alpha;
+uniform highp float intensity;
+uniform highp float texHeight;
+uniform highp float t;
+
+const highp float PI = 3.14159265;
+
+void fragment() {
+	highp vec4 base = texture2D(TEXTURE, UV);
+	highp float bw = zGrayscale(base.rgb * intensity);
+	highp vec4 color = vec4(vec3(color1), alpha);
+
+	if (sin(PI * (UV.y + t) * texHeight) < 0.0)
+	{
+		color = vec4(vec3(color2), alpha);
+	}
+
+	COLOR = vec4(vec3(bw), base.a) * color;
+}
\ No newline at end of file
diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/base.png b/Resources/Textures/Structures/Machines/holopad.rsi/base.png
new file mode 100644
index 0000000000000000000000000000000000000000..4d274e1406f0d8c128603ee03f69e870cb2bdd0b
GIT binary patch
literal 457
zcmV;)0XF`LP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80004yNkl<ZSi|jB
z&r1S97=06hNJuQLbkLic2n*&etDW{>dZ}ZV2>KuVpZXi>qIu|4iEDx&nqH(%8qp#0
z5KRYL*J9h98Gm%ycbS2i;d}4#&G&tP4<G*wBJxPj8}wy70su&I1ohi%B1&LGBzSo;
zf}(0rR1M|H2zuV2YjGeEPg4NU-wEoWY0UY3f6yT-b085<Q$^JP0QC@sBuA$9e+O4o
zZANhE4$KGlLfdR`IT2tDe)sTbKib^-ap&Xhb+*q<iBeV)WLe5Zoe1zKcT(@<0*@19
z*~)*r;8iPJbAVO7lMB({Cyq}}QL9!^D3$<#I+1WCkW0omHHT-rr{Qq%U*MMcUM@s~
zK)2TgV6WT+_#LoaXqydK{lZ$;nga;$AeW4Je#e#Nz(SR<Kj;uij?he2#pTVtP#rkj
z-$ScuLZ}YRx86dr<eEfINbROjt5%ri1kVc=iSvsqre1J%bif>(xf`-N!K0jeAkp&%
z&16-KpT~~p^0tgt)8rn{geIcDATkm8@ZsYNAC|pEd%3(!00000NkvXXu0mjfFlf+J

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/blank.png b/Resources/Textures/Structures/Machines/holopad.rsi/blank.png
new file mode 100644
index 0000000000000000000000000000000000000000..7bee0a002b75fb20e9b790068b7950121cdf779e
GIT binary patch
literal 83
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdzDNh&2kch)?4>B?Wc})uc*XMaS
cfSB*u1QZw;r+*K>4&*R+y85}Sb4q9e0KdKysQ>@~

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/icon_in_call.png b/Resources/Textures/Structures/Machines/holopad.rsi/icon_in_call.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc555615d6c635854dd9a483649ed210d5fffa4f
GIT binary patch
literal 414
zcmV;P0b%}$P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80004HNkl<ZSi|j>
zy-EW?6ot<X*!t55=}a06n>>N05JUuh0AnWvZSw-#rO^kliUF-n9fC1$U@HoWO(0FQ
z@u&K1W?@*@pvi<->}iHObC&t`&fJ-iGG)p%W7()dATOz!=x&+Wt>=j(^(Eby*<DaN
zAmY2)36HNHQ2xstxiPrr67i9wQ%O&f)+Kd;dZ-K>r)1!Hg#Qp2I$u2mzy|4B@jTZ+
z4Ont<$%80|fJo{CD5i`Lfs&UAfL;iID{qodU^gX8=N?3yiAUGBIw?TK1K1nkiy>+*
zK5=n%qAD=63%A21>2-v);o2S7KDag?Vj1?`-`oQWGdVJWj)Q2<3Sbc!IEcm%o+40~
zCWK$(O<>*|+Xmj_!wTpE?YJ~ULkzq<Q3kevw;v9zXj;qB;dhEcUq&*s7c<+GRPjo5
zEafKo*vu}?tRU$?QY-j_WZVl((wd}Y*L7xQ{p{_RDbv5z7n>E}9F}_4cK`qY07*qo
IM6N<$f_+}I-~a#s

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/lights_calling.png b/Resources/Textures/Structures/Machines/holopad.rsi/lights_calling.png
new file mode 100644
index 0000000000000000000000000000000000000000..298087e1dbd8a42398e0c8785c7ee79f2efa43d3
GIT binary patch
literal 425
zcmeAS@N?(olHy`uVBq!ia0vp^3xL>xgAGW|?XFqRz`$7G>EaktaqI0JLq8@*5w-`B
zhYfj-MMPFG^EZ^0nN5j1*mmofcEGJ0H#f>1kd6qDT>MaGooI{15!V~Fr{8@yjTZRC
zBw3f1RvzaCG!qDNr~c&9c>L(yLJ!TQn<qb>x_<w@z00QropN_h=HfijH#t4_*B_sS
zv1%93eoil}tlDw0TJ3VA6#uVdVnPO2-ahs&tgoGSc75ow^Q(4VxO_aku(V{uj%yR`
zicgo$j@kd*{KxL6`#0Jw_*Ze^{ISOQ`}=<N$~Dxl-E(befSpv@XOpOT(pP6POn#YT
zs2(JLhVk}prnO0`yL_46CaFrr%Bw68*~ZTyG$HN1#}08Gh<m~0R;|B(>SkUJ44v0j
zq{g_yo^kQ{R=4Z@cGJ0CR1?I1T{hiWS5ki{ck0XYJGR+I!v(Cqtny*_`|;aupsd@C
z`<4mPzb?C8?|<jdao6v_|78ue4lkMCdK~bbbYgD;*q#M}`xyIt^Gu^R%ZP&nJYD@<
J);T3K0RYv7yZrzF

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/lights_hanging_up.png b/Resources/Textures/Structures/Machines/holopad.rsi/lights_hanging_up.png
new file mode 100644
index 0000000000000000000000000000000000000000..860712c4c8c06006a5c10bc1699d0c32fec96e70
GIT binary patch
literal 432
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrU@Z4^aSW-r_4bZo-XRA8)&T2A
z5*jOaa(Yd7E?6bg#8)VMUEy3~aAKh187-q(|KlDXJG)@+&D0$K>x@7%7`}cze{YBN
zyyNfB{(5NJ{_xV@Jp12W_90b&mV`B=ht)mx@#vrbgzLkpSNnhd{Pp7d^4Ashz9;^9
zeKfy4f8FE1p?}_|f1NK`Afb18-i%HE!@K0u8?GBKIOJ(zTla<W5C1iGh22bNPO_Y5
zO0fgk1_s?9{TBQPWRwaAn*Je{VW;SU8ivn|vu5xo*d5rSzU<BasgI6Jg2gVdgP_9J
d!DmGNEB<Vy9}*VdUUq`~<mu|?vd$@?2>@1TxYqyx

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/lights_in_call.png b/Resources/Textures/Structures/Machines/holopad.rsi/lights_in_call.png
new file mode 100644
index 0000000000000000000000000000000000000000..de204379cc8b2c66c6bdb5518a6a29bb4324afbe
GIT binary patch
literal 326
zcmeAS@N?(olHy`uVBq!ia0vp^4M6O`!3HERU8}EWU|{6+ba4!+xb^nVM&2d|5w-+_
zp2Q7h!b#5s{EiBg9rImbcup})O1t?`VL?s2v-6*+d#dLwkD0~@G=Smd>EH7zcHP@`
zxbFAYIo`$RU#&V5yeD9z{r_9*?KfIE%s<5)*}3ua^b3_GOovJu>Q}vgy5shf=ie^Y
z$}L~<Z_20kSCivwsvCD{eYQ#}U1wX*<$6M}AoJb(>PsQt?SDRgn#}j1p0&?Vc&fa)
z{A-45jBA=VyyN@et-5TF*t_i@`yn9hTs_m%#mqcw_Dq<nale@H$Sa0#>>KP4Du8Wz
zdR~7&$4@q!`T6w>*R0q*64kQm8P+iWklV9IFXfAI9Q%)@LTisoSAxtsb4A$s@z(Oi
RHsNbQTu)a&mvv4FO#pctjza(d

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/lights_ringing.png b/Resources/Textures/Structures/Machines/holopad.rsi/lights_ringing.png
new file mode 100644
index 0000000000000000000000000000000000000000..7faf902ec821a76e94cf064064a953f2e9f9a8c5
GIT binary patch
literal 4429
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
TPA-y600000NkvXXu0mjfAB1xh

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/meta.json b/Resources/Textures/Structures/Machines/holopad.rsi/meta.json
new file mode 100644
index 0000000000..b7601b19c1
--- /dev/null
+++ b/Resources/Textures/Structures/Machines/holopad.rsi/meta.json
@@ -0,0 +1,100 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/pull/80025/commits/f0cc8856d4c1b6b3933524a2d37581cc81c3c05b, /icons/obj/machines/floor.dmi. Edited by chromiumboy",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "base"
+    },
+	{
+      "name": "unpowered"
+    },
+	{
+      "name": "panel_open"
+    },
+	{
+      "name": "blank"
+    },
+	{
+      "name": "icon_in_call"
+    },
+	{
+      "name": "lights_calling",
+      "delays": [
+        [
+          0.2,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.5,
+          0.1,
+          0.1,
+		  0.1,
+          0.1
+        ]
+      ]
+    },
+	{
+      "name": "lights_in_call",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1
+        ]
+      ]
+    },
+	{
+      "name": "lights_ringing",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.2,
+		  0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.8
+        ]
+      ]
+    },
+	{
+      "name": "lights_hanging_up",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+		  0.1,
+		  0.1,
+		  0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+		  0.1,
+		  0.1,
+		  0.1,
+		  99
+        ]
+      ]
+    }	
+  ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/panel_open.png b/Resources/Textures/Structures/Machines/holopad.rsi/panel_open.png
new file mode 100644
index 0000000000000000000000000000000000000000..22947c888709b280978297d580eac24096610c1f
GIT binary patch
literal 221
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=ffJC7v#hArXg@6C_w&nmjbu{`dZB
z`hT)^Kexf8R~+(z9kLh2*Bd_)TI`*XkUW`r#)*q8pAD^M=kYC2Q#j2S9cP@B+TRpt
zz;%N0gH20J-{n;vtv4Gl{{a~^MQrU6v4;|@7lUfg{<mB7UsErNQ}kg)_L)Ww#$8Jo
zOX8JhpLgmvs@<|rf^~62TB_AH8@oT!OF{N8HuuuxW$ij$9Cc0pusj2UwuJAKt$7Av
QK=(3uy85}Sb4q9e07cDG>i_@%

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Structures/Machines/holopad.rsi/unpowered.png b/Resources/Textures/Structures/Machines/holopad.rsi/unpowered.png
new file mode 100644
index 0000000000000000000000000000000000000000..7b4b5dd65a1b287ca782c04c68d47168b431e2e3
GIT binary patch
literal 441
zcmV;q0Y?6bP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80004iNkl<ZSi|j>
zKWoB37{;F~4mwKXCx|u#gkU7NIavJyEtIx<heAJ2p+jdWbm$j|b#N<UL=eQHi_l3+
zN8PSN>JiJC++AX!kO#sYmrLIF`SIQ#AXTdWsJ3O&qV7L!%cODsbtL<NQ>#+|DBD$(
z?dr~$iiphQqVBtO)&%{WA2ZmW%_rnw1d6&zw~qTcio8}pUMsNRWxL7}Oq@V4c$CK8
zK#D|0G<fgTWn-JodS^~Hn`8a@X$t_TXc8nT=c*(!GR}GKc@$(wkffderU1Y%*0&y!
zt^rZ^JPLZr!1?7hx*ZpdrcZ;HL}&s(7?t#~Sj1liVU-_6K`$AYzE1&wwbBX1Au#p^
z_*yLifVF>G16u=8%kf|YV(o;p`Gn-P0<|hOUY?(n_JOmDD~yI7l=gw((c5UYLW_te
z<HSI><L+JiQisttiN}X~p|jxT_D(ps@M$PYLdLoDg~X}Vsa3JD`do3}YsVT!Lr*HW
j@{MSpRBlA6Ql<I^&62mwJj52800000NkvXXu0mjfoG;EI

literal 0
HcmV?d00001