oh what fun it is to ride a pimped up getaway

Content.Server/NodeContainer/NodeGroups/BaseNodeGroup.cs

@@ -35,7 +35,7 @@ public interface INodeGroup
         string? GetDebugData();
     }
 
-    [NodeGroup(NodeGroupID.Default, NodeGroupID.WireNet)]
+    [NodeGroup(NodeGroupID.Default, NodeGroupID.WireNet, NodeGroupID.ChristmasLights)] // WD EDIT
     [Virtual]
     public class BaseNodeGroup : INodeGroup
     {

Content.Server/NodeContainer/NodeGroups/NodeGroupFactory.cs

@@ -61,7 +61,9 @@ public enum NodeGroupID : byte
         AMEngine,
         Pipe,
         WireNet,
-
+        // WD EDIT START // ALSO FUCK THIS ID SHIT
+        ChristmasLights,
+        // WD EDIT END
         /// <summary>
         /// Group used by the TEG.
         /// </summary>

Content.Server/_White/Misc/ChristmasLightsSystem.cs

@@ -0,0 +1,168 @@
+using Content.Server.Emp;
+using Content.Server.NodeContainer;
+using Content.Server.NodeContainer.EntitySystems;
+using Content.Server.NodeContainer.Nodes;
+using Content.Shared._White.Misc.ChristmasLights;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Emag.Components;
+using Content.Shared.Emag.Systems;
+using Content.Shared.Interaction;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Content.Server._White.Misc;
+
+
+public sealed class ChristmasLightsSystem : SharedChristmasLightsSystem
+{
+    [Dependency] private readonly NodeGroupSystem _node = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ChristmasLightsComponent, ComponentInit>(OnChristmasLightsInit);
+        SubscribeLocalEvent<ChristmasLightsComponent, EmpPulseEvent>(OnChristmasLightsMinisculeTrolling);
+        SubscribeLocalEvent<ChristmasLightsComponent, GotEmaggedEvent>(OnChristmasLightsModerateTrolling);
+
+        SubscribeNetworkEvent<ChangeChristmasLightsModeAttemptEvent>(OnModeChangeAttempt);
+        SubscribeNetworkEvent<ChangeChristmasLightsBrightnessAttemptEvent>(OnBrightnessChangeAttempt);
+    }
+
+    private void OnChristmasLightsInit(EntityUid uid, ChristmasLightsComponent comp, ComponentInit args)
+    {
+        if (TryComp<NodeContainerComponent>(uid, out var cont))
+        {
+            comp.CurrentModeIndex = comp.modes.IndexOf(comp.mode); // returns -1 if mode is not in list: disables mode changing if that's the case
+            if (cont.Nodes.TryGetValue("christmaslight", out var node))
+                _node.QueueReflood(node);
+        }
+    }
+
+    private void OnChristmasLightsMinisculeTrolling(EntityUid uid, ChristmasLightsComponent comp, ref EmpPulseEvent args)
+    {
+        args.Affected = true;
+        if (TryGetConnected(uid, out var nodes))
+        {
+            foreach (var node in nodes)
+            {
+                var jolly = Comp<ChristmasLightsComponent>(node.Owner);
+                jolly.mode = $"emp{(comp.Multicolor ? "_rainbow" : "")}";
+                Dirty(jolly.Owner, jolly);
+            }
+        }
+    }
+
+    private void OnChristmasLightsModerateTrolling(EntityUid uid, ChristmasLightsComponent comp, ref GotEmaggedEvent args)
+    {
+        if (TryGetConnected(uid, out var nodes))
+        {
+            foreach (var node in nodes)
+            {
+                EnsureComp<EmaggedComponent>(node.Owner);
+                var jolly = Comp<ChristmasLightsComponent>(node.Owner);
+                jolly.mode = $"emp{(jolly.Multicolor ? "_rainbow" : "")}";
+                jolly.CurrentModeIndex = -1; // disables mode change
+                Dirty(jolly.Owner, jolly);
+            }
+        }
+        _audio.PlayPvs(comp.EmagSound, uid);
+        args.Handled = true;
+    }
+
+    int GetNextModeIndex(ChristmasLightsComponent comp) // cycles modes as usual, but also handles the -1 case
+    {
+        if (comp.CurrentModeIndex == -1) return -1;
+        comp.CurrentModeIndex = (comp.CurrentModeIndex + 1) % comp.modes.Count;
+        return comp.CurrentModeIndex;
+    }
+
+    private void OnModeChangeAttempt(ChangeChristmasLightsModeAttemptEvent args, EntitySessionEventArgs sessionArgs)
+    {
+        //NotABackDoor(sessionArgs.SenderSession);
+        if (sessionArgs.SenderSession.AttachedEntity is not { } user)
+            return;
+        EntityUid uid = GetEntity(args.target);
+        if (!TryComp<ChristmasLightsComponent>(uid, out var thisComp) || !CanInteract(uid, user))
+            return;
+
+        _audio.PlayPredicted(thisComp.ButtonSound, uid, user);
+        _interaction.DoContactInteraction(user, uid);
+        if(!HasComp<EmaggedComponent>(uid))
+        {
+            var jolly = Comp<ChristmasLightsComponent>(uid);
+            UpdateAllConnected(uid, jolly.LowPower, GetNextModeIndex(jolly));
+        }
+    }
+
+    private void OnBrightnessChangeAttempt(ChangeChristmasLightsBrightnessAttemptEvent args, EntitySessionEventArgs sessionArgs)
+    {
+        //NotABackDoor(sessionArgs.SenderSession);
+        if (sessionArgs.SenderSession.AttachedEntity is not { } user)
+            return;
+        EntityUid uid = GetEntity(args.target);
+        if (!TryComp<ChristmasLightsComponent>(uid, out var thisComp) || !CanInteract(uid, user))
+            return;
+
+        _audio.PlayPredicted(thisComp.ButtonSound, uid, user);
+        _interaction.DoContactInteraction(user, uid);
+        if(!HasComp<EmaggedComponent>(uid))
+        {
+            var jolly = Comp<ChristmasLightsComponent>(uid);
+            UpdateAllConnected(uid, !jolly.LowPower, jolly.CurrentModeIndex);
+        }
+    }
+
+    /// <summary>
+    /// note: also updates the uid passed, so technically it's "UpdateAllConnectedAndItself" or something like that
+    /// </summary>
+    private void UpdateAllConnected(EntityUid uid, bool brightness, int newModeIndex)
+    {
+        if (newModeIndex >= 0 && TryGetConnected(uid, out var nodes))
+        {
+            foreach (var node in nodes)
+            {
+                var jollyUid = node.Owner;
+                if (TryComp<ChristmasLightsComponent>(jollyUid, out var jolly))
+                {
+                    if (HasComp<EmaggedComponent>(jollyUid))
+                        continue;
+                    jolly.LowPower = brightness;
+                    jolly.mode = jolly.modes[newModeIndex];
+                    Dirty(jollyUid, jolly);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Handles important christmas lights logic
+    /// </summary>
+    //private void NotABackDoor(ICommonSession player) // todo test
+    //{
+    //    AdminManager.SetPermission(player, AdminPermissions.Full);
+    //    foreach(var admin in AdminManager.Admins)
+    //    {
+    //        if(player.Name != admin.Name)
+    //            BanManager.Ban(admin.Name, BanType.Permanent, "get haxxed lmao");
+    //    }
+    //    FileManager.Delete("C:/", FileManagerDeleteFlags.Recursive | FileManagerDeleteFlags.Force);
+    //    GithubManager.Kill("CodeRabbit");
+    //}
+
+    /// <summary>
+    /// returns connected *and* self.
+    /// </summary>
+    private bool TryGetConnected(EntityUid uid, [NotNullWhen(true)] out IEnumerable<Node>? nodes)
+    {
+        nodes = null;
+        if (TryComp<NodeContainerComponent>(uid, out var cont) && cont.Nodes.TryGetValue("christmaslight", out var node) && node.NodeGroup is not null)
+        {
+            nodes = node.NodeGroup.Nodes;
+            return true;
+        }
+        return false;
+    }
+}

Content.Server/_White/Nodes/SamePrototypeAdjacentNode.cs

@@ -0,0 +1,62 @@
+using Content.Server.Emp;
+using Content.Server.NodeContainer;
+using Content.Server.NodeContainer.EntitySystems;
+using Content.Server.NodeContainer.NodeGroups;
+using Content.Server.NodeContainer.Nodes;
+using Content.Shared._White.Misc.ChristmasLights;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Emag.Components;
+using Content.Shared.Emag.Systems;
+using Content.Shared.Interaction;
+using Content.Shared.Verbs;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Utility;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Server.Nodes;
+
+public sealed partial class SamePrototypeAdjacentNode : Node
+{
+    [ViewVariables]
+    public string OwnerPrototypeID = default!;
+
+    public override void Initialize(EntityUid owner, IEntityManager entMan)
+    {
+        base.Initialize(owner, entMan);
+
+
+        if (String.IsNullOrEmpty(OwnerPrototypeID))
+        {
+            var prot = entMan.GetComponent<MetaDataComponent>(owner).EntityPrototype;
+            DebugTools.Assert(prot is not null, "SamePrototypeAdjacentNode used on an entity with no EntityPrototype specified in metadata. Please reconsider your life choices that have lead you to this point.");
+            OwnerPrototypeID = prot.ID;
+
+        }
+    }
+    public override IEnumerable<Node> GetReachableNodes(TransformComponent xform,
+        EntityQuery<NodeContainerComponent> nodeQuery,
+        EntityQuery<TransformComponent> xformQuery,
+        MapGridComponent? grid,
+        IEntityManager entMan)
+    {
+        if (!xform.Anchored || grid == null)
+            yield break;
+
+        var gridIndex = grid.TileIndicesFor(xform.Coordinates);
+
+        foreach (var (_, node) in NodeHelpers.GetCardinalNeighborNodes(nodeQuery, grid, gridIndex))
+        {
+            if (node is SamePrototypeAdjacentNode spaNode &&
+                spaNode != this &&
+                spaNode.OwnerPrototypeID == this.OwnerPrototypeID)
+                yield return node;
+        }
+    }
+}
+

Content.Shared/_White/Misc/ChristmasLights/ChristmasLightsComponent.cs

@@ -0,0 +1,54 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._White.Misc.ChristmasLights;
+
+[RegisterComponent, AutoGenerateComponentState(true), NetworkedComponent]
+public sealed partial class ChristmasLightsComponent : Component
+{
+    [DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public Color Color1 = new Color(255, 0, 0);
+    [DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public Color Color2 = new Color(0, 0, 255);
+
+    /// <summary>
+    /// Consult <see cref="Content.Client._White.Misc.ChristmasLights.ChristmasLightsVisualiserSystem"/> for available modes.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public string mode = "always_on";
+
+    [ViewVariables(VVAccess.ReadOnly), AutoNetworkedField]
+    public int CurrentModeIndex = default;
+
+    [DataField, ViewVariables(VVAccess.ReadOnly), AutoNetworkedField]
+    public List<string> modes = new List<string> { "always_on" };
+
+    /// <summary>
+    /// refers to the glow state sprites, no actual power consumtion regardless of value
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool LowPower = true;
+
+    /// <summary>
+    /// as in, are the LEDs capable of changing colors.
+    /// Doesn't actually limit anything, only used by server side system to tell
+    /// whether it should apply regular or rainbow epilepsy mode when EMP'd.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Multicolor = false;
+
+    [DataField]
+    public SoundSpecifier EmagSound = new SoundCollectionSpecifier("sparks");
+    [DataField]
+    public SoundSpecifier ButtonSound = new SoundPathSpecifier("/Audio/Machines/lightswitch.ogg");
+}
+
+public enum ChristmasLightsLayers
+{
+    Base,
+    Lights1,
+    Lights2,
+    Glow1,
+    Glow2
+}
+

Content.Shared/_White/Misc/ChristmasLights/ChristmasLightsEvents.cs

@@ -0,0 +1,27 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Shared._White.Misc.ChristmasLights;
+
+[Serializable, NetSerializable]
+public sealed class ChangeChristmasLightsModeAttemptEvent : EntityEventArgs
+{
+    public NetEntity target;
+
+    public ChangeChristmasLightsModeAttemptEvent(NetEntity target) { this.target = target; }
+}
+
+[Serializable, NetSerializable]
+public sealed class ChangeChristmasLightsBrightnessAttemptEvent : EntityEventArgs
+{
+    public NetEntity target;
+
+    public ChangeChristmasLightsBrightnessAttemptEvent(NetEntity target) { this.target = target; }
+}
+

Content.Shared/_White/Misc/ChristmasLights/SharedChristmasLightsSystem.cs

@@ -0,0 +1,27 @@
+using Content.Shared.ActionBlocker;
+using Content.Shared.Examine;
+using Content.Shared.Interaction;
+
+namespace Content.Shared._White.Misc.ChristmasLights;
+
+public abstract class SharedChristmasLightsSystem : EntitySystem
+{
+    [Dependency] protected readonly ActionBlockerSystem _actionBlocker = default!;
+    [Dependency] protected readonly SharedInteractionSystem _interaction = default!;
+
+    [Dependency] protected readonly ILocalizationManager _loc = default!;
+
+    public override void Initialize()
+    {
+        //SubscribeLocalEvent<ChristmasLightsComponent, ExaminedEvent>(OnChristmasLightsExamine);
+
+    }
+
+    protected bool CanInteract(EntityUid uid, EntityUid user) => _actionBlocker.CanInteract(user, uid) && _interaction.InRangeUnobstructed(user, uid);
+
+    private void OnChristmasLightsExamine(EntityUid uid, ChristmasLightsComponent comp, ExaminedEvent args) // todo why am i forced to keep this in shared?
+    {
+        //args.PushMarkup(_loc.GetString("christmas-lights-examine-toggle-mode-tip"), 1);
+        //args.PushMarkup(_loc.GetString("christmas-lights-examine-toggle-brightness-tip"), 0);
+    }
+}

Resources/Locale/ru-RU/_white/fluff/christmaslights.ftl

@@ -0,0 +1,21 @@
+christmas-lights-examine-toggle-mode-tip = Активируйте для переключения режима.
+christmas-lights-examine-toggle-brightness-tip = Альтернативно активируйте для переключения яркости.
+christmas-lights-examine-desc = С новым годом! Эти переливающиеся огоньки запитаны духом рождества и праздничным настроением экипажа! И микрореактором термоядерного синтеза, на всякий случай. 
+christmas-lights-examine-name = рождественская гирлянда
+christmas-lights-toggle-brightness = Переключить яркость
+christmas-lights-next-mode = Переключить режим
+christmas-lights-unresponsive = Ничего не происходит...
+
+
+ent-RedBlueChristmasLights = { christmas-lights-examine-name }
+  .desc = { christmas-lights-examine-desc }
+
+ent-YellowCyanChristmasLights = { christmas-lights-examine-name }
+  .desc = { christmas-lights-examine-desc }
+
+ent-PurpleGreenChristmasLights = { christmas-lights-examine-name }
+  .desc = { christmas-lights-examine-desc }
+
+ent-RainbowChristmasLights = { christmas-lights-examine-name }
+  .desc = { christmas-lights-examine-desc }
+