--- /dev/null
+using Content.Shared.Emp;
+using Robust.Shared.Random;
+
+namespace Content.Client.Emp;
+
+public sealed class EmpSystem : SharedEmpSystem
+{
+ [Dependency] private readonly IRobustRandom _random = default!;
+
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+
+ var query = EntityQueryEnumerator<EmpDisabledComponent, TransformComponent>();
+ while (query.MoveNext(out var uid, out var comp, out var transform))
+ {
+ if (Timing.CurTime > comp.TargetTime)
+ {
+ comp.TargetTime = Timing.CurTime + _random.NextFloat(0.8f, 1.2f) * TimeSpan.FromSeconds(comp.EffectCooldown);
+ Spawn(EmpDisabledEffectPrototype, transform.Coordinates);
+ }
+ }
+ }
+}
}
var empRange = component.MaxElectrocuteRange * 3;
- _emp.EmpPulse(Transform(uid).MapPosition, empRange, component.EmpEnergyConsumption);
+ _emp.EmpPulse(Transform(uid).MapPosition, empRange, component.EmpEnergyConsumption, component.EmpDisabledDuration);
}
public override void Update(float frameTime)
/// </summary>
[DataField("energyConsumption"), ViewVariables(VVAccess.ReadWrite)]
public float EnergyConsumption;
+
+ /// <summary>
+ /// How long it disables targets in seconds
+ /// </summary>
+ [DataField("disableDuration"), ViewVariables(VVAccess.ReadWrite)]
+ public float DisableDuration = 60f;
}
using Content.Server.Explosion.EntitySystems;
+using Content.Server.Power.EntitySystems;
+using Content.Server.Radio;
+using Content.Server.SurveillanceCamera;
+using Content.Shared.Emp;
+using Content.Shared.Examine;
using Robust.Shared.Map;
namespace Content.Server.Emp;
-public sealed class EmpSystem : EntitySystem
+public sealed class EmpSystem : SharedEmpSystem
{
[Dependency] private readonly EntityLookupSystem _lookup = default!;
public const string EmpPulseEffectPrototype = "EffectEmpPulse";
- public const string EmpDisabledEffectPrototype = "EffectEmpDisabled";
public override void Initialize()
{
base.Initialize();
+ SubscribeLocalEvent<EmpDisabledComponent, EntityUnpausedEvent>(OnUnpaused);
+ SubscribeLocalEvent<EmpDisabledComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<EmpOnTriggerComponent, TriggerEvent>(HandleEmpTrigger);
+
+ SubscribeLocalEvent<EmpDisabledComponent, RadioSendAttemptEvent>(OnRadioSendAttempt);
+ SubscribeLocalEvent<EmpDisabledComponent, RadioReceiveAttemptEvent>(OnRadioReceiveAttempt);
+ SubscribeLocalEvent<EmpDisabledComponent, ApcToggleMainBreakerAttemptEvent>(OnApcToggleMainBreaker);
+ SubscribeLocalEvent<EmpDisabledComponent, SurveillanceCameraSetActiveAttemptEvent>(OnCameraSetActive);
}
- public void EmpPulse(MapCoordinates coordinates, float range, float energyConsumption)
+ public void EmpPulse(MapCoordinates coordinates, float range, float energyConsumption, float duration)
{
foreach (var uid in _lookup.GetEntitiesInRange(coordinates, range))
{
- var ev = new EmpPulseEvent(energyConsumption, false);
+ var ev = new EmpPulseEvent(energyConsumption, false, false);
RaiseLocalEvent(uid, ref ev);
if (ev.Affected)
+ {
Spawn(EmpDisabledEffectPrototype, Transform(uid).Coordinates);
+ }
+ if (ev.Disabled)
+ {
+ var disabled = EnsureComp<EmpDisabledComponent>(uid);
+ disabled.DisabledUntil = Timing.CurTime + TimeSpan.FromSeconds(duration);
+ }
}
Spawn(EmpPulseEffectPrototype, coordinates);
}
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+
+ var query = EntityQueryEnumerator<EmpDisabledComponent>();
+ while (query.MoveNext(out var uid, out var comp))
+ {
+ if (comp.DisabledUntil < Timing.CurTime)
+ {
+ RemComp<EmpDisabledComponent>(uid);
+ var ev = new EmpDisabledRemoved();
+ RaiseLocalEvent(uid, ref ev);
+ }
+ }
+ }
+
+ private void OnUnpaused(EntityUid uid, EmpDisabledComponent component, ref EntityUnpausedEvent args)
+ {
+ component.DisabledUntil += args.PausedTime;
+ component.TargetTime += args.PausedTime;
+ }
+
+ private void OnExamine(EntityUid uid, EmpDisabledComponent component, ExaminedEvent args)
+ {
+ args.PushMarkup(Loc.GetString("emp-disabled-comp-on-examine"));
+ }
+
private void HandleEmpTrigger(EntityUid uid, EmpOnTriggerComponent comp, TriggerEvent args)
{
- EmpPulse(Transform(uid).MapPosition, comp.Range, comp.EnergyConsumption);
+ EmpPulse(Transform(uid).MapPosition, comp.Range, comp.EnergyConsumption, comp.DisableDuration);
args.Handled = true;
}
+
+ private void OnRadioSendAttempt(EntityUid uid, EmpDisabledComponent component, ref RadioSendAttemptEvent args)
+ {
+ args.Cancelled = true;
+ }
+
+ private void OnRadioReceiveAttempt(EntityUid uid, EmpDisabledComponent component, ref RadioReceiveAttemptEvent args)
+ {
+ args.Cancelled = true;
+ }
+
+ private void OnApcToggleMainBreaker(EntityUid uid, EmpDisabledComponent component, ref ApcToggleMainBreakerAttemptEvent args)
+ {
+ args.Cancelled = true;
+ }
+
+ private void OnCameraSetActive(EntityUid uid, EmpDisabledComponent component, ref SurveillanceCameraSetActiveAttemptEvent args)
+ {
+ args.Cancelled = true;
+ }
}
[ByRefEvent]
-public record struct EmpPulseEvent(float EnergyConsumption, bool Affected);
+public record struct EmpPulseEvent(float EnergyConsumption, bool Affected, bool Disabled);
+
+[ByRefEvent]
+public record struct EmpDisabledRemoved();
/// <summary>
/// Try to break bulb inside light fixture
/// </summary>
- public void TryDestroyBulb(EntityUid uid, PoweredLightComponent? light = null)
+ public bool TryDestroyBulb(EntityUid uid, PoweredLightComponent? light = null)
{
// check bulb state
var bulbUid = GetBulb(uid, light);
if (bulbUid == null || !EntityManager.TryGetComponent(bulbUid.Value, out LightBulbComponent? lightBulb))
- return;
+ return false;
if (lightBulb.State == LightBulbState.Broken)
- return;
+ return false;
// break it
_bulbSystem.SetState(bulbUid.Value, LightBulbState.Broken, lightBulb);
_bulbSystem.PlayBreakSound(bulbUid.Value, lightBulb);
UpdateLight(uid, light);
+ return true;
}
#endregion
private void OnEmpPulse(EntityUid uid, PoweredLightComponent component, ref EmpPulseEvent args)
{
- args.Affected = true;
- TryDestroyBulb(uid, component);
+ if (TryDestroyBulb(uid, component))
+ args.Affected = true;
}
}
}
}
private void OnToggleMainBreaker(EntityUid uid, ApcComponent component, ApcToggleMainBreakerMessage args)
{
+ var attemptEv = new ApcToggleMainBreakerAttemptEvent();
+ RaiseLocalEvent(uid, ref attemptEv);
+ if (attemptEv.Cancelled)
+ {
+ _popup.PopupCursor(Loc.GetString("apc-component-on-toggle-cancel"),
+ args.Session, PopupType.Medium);
+ return;
+ }
+
TryComp<AccessReaderComponent>(uid, out var access);
if (args.Session.AttachedEntity == null)
return;
if (component.MainBreakerEnabled)
{
args.Affected = true;
+ args.Disabled = true;
ApcToggleBreaker(uid, component);
}
}
}
+
+ [ByRefEvent]
+ public record struct ApcToggleMainBreakerAttemptEvent(bool Cancelled);
}
using Content.Server.Chat.Systems;
+using Content.Server.Emp;
using Content.Server.Radio.Components;
using Content.Shared.Inventory.Events;
using Content.Shared.Radio;
SubscribeLocalEvent<HeadsetComponent, EncryptionChannelsChangedEvent>(OnKeysChanged);
SubscribeLocalEvent<WearingHeadsetComponent, EntitySpokeEvent>(OnSpeak);
+
+ SubscribeLocalEvent<HeadsetComponent, EmpPulseEvent>(OnEmpPulse);
}
private void OnKeysChanged(EntityUid uid, HeadsetComponent component, EncryptionChannelsChangedEvent args)
if (TryComp(Transform(uid).ParentUid, out ActorComponent? actor))
_netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.ConnectedClient);
}
+
+ private void OnEmpPulse(EntityUid uid, HeadsetComponent component, ref EmpPulseEvent args)
+ {
+ if (component.Enabled)
+ {
+ args.Affected = true;
+ args.Disabled = true;
+ }
+ }
}
var sendAttemptEv = new RadioSendAttemptEvent(channel, radioSource);
RaiseLocalEvent(ref sendAttemptEv);
+ RaiseLocalEvent(radioSource, ref sendAttemptEv);
var canSend = !sendAttemptEv.Cancelled;
var sourceMapId = Transform(radioSource).MapID;
// check if message can be sent to specific receiver
var attemptEv = new RadioReceiveAttemptEvent(channel, radioSource, receiver);
RaiseLocalEvent(ref attemptEv);
+ RaiseLocalEvent(receiver, ref attemptEv);
if (attemptEv.Cancelled)
continue;
using Content.Server.DeviceNetwork;
using Content.Server.DeviceNetwork.Components;
using Content.Server.DeviceNetwork.Systems;
+using Content.Server.Emp;
using Content.Server.Power.Components;
using Content.Shared.ActionBlocker;
using Content.Shared.DeviceNetwork;
SubscribeLocalEvent<SurveillanceCameraComponent, SurveillanceCameraSetupSetName>(OnSetName);
SubscribeLocalEvent<SurveillanceCameraComponent, SurveillanceCameraSetupSetNetwork>(OnSetNetwork);
SubscribeLocalEvent<SurveillanceCameraComponent, GetVerbsEvent<AlternativeVerb>>(AddVerbs);
+
+ SubscribeLocalEvent<SurveillanceCameraComponent, EmpPulseEvent>(OnEmpPulse);
+ SubscribeLocalEvent<SurveillanceCameraComponent, EmpDisabledRemoved>(OnEmpDisabledRemoved);
}
private void OnPacketReceived(EntityUid uid, SurveillanceCameraComponent component, DeviceNetworkPacketEvent args)
if (setting)
{
+ var attemptEv = new SurveillanceCameraSetActiveAttemptEvent();
+ RaiseLocalEvent(camera, ref attemptEv);
+ if (attemptEv.Cancelled)
+ return;
component.Active = setting;
}
else
_appearance.SetData(uid, SurveillanceCameraVisualsKey.Key, key, appearance);
}
+
+ private void OnEmpPulse(EntityUid uid, SurveillanceCameraComponent component, ref EmpPulseEvent args)
+ {
+ if (component.Active)
+ {
+ args.Affected = true;
+ args.Disabled = true;
+ SetActive(uid, false);
+ }
+ }
+
+ private void OnEmpDisabledRemoved(EntityUid uid, SurveillanceCameraComponent component, ref EmpDisabledRemoved args)
+ {
+ SetActive(uid, true);
+ }
}
public sealed class OnSurveillanceCameraViewerAddEvent : EntityEventArgs
Camera = camera;
}
}
+
+[ByRefEvent]
+public record struct SurveillanceCameraSetActiveAttemptEvent(bool Cancelled);
using System.Linq;
using Content.Server.Cargo.Systems;
+using Content.Server.Emp;
using Content.Server.Power.Components;
using Content.Server.Power.EntitySystems;
using Content.Server.UserInterface;
using Content.Shared.DoAfter;
using Content.Shared.Emag.Components;
using Content.Shared.Emag.Systems;
+using Content.Shared.Emp;
using Content.Shared.Popups;
using Content.Shared.Throwing;
using Content.Shared.VendingMachines;
using Robust.Shared.Audio;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
+using Robust.Shared.Timing;
namespace Content.Server.VendingMachines
{
[Dependency] private readonly PricingSystem _pricing = default!;
[Dependency] private readonly ThrowingSystem _throwingSystem = default!;
[Dependency] private readonly UserInterfaceSystem _userInterfaceSystem = default!;
+ [Dependency] private readonly IGameTiming _timing = default!;
private ISawmill _sawmill = default!;
SubscribeLocalEvent<VendingMachineComponent, GotEmaggedEvent>(OnEmagged);
SubscribeLocalEvent<VendingMachineComponent, DamageChangedEvent>(OnDamage);
SubscribeLocalEvent<VendingMachineComponent, PriceCalculationEvent>(OnVendingPrice);
+ SubscribeLocalEvent<VendingMachineComponent, EmpPulseEvent>(OnEmpPulse);
SubscribeLocalEvent<VendingMachineComponent, ActivatableUIOpenAttemptEvent>(OnActivatableUIOpenAttempt);
SubscribeLocalEvent<VendingMachineComponent, BoundUIOpenedEvent>(OnBoundUIOpened);
}
}
}
+ var disabled = EntityQueryEnumerator<EmpDisabledComponent, VendingMachineComponent>();
+ while (disabled.MoveNext(out var uid, out _, out var comp))
+ {
+ if (comp.NextEmpEject < _timing.CurTime)
+ {
+ EjectRandom(uid, true, false, comp);
+ comp.NextEmpEject += TimeSpan.FromSeconds(5 * comp.EjectDelay);
+ }
+ }
}
public void TryRestockInventory(EntityUid uid, VendingMachineComponent? vendComponent = null)
args.Price += priceSets.Max();
}
+
+ private void OnEmpPulse(EntityUid uid, VendingMachineComponent component, ref EmpPulseEvent args)
+ {
+ if (!component.Broken && this.IsPowered(uid, EntityManager))
+ {
+ args.Affected = true;
+ args.Disabled = true;
+ component.NextEmpEject = _timing.CurTime;
+ }
+ }
}
}
[DataField("energyConsumption"), ViewVariables(VVAccess.ReadWrite)]
public float EnergyConsumption = 1000000;
+
+ [DataField("disableDuration"), ViewVariables(VVAccess.ReadWrite)]
+ public float DisableDuration = 60f;
}
private void OnActivate(EntityUid uid, EmpArtifactComponent component, ArtifactActivatedEvent args)
{
- _emp.EmpPulse(Transform(uid).MapPosition, component.Range, component.EnergyConsumption);
+ _emp.EmpPulse(Transform(uid).MapPosition, component.Range, component.EnergyConsumption, component.DisableDuration);
}
}
\ No newline at end of file
/// <summary>
[DataField("empEnergyConsumption"), ViewVariables(VVAccess.ReadWrite)]
public float EmpEnergyConsumption = 100000f;
+
+ /// <summary>
+ /// Duration of devices being disabled by the emp pulse upon going supercritical.
+ /// <summary>
+ [DataField("empDisabledDuration"), ViewVariables(VVAccess.ReadWrite)]
+ public float EmpDisabledDuration = 60f;
}
--- /dev/null
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Shared.Emp;
+
+/// <summary>
+/// While entity has this component it is "disabled" by EMP.
+/// Add desired behaviour in other systems
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedEmpSystem))]
+public sealed class EmpDisabledComponent : Component
+{
+ /// <summary>
+ /// Moment of time when component is removed and entity stops being "disabled"
+ /// </summary>
+ [DataField("timeLeft", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ public TimeSpan DisabledUntil;
+
+ [DataField("effectCoolDown"), ViewVariables(VVAccess.ReadWrite)]
+ public float EffectCooldown = 3f;
+
+ /// <summary>
+ /// When next effect will be spawned
+ /// </summary>
+ public TimeSpan TargetTime = TimeSpan.Zero;
+}
--- /dev/null
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Emp;
+
+public abstract class SharedEmpSystem : EntitySystem
+{
+ [Dependency] protected readonly IGameTiming Timing = default!;
+
+ protected const string EmpDisabledEffectPrototype = "EffectEmpDisabled";
+}
using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
namespace Content.Shared.VendingMachines
public float DenyAccumulator = 0f;
public float DispenseOnHitAccumulator = 0f;
+ /// <summary>
+ /// While disabled by EMP it randomly ejects items
+ /// </summary>
+ [DataField("nextEmpEject", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ public TimeSpan NextEmpEject = TimeSpan.Zero;
+
#region Client Visuals
/// <summary>
/// RSI state for when the vending machine is unpowered.
apc-component-insufficient-access = Insufficient access!
apc-component-on-examine-panel-open = The [color=lightgray]APC electronics panel[/color] is [color=red]open[/color].
-apc-component-on-examine-panel-closed = The [color=lightgray]APC electronics panel[/color] is [color=darkgreen]closed[/color].
\ No newline at end of file
+apc-component-on-examine-panel-closed = The [color=lightgray]APC electronics panel[/color] is [color=darkgreen]closed[/color].
+apc-component-on-toggle-cancel = It does nothing!
--- /dev/null
+emp-disabled-comp-on-examine = [color=lightblue]It's disrupted by an electric field... [/color]
projects / space-station-14.git / commitdiff