Мягкий свет для всякого (#316)

* add: add small soft light to laser weapon + fix the bluest blue energy shield

* git commit

* boltlights done

* add: HuetaSystem

* add: Doorlights finally done

* add: small light to lockers

* add: small light to multitool

* fix: fix naming

* hui pizde

* fix: fix parasha

* add: small light to powercells

* zabil

* add: code light to welders

* tweak: better energy and radius

* add: better color parameters

* add: less radius and energy for guns

* add: better lights for vending machines

* add: better light to consoles

* add: better light for apc

* shut up

* fix: thank you neuro colleague

Content.Shared/_White/Lighting/PointLight/Airlock/PointLightAirlockComponent.cs

@@ -0,0 +1,19 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._White.Lighting.PointLight.Airlock;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class PointLightAirlockComponent : Component
+{
+    [ViewVariables]
+    public string RedColor = "#D56C6C";
+
+    [ViewVariables]
+    public string BlueColor = "#7F93C0";
+
+    [ViewVariables]
+    public string YellowColor = "#BDC07F";
+
+    [ViewVariables]
+    public string GreenColor = "#7FC080";
+}

Content.Shared/_White/Lighting/PointLight/Airlock/PointLightAirlockSystem.cs

@@ -0,0 +1,83 @@
+using Content.Shared.Doors.Components;
+
+namespace Content.Shared._White.Lighting.PointLight.Airlock;
+
+//TODO: Когда-нибудь починить эту хуйню: Когда дверь открыта на аварийный доступ и ее болтируют, то свет будет желтым, хотя должен быть красным из-за болтов.
+
+public sealed class SharedPointLightAirlockSystem : EntitySystem
+{
+    [Dependency] private readonly SharedPointLightSystem _pointLightSystem = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<PointLightAirlockComponent, DoorlightsChangedEvent>(OnDoorLightChanged);
+    }
+
+    public void ToggleLight(EntityUid uid, string hex, bool enable = true)
+    {
+        if (!_pointLightSystem.TryGetLight(uid, out var pointLightComponent))
+            return;
+
+        if (enable)
+        {
+            var color = Color.FromHex(hex);
+            _pointLightSystem.SetColor(uid, color, pointLightComponent);
+        }
+
+        _pointLightSystem.SetEnabled(uid, enable, pointLightComponent);
+
+        RaiseLocalEvent(uid, new PointLightToggleEvent(enable), true);
+    }
+
+    public void OnDoorLightChanged(EntityUid uid, PointLightAirlockComponent component, DoorlightsChangedEvent args)
+    {
+        if (!TryComp<DoorComponent>(uid, out var door))
+            return;
+
+        if (TryComp<AirlockComponent>(uid, out var airlockComponent) && airlockComponent.EmergencyAccess && args.Value && args.State is not DoorVisuals.EmergencyLights && args.State != null)
+            return; // While emergency access lights must be yellow no matter what
+
+        switch (args.State)
+        {
+            case DoorVisuals.BoltLights:
+                if (args.Value)
+                    ToggleLight(uid, component.RedColor);
+                else
+                    RaiseLocalEvent(uid, new DoorlightsChangedEvent(door.State, true));
+                break;
+
+            case DoorState.Denying:
+                ToggleLight(uid, component.RedColor);
+                break;
+
+            case DoorState.Closed:
+                ToggleLight(uid, component.BlueColor);
+                break;
+
+            case DoorVisuals.EmergencyLights:
+                if (args.Value)
+                    ToggleLight(uid, component.YellowColor);
+                else
+                    RaiseLocalEvent(uid, new DoorlightsChangedEvent(door.State, true));
+                break;
+
+            case DoorState.Open:
+                ToggleLight(uid, component.BlueColor);
+                break;
+
+            case DoorState.Opening:
+                ToggleLight(uid, component.GreenColor);
+                break;
+
+            case DoorState.Closing:
+                ToggleLight(uid, component.GreenColor);
+                break;
+
+            default:
+                ToggleLight(uid, "", false);
+                break;
+        }
+
+    }
+
+}

Content.Shared/_White/Lighting/PointLight/Locker/PointLightLockerComponent.cs

@@ -0,0 +1,19 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._White.Lighting.PointLight.Locker;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class PointLightLockerComponent : Component
+{
+    [DataField, ViewVariables]
+    public string RedColor = "#D56C6C";
+
+    [DataField, ViewVariables]
+    public string GreenColor = "#7FC080";
+
+    [DataField, ViewVariables]
+    public float ReduceEnergyOnOpen = 0.1f;
+
+    [DataField, ViewVariables]
+    public float ReduceRadiusOnOpen = 0.1f;
+}

Content.Shared/_White/Lighting/PointLight/Locker/PointLightLockerSystem.cs

@@ -0,0 +1,70 @@
+using Content.Shared.Lock;
+using Content.Shared.Storage.Components;
+
+namespace Content.Shared._White.Lighting.PointLight.Locker;
+
+public sealed class PointLightLockerSystem : EntitySystem
+{
+    [Dependency] private readonly SharedPointLightSystem _pointLightSystem = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<PointLightLockerComponent, ComponentInit>(OnComponentInit);
+
+        SubscribeLocalEvent<PointLightLockerComponent, LockToggledEvent>(OnLockToggled);
+        SubscribeLocalEvent<PointLightLockerComponent, StorageAfterOpenEvent>(OnStorageAfterOpen);
+        SubscribeLocalEvent<PointLightLockerComponent, StorageAfterCloseEvent>(OnStorageAfterClose);
+    }
+
+    public void ToggleLight(EntityUid uid, string hex, bool enable = true)
+    {
+        if (!_pointLightSystem.TryGetLight(uid, out var pointLightComponent))
+            return;
+
+        if (enable)
+        {
+            var color = Color.FromHex(hex);
+            _pointLightSystem.SetColor(uid, color, pointLightComponent);
+        }
+
+        _pointLightSystem.SetEnabled(uid, enable, pointLightComponent);
+
+        RaiseLocalEvent(uid, new PointLightToggleEvent(enable), true);
+    }
+
+    public void OnComponentInit(EntityUid uid, PointLightLockerComponent component, ComponentInit args)
+    {
+        if (!TryComp<LockComponent>(uid, out var locker))
+            return;
+
+        ToggleLight(uid, locker.Locked ? component.RedColor : component.GreenColor, true);
+    }
+
+    public void OnLockToggled(EntityUid uid, PointLightLockerComponent component, LockToggledEvent args)
+    {
+        ToggleLight(uid, args.Locked ? component.RedColor : component.GreenColor, true);
+    }
+
+    public void OnStorageAfterOpen(EntityUid uid, PointLightLockerComponent component, StorageAfterOpenEvent args)
+    {
+        ChangeLightOnDoorToggled(uid, component, true);
+    }
+
+    public void OnStorageAfterClose(EntityUid uid, PointLightLockerComponent component, StorageAfterCloseEvent args)
+    {
+        ChangeLightOnDoorToggled(uid, component, false);
+    }
+
+    public void ChangeLightOnDoorToggled(EntityUid uid, PointLightLockerComponent component, bool status)
+    {
+        if (!_pointLightSystem.TryGetLight(uid, out var pointLightComponent))
+            return;
+
+        var factor = status ? 1f : -1f;
+
+        _pointLightSystem.SetEnergy(uid, pointLightComponent.Energy - component.ReduceEnergyOnOpen * factor);
+        _pointLightSystem.SetRadius(uid, pointLightComponent.Radius- component.ReduceRadiusOnOpen * factor);
+
+        RaiseLocalEvent(uid, new PointLightToggleEvent(true), true);
+    }
+}