--- /dev/null
+using Content.Shared.DeviceNetwork.Systems;
+
+namespace Content.Client.DeviceNetwork.Systems;
+
+/// <inheritdoc/>
+public sealed class DeviceNetworkJammerSystem : SharedDeviceNetworkJammerSystem;
-using Content.Server.DeviceNetwork.Components;
using Content.Shared.DeviceNetwork.Components;
+using Content.Shared.DeviceNetwork.Systems;
using Robust.Server.GameObjects;
namespace Content.Server.DeviceNetwork.Systems;
-public sealed class DeviceNetworkJammerSystem : EntitySystem
+/// <inheritdoc/>
+public sealed class DeviceNetworkJammerSystem : SharedDeviceNetworkJammerSystem
{
- [Dependency] private TransformSystem _transform = default!;
+ [Dependency] private readonly TransformSystem _transform = default!;
+ [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
+
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<TransformComponent, BeforePacketSentEvent>(BeforePacketSent);
}
- private void BeforePacketSent(EntityUid uid, TransformComponent xform, BeforePacketSentEvent ev)
+ private void BeforePacketSent(Entity<TransformComponent> xform, ref BeforePacketSentEvent ev)
{
if (ev.Cancelled)
return;
var query = EntityQueryEnumerator<DeviceNetworkJammerComponent, TransformComponent>();
- while (query.MoveNext(out _, out var jammerComp, out var jammerXform))
+ while (query.MoveNext(out var uid, out var jammerComp, out var jammerXform))
{
- if (!jammerComp.JammableNetworks.Contains(ev.NetworkId))
+ if (!_jammer.GetJammableNetworks((uid, jammerComp)).Contains(ev.NetworkId))
continue;
- if (jammerXform.Coordinates.InRange(EntityManager, _transform, ev.SenderTransform.Coordinates, jammerComp.Range)
- || jammerXform.Coordinates.InRange(EntityManager, _transform, xform.Coordinates, jammerComp.Range))
+ if (_transform.InRange(jammerXform.Coordinates, ev.SenderTransform.Coordinates, jammerComp.Range)
+ || _transform.InRange(jammerXform.Coordinates, xform.Comp.Coordinates, jammerComp.Range))
{
ev.Cancel();
return;
+++ /dev/null
-using Content.Server.Radio.EntitySystems;
-
-namespace Content.Server.Radio.Components;
-
-/// <summary>
-/// Prevents all radio in range from sending messages
-/// </summary>
-[RegisterComponent]
-[Access(typeof(JammerSystem))]
-public sealed partial class ActiveRadioJammerComponent : Component
-{
-}
using Content.Server.DeviceNetwork.Components;
-using Content.Server.Popups;
using Content.Server.Power.EntitySystems;
using Content.Server.PowerCell;
-using Content.Server.Radio.Components;
using Content.Shared.DeviceNetwork.Components;
-using Content.Shared.Examine;
using Content.Shared.Interaction;
using Content.Shared.PowerCell.Components;
-using Content.Shared.RadioJammer;
using Content.Shared.Radio.EntitySystems;
+using Content.Shared.Radio.Components;
+using Content.Shared.DeviceNetwork.Systems;
namespace Content.Server.Radio.EntitySystems;
[Dependency] private readonly PowerCellSystem _powerCell = default!;
[Dependency] private readonly BatterySystem _battery = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
+ [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
public override void Initialize()
{
SubscribeLocalEvent<RadioJammerComponent, ActivateInWorldEvent>(OnActivate);
SubscribeLocalEvent<ActiveRadioJammerComponent, PowerCellChangedEvent>(OnPowerCellChanged);
- SubscribeLocalEvent<RadioJammerComponent, ExaminedEvent>(OnExamine);
SubscribeLocalEvent<RadioSendAttemptEvent>(OnRadioSendAttempt);
}
if (_powerCell.TryGetBatteryFromSlot(uid, out var batteryUid, out var battery))
{
- if (!_battery.TryUseCharge(batteryUid.Value, GetCurrentWattage(jam) * frameTime, battery))
+ if (!_battery.TryUseCharge(batteryUid.Value, GetCurrentWattage((uid, jam)) * frameTime, battery))
{
- ChangeLEDState(false, uid);
+ ChangeLEDState(uid, false);
RemComp<ActiveRadioJammerComponent>(uid);
RemComp<DeviceNetworkJammerComponent>(uid);
}
else
{
var percentCharged = battery.CurrentCharge / battery.MaxCharge;
- if (percentCharged > .50)
+ var chargeLevel = percentCharged switch
{
- ChangeChargeLevel(RadioJammerChargeLevel.High, uid);
- }
- else if (percentCharged < .15)
- {
- ChangeChargeLevel(RadioJammerChargeLevel.Low, uid);
- }
- else
- {
- ChangeChargeLevel(RadioJammerChargeLevel.Medium, uid);
- }
+ > 0.50f => RadioJammerChargeLevel.High,
+ < 0.15f => RadioJammerChargeLevel.Low,
+ _ => RadioJammerChargeLevel.Medium,
+ };
+ ChangeChargeLevel(uid, chargeLevel);
}
}
}
}
- private void OnActivate(EntityUid uid, RadioJammerComponent comp, ActivateInWorldEvent args)
+ private void OnActivate(Entity<RadioJammerComponent> ent, ref ActivateInWorldEvent args)
{
if (args.Handled || !args.Complex)
return;
- var activated = !HasComp<ActiveRadioJammerComponent>(uid) &&
- _powerCell.TryGetBatteryFromSlot(uid, out var battery) &&
- battery.CurrentCharge > GetCurrentWattage(comp);
+ var activated = !HasComp<ActiveRadioJammerComponent>(ent) &&
+ _powerCell.TryGetBatteryFromSlot(ent.Owner, out var battery) &&
+ battery.CurrentCharge > GetCurrentWattage(ent);
if (activated)
{
- ChangeLEDState(true, uid);
- EnsureComp<ActiveRadioJammerComponent>(uid);
- EnsureComp<DeviceNetworkJammerComponent>(uid, out var jammingComp);
- jammingComp.Range = GetCurrentRange(comp);
- jammingComp.JammableNetworks.Add(DeviceNetworkComponent.DeviceNetIdDefaults.Wireless.ToString());
- Dirty(uid, jammingComp);
+ ChangeLEDState(ent.Owner, true);
+ EnsureComp<ActiveRadioJammerComponent>(ent);
+ EnsureComp<DeviceNetworkJammerComponent>(ent, out var jammingComp);
+ _jammer.SetRange((ent, jammingComp), GetCurrentRange(ent));
+ _jammer.AddJammableNetwork((ent, jammingComp), DeviceNetworkComponent.DeviceNetIdDefaults.Wireless.ToString());
}
else
{
- ChangeLEDState(false, uid);
- RemCompDeferred<ActiveRadioJammerComponent>(uid);
- RemCompDeferred<DeviceNetworkJammerComponent>(uid);
+ ChangeLEDState(ent.Owner, false);
+ RemCompDeferred<ActiveRadioJammerComponent>(ent);
+ RemCompDeferred<DeviceNetworkJammerComponent>(ent);
}
var state = Loc.GetString(activated ? "radio-jammer-component-on-state" : "radio-jammer-component-off-state");
var message = Loc.GetString("radio-jammer-component-on-use", ("state", state));
args.Handled = true;
}
- private void OnPowerCellChanged(EntityUid uid, ActiveRadioJammerComponent comp, PowerCellChangedEvent args)
+ private void OnPowerCellChanged(Entity<ActiveRadioJammerComponent> ent, ref PowerCellChangedEvent args)
{
if (args.Ejected)
{
- ChangeLEDState(false, uid);
- RemCompDeferred<ActiveRadioJammerComponent>(uid);
- }
- }
-
- private void OnExamine(EntityUid uid, RadioJammerComponent comp, ExaminedEvent args)
- {
- if (args.IsInDetailsRange)
- {
- var powerIndicator = HasComp<ActiveRadioJammerComponent>(uid)
- ? Loc.GetString("radio-jammer-component-examine-on-state")
- : Loc.GetString("radio-jammer-component-examine-off-state");
- args.PushMarkup(powerIndicator);
-
- var powerLevel = Loc.GetString(comp.Settings[comp.SelectedPowerLevel].Name);
- var switchIndicator = Loc.GetString("radio-jammer-component-switch-setting", ("powerLevel", powerLevel));
- args.PushMarkup(switchIndicator);
+ ChangeLEDState(ent.Owner, false);
+ RemCompDeferred<ActiveRadioJammerComponent>(ent);
}
}
var source = Transform(sourceUid).Coordinates;
var query = EntityQueryEnumerator<ActiveRadioJammerComponent, RadioJammerComponent, TransformComponent>();
- while (query.MoveNext(out _, out _, out var jam, out var transform))
+ while (query.MoveNext(out var uid, out _, out var jam, out var transform))
{
- if (source.InRange(EntityManager, _transform, transform.Coordinates, GetCurrentRange(jam)))
+ if (_transform.InRange(source, transform.Coordinates, GetCurrentRange((uid, jam))))
{
return true;
}
+using Content.Shared.DeviceNetwork.Systems;
using Robust.Shared.GameStates;
namespace Content.Shared.DeviceNetwork.Components;
/// Allow entities to jam DeviceNetwork packets.
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedDeviceNetworkJammerSystem))]
public sealed partial class DeviceNetworkJammerComponent : Component
{
/// <summary>
--- /dev/null
+using Content.Shared.DeviceNetwork.Components;
+
+namespace Content.Shared.DeviceNetwork.Systems;
+
+/// <inheritdoc cref="DeviceNetworkJammerComponent"/>
+public abstract class SharedDeviceNetworkJammerSystem : EntitySystem
+{
+ /// <summary>
+ /// Sets the range of the jamming effect.
+ /// </summary>
+ public void SetRange(Entity<DeviceNetworkJammerComponent> ent, float value)
+ {
+ ent.Comp.Range = value;
+ Dirty(ent);
+ }
+
+ /// <inheritdoc cref="SetRange"/>
+ public bool TrySetRange(Entity<DeviceNetworkJammerComponent?> ent, float value)
+ {
+ if (!Resolve(ent, ref ent.Comp, logMissing: false))
+ return false;
+
+ SetRange((ent, ent.Comp), value);
+ return true;
+ }
+
+ /// <summary>
+ /// Returns the set of networks that this entity can jam.
+ public IReadOnlySet<string> GetJammableNetworks(Entity<DeviceNetworkJammerComponent> ent)
+ {
+ return ent.Comp.JammableNetworks;
+ }
+
+ /// <summary>
+ /// Enables this entity to jam packets on the specified network.
+ /// </summary>
+ public void AddJammableNetwork(Entity<DeviceNetworkJammerComponent> ent, string networkId)
+ {
+ if (ent.Comp.JammableNetworks.Add(networkId))
+ Dirty(ent);
+ }
+
+ /// <summary>
+ /// Stops this entity from jamming packets on the specified network.
+ /// </summary>
+ public void RemoveJammableNetwork(Entity<DeviceNetworkJammerComponent> ent, string networkId)
+ {
+ if (ent.Comp.JammableNetworks.Remove(networkId))
+ Dirty(ent);
+ }
+
+ /// <summary>
+ /// Stops this entity from jamming packets on any networks.
+ /// </summary>
+ public void ClearJammableNetworks(Entity<DeviceNetworkJammerComponent> ent)
+ {
+ if (ent.Comp.JammableNetworks.Count == 0)
+ return;
+
+ ent.Comp.JammableNetworks.Clear();
+ Dirty(ent);
+ }
+}
--- /dev/null
+using Content.Shared.Radio.EntitySystems;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Radio.Components;
+
+/// <summary>
+/// Prevents all radio in range from sending messages
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedJammerSystem))]
+public sealed partial class ActiveRadioJammerComponent : Component
+{
+}
using Robust.Shared.Serialization;
using Robust.Shared.GameStates;
-namespace Content.Shared.RadioJammer;
+namespace Content.Shared.Radio.Components;
/// <summary>
/// When activated (<see cref="ActiveRadioJammerComponent"/>) prevents from sending messages in range
/// Suit sensors will also stop working.
/// </summary>
[NetworkedComponent, RegisterComponent]
+[AutoGenerateComponentState]
public sealed partial class RadioJammerComponent : Component
{
[DataDefinition]
public float Range;
/// <summary>
- /// The message that is displayed when switched
+ /// The message that is displayed when switched.
/// to this setting.
/// </summary>
[DataField(required: true)]
/// Index of the currently selected setting.
/// </summary>
[DataField]
+ [AutoNetworkedField]
public int SelectedPowerLevel = 1;
}
using Content.Shared.Popups;
-using Content.Shared.DeviceNetwork.Components;
using Content.Shared.Verbs;
-using Content.Shared.RadioJammer;
+using Content.Shared.Examine;
+using Content.Shared.Radio.Components;
+using Content.Shared.DeviceNetwork.Systems;
namespace Content.Shared.Radio.EntitySystems;
public abstract class SharedJammerSystem : EntitySystem
{
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
[Dependency] protected readonly SharedPopupSystem Popup = default!;
public override void Initialize()
base.Initialize();
SubscribeLocalEvent<RadioJammerComponent, GetVerbsEvent<Verb>>(OnGetVerb);
+ SubscribeLocalEvent<RadioJammerComponent, ExaminedEvent>(OnExamine);
}
private void OnGetVerb(Entity<RadioJammerComponent> entity, ref GetVerbsEvent<Verb> args)
Act = () =>
{
entity.Comp.SelectedPowerLevel = currIndex;
- if (TryComp<DeviceNetworkJammerComponent>(entity.Owner, out var jammerComp))
+ Dirty(entity);
+ if (_jammer.TrySetRange(entity.Owner, GetCurrentRange(entity)))
{
- // This is a little sketcy but only way to do it.
- jammerComp.Range = GetCurrentRange(entity.Comp);
- Dirty(entity.Owner, jammerComp);
+ Popup.PopupPredicted(Loc.GetString(setting.Message), user, user);
}
- Popup.PopupPredicted(Loc.GetString(setting.Message), user, user);
},
Text = Loc.GetString(setting.Name),
};
}
}
- public float GetCurrentWattage(RadioJammerComponent jammer)
+ private void OnExamine(Entity<RadioJammerComponent> ent, ref ExaminedEvent args)
{
- return jammer.Settings[jammer.SelectedPowerLevel].Wattage;
+ if (args.IsInDetailsRange)
+ {
+ var powerIndicator = HasComp<ActiveRadioJammerComponent>(ent)
+ ? Loc.GetString("radio-jammer-component-examine-on-state")
+ : Loc.GetString("radio-jammer-component-examine-off-state");
+ args.PushMarkup(powerIndicator);
+
+ var powerLevel = Loc.GetString(ent.Comp.Settings[ent.Comp.SelectedPowerLevel].Name);
+ var switchIndicator = Loc.GetString("radio-jammer-component-switch-setting", ("powerLevel", powerLevel));
+ args.PushMarkup(switchIndicator);
+ }
+ }
+
+ public float GetCurrentWattage(Entity<RadioJammerComponent> jammer)
+ {
+ return jammer.Comp.Settings[jammer.Comp.SelectedPowerLevel].Wattage;
}
- public float GetCurrentRange(RadioJammerComponent jammer)
+ public float GetCurrentRange(Entity<RadioJammerComponent> jammer)
{
- return jammer.Settings[jammer.SelectedPowerLevel].Range;
+ return jammer.Comp.Settings[jammer.Comp.SelectedPowerLevel].Range;
}
- protected void ChangeLEDState(bool isLEDOn, EntityUid uid,
- AppearanceComponent? appearance = null)
+ protected void ChangeLEDState(Entity<AppearanceComponent?> ent, bool isLEDOn)
{
- _appearance.SetData(uid, RadioJammerVisuals.LEDOn, isLEDOn, appearance);
+ _appearance.SetData(ent, RadioJammerVisuals.LEDOn, isLEDOn, ent.Comp);
}
- protected void ChangeChargeLevel(RadioJammerChargeLevel chargeLevel, EntityUid uid,
- AppearanceComponent? appearance = null)
+ protected void ChangeChargeLevel(Entity<AppearanceComponent?> ent, RadioJammerChargeLevel chargeLevel)
{
- _appearance.SetData(uid, RadioJammerVisuals.ChargeLevel, chargeLevel, appearance);
+ _appearance.SetData(ent, RadioJammerVisuals.ChargeLevel, chargeLevel, ent.Comp);
}
}
projects / space-station-14.git / commitdiff