--- /dev/null
+using Content.Client.Radio.Ui;
+using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Radio.EntitySystems;
+
+public sealed class RadioDeviceSystem : EntitySystem
+{
+ [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+ /// <inheritdoc/>
+ public override void Initialize()
+ {
+ SubscribeLocalEvent<IntercomComponent, AfterAutoHandleStateEvent>(OnAfterHandleState);
+ }
+
+ private void OnAfterHandleState(Entity<IntercomComponent> ent, ref AfterAutoHandleStateEvent args)
+ {
+ if (_ui.TryGetOpenUi<IntercomBoundUserInterface>(ent.Owner, IntercomUiKey.Key, out var bui))
+ bui.Update(ent);
+ }
+}
using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
using JetBrains.Annotations;
-using Robust.Client.GameObjects;
namespace Content.Client.Radio.Ui;
{
base.Open();
- _menu = new();
+ var comp = EntMan.GetComponent<IntercomComponent>(Owner);
+
+ _menu = new((Owner, comp));
_menu.OnMicPressed += enabled =>
{
_menu?.Close();
}
- protected override void UpdateState(BoundUserInterfaceState state)
+ public void Update(Entity<IntercomComponent> ent)
{
- base.UpdateState(state);
-
- if (state is not IntercomBoundUIState msg)
- return;
-
- _menu?.Update(msg);
+ _menu?.Update(ent);
}
}
using Content.Client.UserInterface.Controls;
-using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
using Robust.Client.AutoGenerated;
using Robust.Client.UserInterface.XAML;
using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
namespace Content.Client.Radio.Ui;
private readonly List<string> _channels = new();
- public IntercomMenu()
+ public IntercomMenu(Entity<IntercomComponent> entity)
{
RobustXamlLoader.Load(this);
IoCManager.InjectDependencies(this);
MicButton.OnPressed += args => OnMicPressed?.Invoke(args.Button.Pressed);
SpeakerButton.OnPressed += args => OnSpeakerPressed?.Invoke(args.Button.Pressed);
+
+ Update(entity);
}
- public void Update(IntercomBoundUIState state)
+ public void Update(Entity<IntercomComponent> entity)
{
- MicButton.Pressed = state.MicEnabled;
- SpeakerButton.Pressed = state.SpeakerEnabled;
+ MicButton.Pressed = entity.Comp.MicrophoneEnabled;
+ SpeakerButton.Pressed = entity.Comp.SpeakerEnabled;
+
+ MicButton.Disabled = entity.Comp.SupportedChannels.Count == 0;
+ SpeakerButton.Disabled = entity.Comp.SupportedChannels.Count == 0;
+ ChannelOptions.Disabled = entity.Comp.SupportedChannels.Count == 0;
ChannelOptions.Clear();
_channels.Clear();
- for (var i = 0; i < state.AvailableChannels.Count; i++)
+ for (var i = 0; i < entity.Comp.SupportedChannels.Count; i++)
{
- var channel = state.AvailableChannels[i];
- if (!_prototype.TryIndex<RadioChannelPrototype>(channel, out var prototype))
+ var channel = entity.Comp.SupportedChannels[i];
+ if (!_prototype.TryIndex(channel, out var prototype))
continue;
_channels.Add(channel);
ChannelOptions.AddItem(Loc.GetString(prototype.Name), i);
- if (channel == state.SelectedChannel)
+ if (channel == entity.Comp.CurrentChannel)
ChannelOptions.Select(i);
}
+
+ if (entity.Comp.SupportedChannels.Count == 0)
+ {
+ ChannelOptions.AddItem(Loc.GetString("intercom-options-none"), 0);
+ ChannelOptions.Select(0);
+ }
+
ChannelOptions.OnItemSelected += args =>
{
+ if (!_channels.TryGetValue(args.Id, out var proto))
+ return;
+
ChannelOptions.SelectId(args.Id);
- OnChannelSelected?.Invoke(_channels[args.Id]);
+ OnChannelSelected?.Invoke(proto);
};
}
}
+using System.Linq;
using Content.Server.Chat.Systems;
using Content.Server.Interaction;
using Content.Server.Popups;
using Content.Server.Radio.Components;
using Content.Server.Speech;
using Content.Server.Speech.Components;
-using Content.Shared.UserInterface;
-using Content.Shared.Chat;
using Content.Shared.Examine;
using Content.Shared.Interaction;
using Content.Shared.Radio;
using Content.Shared.Radio.Components;
-using Robust.Server.GameObjects;
using Robust.Shared.Prototypes;
namespace Content.Server.Radio.EntitySystems;
[Dependency] private readonly RadioSystem _radio = default!;
[Dependency] private readonly InteractionSystem _interaction = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
- [Dependency] private readonly UserInterfaceSystem _ui = default!;
// Used to prevent a shitter from using a bunch of radios to spam chat.
private HashSet<(string, EntityUid)> _recentlySent = new();
SubscribeLocalEvent<RadioSpeakerComponent, ActivateInWorldEvent>(OnActivateSpeaker);
SubscribeLocalEvent<RadioSpeakerComponent, RadioReceiveEvent>(OnReceiveRadio);
- SubscribeLocalEvent<IntercomComponent, BeforeActivatableUIOpenEvent>(OnBeforeIntercomUiOpen);
+ SubscribeLocalEvent<IntercomComponent, EncryptionChannelsChangedEvent>(OnIntercomEncryptionChannelsChanged);
SubscribeLocalEvent<IntercomComponent, ToggleIntercomMicMessage>(OnToggleIntercomMic);
SubscribeLocalEvent<IntercomComponent, ToggleIntercomSpeakerMessage>(OnToggleIntercomSpeaker);
SubscribeLocalEvent<IntercomComponent, SelectIntercomChannelMessage>(OnSelectIntercomChannel);
SetSpeakerEnabled(uid, user, !component.Enabled, quiet, component);
}
- public void SetSpeakerEnabled(EntityUid uid, EntityUid user, bool enabled, bool quiet = false, RadioSpeakerComponent? component = null)
+ public void SetSpeakerEnabled(EntityUid uid, EntityUid? user, bool enabled, bool quiet = false, RadioSpeakerComponent? component = null)
{
if (!Resolve(uid, ref component))
return;
component.Enabled = enabled;
- if (!quiet)
+ if (!quiet && user != null)
{
var state = Loc.GetString(component.Enabled ? "handheld-radio-component-on-state" : "handheld-radio-component-off-state");
var message = Loc.GetString("handheld-radio-component-on-use", ("radioState", state));
- _popup.PopupEntity(message, user, user);
+ _popup.PopupEntity(message, user.Value, user.Value);
}
_appearance.SetData(uid, RadioDeviceVisuals.Speaker, component.Enabled);
var nameEv = new TransformSpeakerNameEvent(args.MessageSource, Name(args.MessageSource));
RaiseLocalEvent(args.MessageSource, nameEv);
- var name = Loc.GetString("speech-name-relay", ("speaker", Name(uid)),
+ var name = Loc.GetString("speech-name-relay",
+ ("speaker", Name(uid)),
("originalName", nameEv.Name));
// log to chat so people can identity the speaker/source, but avoid clogging ghost chat if there are many radios
_chat.TrySendInGameICMessage(uid, args.Message, InGameICChatType.Whisper, ChatTransmitRange.GhostRangeLimit, nameOverride: name, checkRadioPrefix: false);
}
- private void OnBeforeIntercomUiOpen(EntityUid uid, IntercomComponent component, BeforeActivatableUIOpenEvent args)
+ private void OnIntercomEncryptionChannelsChanged(Entity<IntercomComponent> ent, ref EncryptionChannelsChangedEvent args)
{
- UpdateIntercomUi(uid, component);
+ ent.Comp.SupportedChannels = args.Component.Channels.Select(p => new ProtoId<RadioChannelPrototype>(p)).ToList();
+
+ var channel = args.Component.DefaultChannel;
+ if (ent.Comp.CurrentChannel != null && ent.Comp.SupportedChannels.Contains(ent.Comp.CurrentChannel.Value))
+ channel = ent.Comp.CurrentChannel;
+
+ SetIntercomChannel(ent, channel);
}
- private void OnToggleIntercomMic(EntityUid uid, IntercomComponent component, ToggleIntercomMicMessage args)
+ private void OnToggleIntercomMic(Entity<IntercomComponent> ent, ref ToggleIntercomMicMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
+ if (ent.Comp.RequiresPower && !this.IsPowered(ent, EntityManager))
return;
- SetMicrophoneEnabled(uid, args.Actor, args.Enabled, true);
- UpdateIntercomUi(uid, component);
+ SetMicrophoneEnabled(ent, args.Actor, args.Enabled, true);
+ ent.Comp.MicrophoneEnabled = args.Enabled;
+ Dirty(ent);
}
- private void OnToggleIntercomSpeaker(EntityUid uid, IntercomComponent component, ToggleIntercomSpeakerMessage args)
+ private void OnToggleIntercomSpeaker(Entity<IntercomComponent> ent, ref ToggleIntercomSpeakerMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
+ if (ent.Comp.RequiresPower && !this.IsPowered(ent, EntityManager))
return;
- SetSpeakerEnabled(uid, args.Actor, args.Enabled, true);
- UpdateIntercomUi(uid, component);
+ SetSpeakerEnabled(ent, args.Actor, args.Enabled, true);
+ ent.Comp.SpeakerEnabled = args.Enabled;
+ Dirty(ent);
}
- private void OnSelectIntercomChannel(EntityUid uid, IntercomComponent component, SelectIntercomChannelMessage args)
+ private void OnSelectIntercomChannel(Entity<IntercomComponent> ent, ref SelectIntercomChannelMessage args)
{
- if (component.RequiresPower && !this.IsPowered(uid, EntityManager))
+ if (ent.Comp.RequiresPower && !this.IsPowered(ent, EntityManager))
return;
- if (!_protoMan.TryIndex<RadioChannelPrototype>(args.Channel, out _) || !component.SupportedChannels.Contains(args.Channel))
+ if (!_protoMan.HasIndex<RadioChannelPrototype>(args.Channel) || !ent.Comp.SupportedChannels.Contains(args.Channel))
return;
- if (TryComp<RadioMicrophoneComponent>(uid, out var mic))
- mic.BroadcastChannel = args.Channel;
- if (TryComp<RadioSpeakerComponent>(uid, out var speaker))
- speaker.Channels = new(){ args.Channel };
- UpdateIntercomUi(uid, component);
+ SetIntercomChannel(ent, args.Channel);
}
- private void UpdateIntercomUi(EntityUid uid, IntercomComponent component)
+ private void SetIntercomChannel(Entity<IntercomComponent> ent, ProtoId<RadioChannelPrototype>? channel)
{
- var micComp = CompOrNull<RadioMicrophoneComponent>(uid);
- var speakerComp = CompOrNull<RadioSpeakerComponent>(uid);
-
- var micEnabled = micComp?.Enabled ?? false;
- var speakerEnabled = speakerComp?.Enabled ?? false;
- var availableChannels = component.SupportedChannels;
- var selectedChannel = micComp?.BroadcastChannel ?? SharedChatSystem.CommonChannel;
- var state = new IntercomBoundUIState(micEnabled, speakerEnabled, availableChannels, selectedChannel);
- _ui.SetUiState(uid, IntercomUiKey.Key, state);
+ ent.Comp.CurrentChannel = channel;
+
+ if (channel == null)
+ {
+ SetSpeakerEnabled(ent, null, false);
+ SetMicrophoneEnabled(ent, null, false);
+ ent.Comp.MicrophoneEnabled = false;
+ ent.Comp.SpeakerEnabled = false;
+ Dirty(ent);
+ return;
+ }
+
+ if (TryComp<RadioMicrophoneComponent>(ent, out var mic))
+ mic.BroadcastChannel = channel;
+ if (TryComp<RadioSpeakerComponent>(ent, out var speaker))
+ speaker.Channels = new(){ channel };
+ Dirty(ent);
}
}
// set used to prevent radio feedback loops.
private readonly HashSet<string> _messages = new();
+ private EntityQuery<TelecomExemptComponent> _exemptQuery;
+
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<IntrinsicRadioReceiverComponent, RadioReceiveEvent>(OnIntrinsicReceive);
SubscribeLocalEvent<IntrinsicRadioTransmitterComponent, EntitySpokeEvent>(OnIntrinsicSpeak);
+
+ _exemptQuery = GetEntityQuery<TelecomExemptComponent>();
}
private void OnIntrinsicSpeak(EntityUid uid, IntrinsicRadioTransmitterComponent component, EntitySpokeEvent args)
var sourceMapId = Transform(radioSource).MapID;
var hasActiveServer = HasActiveServer(sourceMapId, channel.ID);
- var hasMicro = HasComp<RadioMicrophoneComponent>(radioSource);
+ var sourceServerExempt = _exemptQuery.HasComp(radioSource);
- var speakerQuery = GetEntityQuery<RadioSpeakerComponent>();
var radioQuery = EntityQueryEnumerator<ActiveRadioComponent, TransformComponent>();
while (canSend && radioQuery.MoveNext(out var receiver, out var radio, out var transform))
{
continue;
// don't need telecom server for long range channels or handheld radios and intercoms
- var needServer = !channel.LongRange && (!hasMicro || !speakerQuery.HasComponent(receiver));
+ var needServer = !channel.LongRange && !sourceServerExempt;
if (needServer && !hasActiveServer)
continue;
using Robust.Shared.GameStates;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List;
+using Robust.Shared.Prototypes;
namespace Content.Shared.Radio.Components;
/// <summary>
/// Handles intercom ui and is authoritative on the channels an intercom can access.
/// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(true)]
public sealed partial class IntercomComponent : Component
{
/// <summary>
- /// Does this intercom require popwer to function
+ /// Does this intercom require power to function
/// </summary>
- [DataField("requiresPower"), ViewVariables(VVAccess.ReadWrite)]
+ [DataField]
public bool RequiresPower = true;
+ [DataField, AutoNetworkedField]
+ public bool SpeakerEnabled;
+
+ [DataField, AutoNetworkedField]
+ public bool MicrophoneEnabled;
+
+ [DataField, AutoNetworkedField]
+ public ProtoId<RadioChannelPrototype>? CurrentChannel;
+
/// <summary>
/// The list of radio channel prototypes this intercom can choose between.
/// </summary>
- [DataField("supportedChannels", customTypeSerializer: typeof(PrototypeIdListSerializer<RadioChannelPrototype>))]
- public List<string> SupportedChannels = new();
+ [DataField, AutoNetworkedField]
+ public List<ProtoId<RadioChannelPrototype>> SupportedChannels = new();
}
--- /dev/null
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Radio.Components;
+
+/// <summary>
+/// This is used for a radio that doesn't need a telecom server in order to broadcast.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class TelecomExemptComponent : Component;
[Dependency] private readonly SharedContainerSystem _container = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedHandsSystem _hands = default!;
+ [Dependency] private readonly SharedWiresSystem _wires = default!;
public override void Initialize()
{
return;
}
- if (TryComp<WiresPanelComponent>(uid, out var panel) && !panel.Open)
+ if (!_wires.IsPanelOpen(uid))
{
_popup.PopupClient(Loc.GetString("encryption-keys-panel-locked"), uid, args.User);
return;
if (component.Channels.Count > 0)
{
- args.PushMarkup(Loc.GetString("examine-encryption-channels-prefix"));
- AddChannelsExamine(component.Channels, component.DefaultChannel, args, _protoManager, "examine-encryption-channel");
+ using (args.PushGroup(nameof(EncryptionKeyComponent)))
+ {
+ args.PushMarkup(Loc.GetString("examine-encryption-channels-prefix"));
+ AddChannelsExamine(component.Channels,
+ component.DefaultChannel,
+ args,
+ _protoManager,
+ "examine-encryption-channel");
+ }
}
}
-using Robust.Shared.Serialization;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
namespace Content.Shared.Radio;
Key,
}
-[Serializable, NetSerializable]
-public sealed class IntercomBoundUIState : BoundUserInterfaceState
-{
- public bool MicEnabled;
- public bool SpeakerEnabled;
- public List<string> AvailableChannels;
- public string SelectedChannel;
-
- public IntercomBoundUIState(bool micEnabled, bool speakerEnabled, List<string> availableChannels, string selectedChannel)
- {
- MicEnabled = micEnabled;
- SpeakerEnabled = speakerEnabled;
- AvailableChannels = availableChannels;
- SelectedChannel = selectedChannel;
- }
-}
-
[Serializable, NetSerializable]
public sealed class ToggleIntercomMicMessage : BoundUserInterfaceMessage
{
{
base.Initialize();
+ SubscribeLocalEvent<WiresPanelComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<WiresPanelComponent, WirePanelDoAfterEvent>(OnPanelDoAfter);
SubscribeLocalEvent<WiresPanelComponent, InteractUsingEvent>(OnInteractUsing);
SubscribeLocalEvent<WiresPanelComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<ActivatableUIRequiresPanelComponent, PanelChangedEvent>(OnActivatableUIPanelChanged);
}
+ private void OnStartup(Entity<WiresPanelComponent> ent, ref ComponentStartup args)
+ {
+ UpdateAppearance(ent, ent);
+ }
+
private void OnPanelDoAfter(EntityUid uid, WiresPanelComponent panel, WirePanelDoAfterEvent args)
{
if (args.Cancelled)
intercom-menu-title = Intercom
intercom-channel-label = Channel:
intercom-button-text-mic = Mic.
-intercom-button-text-speaker = Speak
+intercom-button-text-speaker = Spkr.
+intercom-options-none = No channels
intercom-flavor-text-left = Keep lines free of chatter
parent: BaseItem
id: RadioHandheld
components:
+ - type: TelecomExempt
- type: RadioMicrophone
broadcastChannel: Handheld
- type: RadioSpeaker
sprite: Objects/Devices/securityhandy.rsi
- type: Item
sprite: Objects/Devices/securityhandy.rsi
- heldPrefix: walkietalkie
\ No newline at end of file
+ heldPrefix: walkietalkie
- type: entity
- id: Intercom
+ id: BaseIntercom
name: intercom
description: An intercom. For when the station just needs to know something.
abstract: true
- type: Electrified
enabled: false
usesApcPower: true
+ - type: TelecomExempt
+ - type: EncryptionKeyHolder
+ keySlots: 3
+ keysExtractionMethod: Prying
- type: RadioMicrophone
powerRequired: true
unobstructedRequired: true
- type: InteractionOutline
- type: Appearance
- type: WiresVisuals
+ - type: WiresPanelSecurity
- type: ContainerFill
containers:
board: [ IntercomElectronics ]
- type: ContainerContainer
containers:
board: !type:Container
+ key_slots: !type:Container
- type: Sprite
noRot: false
drawdepth: SmallObjects
visible: false
- state: panel
map: ["enum.WiresVisualLayers.MaintenancePanel"]
- shader: unshaded
visible: false
- type: Transform
noRot: false
- type: ActivatableUIRequiresPower
- type: ActivatableUI
key: enum.IntercomUiKey.Key
+ singleUser: true
- type: UserInterface
interfaces:
enum.IntercomUiKey.Key:
- Wallmount
- type: entity
- id: IntercomAssesmbly
+ id: IntercomAssembly
name: intercom assembly
description: An intercom. It doesn't seem very helpful right now.
components:
- type: Sprite
drawdepth: SmallObjects
sprite: Structures/Wallmounts/intercom.rsi
- state: build
+ layers:
+ - state: build
+ - state: panel
+ visible: false
+ map: [ "wires" ]
+ - type: Appearance
+ - type: GenericVisualizer
+ visuals:
+ enum.ConstructionVisuals.Layer:
+ wires:
+ 0: { visible: false }
+ 1: { visible: true }
- type: Construction
graph: Intercom
node: assembly
snap:
- Wallmount
+# this weird inheritance BS exists for construction shitcode
+- type: entity
+ id: IntercomConstructed
+ parent: BaseIntercom
+ suffix: Empty, Panel Open
+ components:
+ - type: Sprite
+ layers:
+ - state: base
+ - state: unshaded
+ map: ["enum.PowerDeviceVisualLayers.Powered"]
+ shader: unshaded
+ - state: broadcasting
+ map: ["enum.RadioDeviceVisualLayers.Broadcasting"]
+ shader: unshaded
+ visible: false
+ - state: speaker
+ map: ["enum.RadioDeviceVisualLayers.Speaker"]
+ shader: unshaded
+ visible: false
+ - state: panel
+ map: ["enum.WiresVisualLayers.MaintenancePanel"]
+ visible: true
+ - type: WiresPanel
+ open: true
+
+- type: entity
+ id: Intercom
+ parent: IntercomConstructed
+ suffix: ""
+ components:
+ - type: Sprite
+ layers:
+ - state: base
+ - state: unshaded
+ map: ["enum.PowerDeviceVisualLayers.Powered"]
+ shader: unshaded
+ - state: broadcasting
+ map: ["enum.RadioDeviceVisualLayers.Broadcasting"]
+ shader: unshaded
+ visible: false
+ - state: speaker
+ map: ["enum.RadioDeviceVisualLayers.Speaker"]
+ shader: unshaded
+ visible: false
+ - state: panel
+ map: ["enum.WiresVisualLayers.MaintenancePanel"]
+ - type: WiresPanel
+ open: false
+
- type: entity
id: IntercomCommon
parent: Intercom
suffix: Common
components:
- - type: Intercom
- supportedChannels:
- - Common
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
- type: entity
id: IntercomCommand
parent: Intercom
suffix: Command
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Command
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyCommand
- type: entity
id: IntercomEngineering
parent: Intercom
suffix: Engineering
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Engineering
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyEngineering
- type: entity
id: IntercomMedical
parent: Intercom
suffix: Medical
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Medical
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyMedical
- type: entity
id: IntercomScience
parent: Intercom
suffix: Science
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Science
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyScience
- type: entity
id: IntercomSecurity
parent: Intercom
suffix: Security
+ description: An intercom. It's been reinforced with metal from security helmets, making it a bitch-and-a-half to open.
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Security
+ - type: WiresPanel
+ openDelay: 5
+ - type: WiresPanelSecurity
+ examine: wires-panel-component-on-examine-security-level2
+ wiresAccessible: false
+ - type: Construction
+ node: intercomReinforced
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeySecurity
- type: entity
id: IntercomService
parent: Intercom
suffix: Service
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Service
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyService
- type: entity
id: IntercomSupply
parent: Intercom
suffix: Supply
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Supply
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyCargo
- type: entity
id: IntercomAll
parent: Intercom
suffix: All
components:
- - type: Intercom
- supportedChannels:
- - Common
- - Command
- - Engineering
- - Medical
- - Science
- - Security
- - Service
- - Supply
+ - type: ContainerFill
+ containers:
+ board:
+ - IntercomElectronics
+ key_slots:
+ - EncryptionKeyCommon
+ - EncryptionKeyStationMaster
doAfter: 2.0
- node: assembly
- entity: IntercomAssesmbly
+ entity: IntercomAssembly
edges:
- to: wired
steps:
- material: Cable
amount: 2
doAfter: 1
+ completed:
+ - !type:VisualizerDataInt
+ key: "enum.ConstructionVisuals.Layer"
+ data: 1
- to: start
completed:
- !type:GivePrototype
doAfter: 2
- node: wired
- entity: IntercomAssesmbly
+ entity: IntercomAssembly
edges:
- to: electronics
steps:
- !type:GivePrototype
prototype: CableApcStack1
amount: 2
+ - !type:VisualizerDataInt
+ key: "enum.ConstructionVisuals.Layer"
+ data: 0
steps:
- tool: Cutting
doAfter: 1
doAfter: 2
- node: intercom
- entity: IntercomCommon #TODO: make this work with encryption keys
+ entity: IntercomConstructed
+ doNotReplaceInheritingEntities: true
+ actions:
+ - !type:SetWiresPanelSecurity
+ wiresAccessible: true
edges:
- to: wired
conditions:
steps:
- tool: Prying
doAfter: 1
+ - to: intercomReinforced
+ conditions:
+ - !type:WirePanel
+ steps:
+ - material: Steel
+ amount: 1
+ - tool: Welding
+ doAfter: 1
+
+ - node: intercomReinforced
+ actions:
+ - !type:SetWiresPanelSecurity
+ examine: wires-panel-component-on-examine-security-level2
+ wiresAccessible: false
+ edges:
+ - to: intercom
+ conditions:
+ - !type:WirePanel
+ completed:
+ - !type:GivePrototype
+ prototype: SheetSteel1
+ steps:
+ - tool: Welding
+ doAfter: 5
# INTERCOM
- type: construction
name: intercom
- id: IntercomAssesmbly
+ id: IntercomAssembly
graph: Intercom
startNode: start
targetNode: intercom
#2024-06-25
BookChefGaming: BookHowToCookForFortySpaceman
+
+#2024-06-29
+IntercomAssesmbly: IntercomAssembly
projects / space-station-14.git / commitdiff
