Implement machine linking (#1784)

* Implement machine linking

* Cleanup and rename Signals

* Implement signal button

* Add machine linking signal mapping

* Fix signallink command help

* Add localization to signal linking and allow infinite range

* Add feedback for when a transmitter is not connected to any receivers

Refactor PopupMessage to use the entity extension
Refactor dependencies to not have to disable warnings
This commit is contained in:
ShadowCommander
2020-08-29 03:33:42 -07:00
committed by GitHub
parent f3315feba1
commit aa66aa2286
16 changed files with 701 additions and 9 deletions

View File

@@ -0,0 +1,14 @@
namespace Content.Server.GameObjects.Components.MachineLinking
{
public interface ISignalReceiver
{
void TriggerSignal(SignalState state);
}
public enum SignalState
{
On,
Off,
Toggle
}
}

View File

@@ -0,0 +1,40 @@
using Content.Shared.Interfaces;
using Content.Shared.Interfaces.GameObjects.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Localization;
namespace Content.Server.GameObjects.Components.MachineLinking
{
[RegisterComponent]
public class SignalButtonComponent : Component, IActivate, IInteractHand
{
public override string Name => "SignalButton";
public void Activate(ActivateEventArgs eventArgs)
{
TransmitSignal(eventArgs.User);
}
public bool InteractHand(InteractHandEventArgs eventArgs)
{
TransmitSignal(eventArgs.User);
return true;
}
private void TransmitSignal(IEntity user)
{
if (!Owner.TryGetComponent<SignalTransmitterComponent>(out var transmitter))
{
return;
}
if (transmitter.TransmitSignal(user, SignalState.Toggle))
{
// Since the button doesn't have an animation, I'm going to use a popup message
Owner.PopupMessage(user, Loc.GetString("Click."));
}
}
}
}

View File

@@ -0,0 +1,21 @@
using Robust.Shared.GameObjects;
using Robust.Shared.ViewVariables;
namespace Content.Server.GameObjects.Components.MachineLinking
{
[RegisterComponent]
public class SignalLinkerComponent : Component
{
public override string Name => "SignalLinker";
[ViewVariables]
public SignalTransmitterComponent Link { get; set; }
public override void Initialize()
{
base.Initialize();
Link = null;
}
}
}

View File

@@ -0,0 +1,118 @@
using Content.Server.GameObjects.Components.Interactable;
using Content.Shared.GameObjects.Components.Interactable;
using Content.Shared.Interfaces;
using Content.Shared.Interfaces.GameObjects.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Content.Server.GameObjects.Components.MachineLinking
{
[RegisterComponent]
public class SignalReceiverComponent : Component, IInteractUsing
{
[Dependency] private readonly IMapManager _mapManager = default!;
public override string Name => "SignalReceiver";
private List<SignalTransmitterComponent> _transmitters;
public override void Initialize()
{
base.Initialize();
_transmitters = new List<SignalTransmitterComponent>();
}
public void DistributeSignal(SignalState state)
{
foreach (var comp in Owner.GetAllComponents<ISignalReceiver>())
{
comp.TriggerSignal(state);
}
}
public void Subscribe(SignalTransmitterComponent transmitter)
{
if (_transmitters.Contains(transmitter))
{
return;
}
transmitter.Subscribe(this);
_transmitters.Add(transmitter);
}
public void Unsubscribe(SignalTransmitterComponent transmitter)
{
transmitter.Unsubscribe(this);
_transmitters.Remove(transmitter);
}
/// <summary>
/// Subscribes/Unsubscribes a transmitter to this component. Returns whether it was successful.
/// </summary>
/// <param name="user"></param>
/// <param name="transmitter"></param>
/// <returns></returns>
public bool Interact(IEntity user, SignalTransmitterComponent transmitter)
{
if (transmitter == null)
{
user.PopupMessage(user, Loc.GetString("Signal not set."));
return false;
}
if (_transmitters.Contains(transmitter))
{
Unsubscribe(transmitter);
Owner.PopupMessage(user, Loc.GetString("Unlinked."));
return true;
}
if (transmitter.Range > 0 && !Owner.Transform.GridPosition.InRange(_mapManager, transmitter.Owner.Transform.GridPosition, transmitter.Range))
{
Owner.PopupMessage(user, Loc.GetString("Out of range."));
return false;
}
Subscribe(transmitter);
Owner.PopupMessage(user, Loc.GetString("Linked!"));
return true;
}
public async Task<bool> InteractUsing(InteractUsingEventArgs eventArgs)
{
if (!eventArgs.Using.TryGetComponent<ToolComponent>(out var tool))
return false;
if (tool.HasQuality(ToolQuality.Multitool)
&& eventArgs.Using.TryGetComponent<SignalLinkerComponent>(out var linker))
{
return Interact(eventArgs.User, linker.Link);
}
return false;
}
protected override void Shutdown()
{
base.Shutdown();
foreach (var transmitter in _transmitters)
{
if (transmitter.Deleted)
{
continue;
}
transmitter.Unsubscribe(this);
}
_transmitters.Clear();
}
}
}

View File

@@ -0,0 +1,87 @@
using Content.Shared.GameObjects.EntitySystems;
using Content.Shared.GameObjects.Verbs;
using Content.Shared.Interfaces.GameObjects.Components;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Serialization;
namespace Content.Server.GameObjects.Components.MachineLinking
{
[RegisterComponent]
public class SignalSwitchComponent : Component, IInteractHand, IActivate
{
public override string Name => "SignalSwitch";
private bool _on;
public override void Initialize()
{
base.Initialize();
UpdateSprite();
}
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref _on, "on", true);
}
public void Activate(ActivateEventArgs eventArgs)
{
TransmitSignal(eventArgs.User);
}
public bool InteractHand(InteractHandEventArgs eventArgs)
{
TransmitSignal(eventArgs.User);
return true;
}
public void TransmitSignal(IEntity user)
{
_on = !_on;
UpdateSprite();
if (!Owner.TryGetComponent<SignalTransmitterComponent>(out var transmitter))
{
return;
}
transmitter.TransmitSignal(user, _on ? SignalState.On : SignalState.Off);
}
private void UpdateSprite()
{
if (Owner.TryGetComponent<SpriteComponent>(out var sprite))
{
sprite.LayerSetState(0, _on ? "on" : "off");
}
}
[Verb]
private sealed class ToggleSwitchVerb : Verb<SignalSwitchComponent>
{
protected override void Activate(IEntity user, SignalSwitchComponent component)
{
component.TransmitSignal(user);
}
protected override void GetData(IEntity user, SignalSwitchComponent component, VerbData data)
{
if (!ActionBlockerSystem.CanInteract(user))
{
data.Visibility = VerbVisibility.Invisible;
return;
}
data.Text = Loc.GetString("Toggle Switch");
data.Visibility = VerbVisibility.Visible;
}
}
}
}

View File

@@ -0,0 +1,166 @@
using Content.Server.GameObjects.Components.Interactable;
using Content.Shared.GameObjects.Components.Interactable;
using Content.Shared.Interfaces;
using Content.Shared.Interfaces.GameObjects.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Content.Server.GameObjects.Components.MachineLinking
{
[RegisterComponent]
public class SignalTransmitterComponent : Component, IInteractUsing
{
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
public override string Name => "SignalTransmitter";
private List<SignalReceiverComponent> _unresolvedReceivers;
private List<SignalReceiverComponent> _receivers;
[ViewVariables] private float _range;
/// <summary>
/// 0 is unlimited range
/// </summary>
public float Range { get => _range; private set => _range = value; }
public override void Initialize()
{
base.Initialize();
_receivers = new List<SignalReceiverComponent>();
if (_unresolvedReceivers != null)
{
foreach (var receiver in _unresolvedReceivers)
{
receiver.Subscribe(this);
}
_unresolvedReceivers = null;
}
}
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref _range, "range", 10);
if (serializer.Reading)
{
if (!serializer.TryReadDataField("signalReceivers", out List<EntityUid> entityUids))
{
return;
}
_unresolvedReceivers = new List<SignalReceiverComponent>();
foreach (var entityUid in entityUids)
{
if (!_entityManager.TryGetEntity(entityUid, out var entity)
|| !entity.TryGetComponent<SignalReceiverComponent>(out var receiver))
{
continue;
}
_unresolvedReceivers.Add(receiver);
}
}
else if (serializer.Writing)
{
var entityList = new List<EntityUid>();
foreach (var receiver in _receivers)
{
if (receiver.Deleted)
{
continue;
}
entityList.Add(receiver.Owner.Uid);
}
serializer.DataWriteFunction("signalReceivers", null, () => entityList);
}
}
public bool TransmitSignal(IEntity user, SignalState state)
{
if (_receivers.Count == 0)
{
Owner.PopupMessage(user, Loc.GetString("No receivers connected."));
return false;
}
foreach (var receiver in _receivers)
{
if (Range > 0 && !Owner.Transform.GridPosition.InRange(_mapManager, receiver.Owner.Transform.GridPosition, Range))
{
continue;
}
receiver.DistributeSignal(state);
}
return true;
}
public void Subscribe(SignalReceiverComponent receiver)
{
if (_receivers.Contains(receiver))
{
return;
}
_receivers.Add(receiver);
}
public void Unsubscribe(SignalReceiverComponent receiver)
{
_receivers.Remove(receiver);
}
public SignalTransmitterComponent GetSignal(IEntity user)
{
if (user != null)
{
Owner.PopupMessage(user, Loc.GetString("Signal fetched."));
}
return this;
}
public async Task<bool> InteractUsing(InteractUsingEventArgs eventArgs)
{
if (!eventArgs.Using.TryGetComponent<ToolComponent>(out var tool))
return false;
if (tool.HasQuality(ToolQuality.Multitool)
&& eventArgs.Using.TryGetComponent<SignalLinkerComponent>(out var linker))
{
linker.Link = GetSignal(eventArgs.User);
}
return false;
}
protected override void Shutdown()
{
base.Shutdown();
foreach (var receiver in _receivers)
{
if (receiver.Deleted)
{
continue;
}
receiver.Unsubscribe(this);
}
_receivers.Clear();
}
}
}