468 lines
18 KiB
C#
468 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma.Items.Components
|
|
{
|
|
partial class Connection
|
|
{
|
|
//how many wires can be linked to connectors by default
|
|
private const int DefaultMaxWires = 5;
|
|
|
|
//how many wires a player can link to this connection
|
|
public readonly int MaxPlayerConnectableWires = 5;
|
|
|
|
//how many wires can be linked to this connection in total
|
|
public readonly int MaxWires = 5;
|
|
|
|
public readonly int DisplayOrder;
|
|
|
|
public readonly string Name;
|
|
private readonly LocalizedString _displayName;
|
|
public LocalizedString DisplayName
|
|
{
|
|
get => DisplayNameOverride ?? _displayName;
|
|
private init => _displayName = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display name ignoring <see cref="DisplayNameOverride"/>
|
|
/// </summary>
|
|
public LocalizedString DefaultDisplayName => _displayName;
|
|
|
|
public LocalizedString DisplayNameOverride;
|
|
|
|
private readonly HashSet<Wire> wires;
|
|
public IReadOnlyCollection<Wire> Wires => wires;
|
|
|
|
/// <summary>
|
|
/// Circuit box input and output connections that are linked to this connection.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// We don't want to create a wire between the circuit boxes connection panel and the
|
|
/// connection panel of the item inside the circuit box so we use this to bridge the gap.
|
|
/// </remarks>
|
|
public List<CircuitBoxConnection> CircuitBoxConnections = new();
|
|
|
|
private bool enumeratingWires;
|
|
private readonly HashSet<Wire> removedWires = new HashSet<Wire>();
|
|
|
|
private readonly Item item;
|
|
|
|
public readonly bool IsOutput;
|
|
|
|
public readonly List<StatusEffect> Effects;
|
|
|
|
public readonly List<(ushort wireId, int? connectionIndex)> LoadedWires;
|
|
|
|
//The grid the connection is a part of
|
|
public GridInfo Grid;
|
|
|
|
//Priority in which power output will be handled - load is unaffected
|
|
public PowerPriority Priority = PowerPriority.Default;
|
|
|
|
public Signal LastSentSignal { get; private set; }
|
|
public Signal LastReceivedSignal {get; private set;}
|
|
|
|
public bool IsPower
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
private bool recipientsDirty = true;
|
|
private readonly List<Connection> recipients = new List<Connection>();
|
|
public List<Connection> Recipients
|
|
{
|
|
get
|
|
{
|
|
if (recipientsDirty) { RefreshRecipients(); }
|
|
return recipients;
|
|
}
|
|
}
|
|
|
|
public Item Item
|
|
{
|
|
get { return item; }
|
|
}
|
|
|
|
public ConnectionPanel ConnectionPanel
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return "Connection (" + item.Name + ", " + Name + ")";
|
|
}
|
|
|
|
public Connection(ContentXElement element, int connectionIndex, ConnectionPanel connectionPanel, IdRemap idRemap, bool isItemSwap)
|
|
{
|
|
|
|
#if CLIENT
|
|
if (connector == null)
|
|
{
|
|
connector = GUIStyle.GetComponentStyle("ConnectionPanelConnector").GetDefaultSprite();
|
|
wireVertical = GUIStyle.GetComponentStyle("ConnectionPanelWire").GetDefaultSprite();
|
|
connectionSprite = GUIStyle.GetComponentStyle("ConnectionPanelConnection").GetDefaultSprite();
|
|
connectionSpriteHighlight = GUIStyle.GetComponentStyle("ConnectionPanelConnection").GetSprite(GUIComponent.ComponentState.Hover);
|
|
screwSprites = GUIStyle.GetComponentStyle("ConnectionPanelScrew").Sprites[GUIComponent.ComponentState.None].Select(s => s.Sprite).ToList();
|
|
}
|
|
#endif
|
|
ConnectionPanel = connectionPanel;
|
|
item = connectionPanel.Item;
|
|
|
|
MaxWires = element.GetAttributeInt("maxwires", DefaultMaxWires);
|
|
MaxWires = Math.Max(element.Elements().Count(e => e.Name.ToString().Equals("link", StringComparison.OrdinalIgnoreCase)), MaxWires);
|
|
|
|
MaxPlayerConnectableWires = element.GetAttributeInt("maxplayerconnectablewires", MaxWires);
|
|
wires = new HashSet<Wire>();
|
|
|
|
IsOutput = element.Name.ToString() == "output";
|
|
Name = element.GetAttributeString("name", IsOutput ? "output" : "input");
|
|
|
|
int displayOrder;
|
|
if (element.GetAttribute("displayorderoverride") is not { } displayOrderAttr)
|
|
{
|
|
var sameElements = connectionPanel.Connections.Where(c => c.IsOutput == IsOutput);
|
|
displayOrder = !sameElements.Any() ? 0 : sameElements.Max(static c => c.DisplayOrder) + 1;
|
|
}
|
|
else
|
|
{
|
|
displayOrder = displayOrderAttr.GetAttributeInt(0);
|
|
}
|
|
|
|
DisplayOrder = displayOrder;
|
|
|
|
string displayNameTag = "", fallbackTag = "";
|
|
//if displayname is not present, attempt to find it from the prefab
|
|
if (element.GetAttribute("displayname") == null)
|
|
{
|
|
foreach (var subElement in item.Prefab.ConfigElement.Elements())
|
|
{
|
|
if (!subElement.Name.ToString().Equals("connectionpanel", StringComparison.OrdinalIgnoreCase)) { continue; }
|
|
int prefabConnectionIndex = 0;
|
|
foreach (XElement connectionElement in subElement.Elements())
|
|
{
|
|
string prefabConnectionName = connectionElement.GetAttributeString("name", null);
|
|
if (prefabConnectionName.IsNullOrEmpty()) { continue; }
|
|
|
|
string[] aliases = connectionElement.GetAttributeStringArray("aliases", Array.Empty<string>());
|
|
if (prefabConnectionName == Name || aliases.Contains(Name) ||
|
|
//when swapping items, we move wires based on the order of the connections, not the names
|
|
//= we should find a connection based on the index if the name doesn't match
|
|
(isItemSwap && connectionIndex == prefabConnectionIndex))
|
|
{
|
|
displayNameTag = connectionElement.GetAttributeString("displayname", "");
|
|
fallbackTag = connectionElement.GetAttributeString("fallbackdisplayname", "");
|
|
}
|
|
prefabConnectionIndex++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
displayNameTag = element.GetAttributeString("displayname", "");
|
|
fallbackTag = element.GetAttributeString("fallbackdisplayname", null);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(displayNameTag))
|
|
{
|
|
//extract the tag parts in case the tags contains variables
|
|
string tagWithoutVariables = displayNameTag?.Split('~')?.FirstOrDefault();
|
|
string fallbackTagWithoutVariables = fallbackTag?.Split('~')?.FirstOrDefault();
|
|
//use displayNameTag if found, otherwise fallBack
|
|
if (TextManager.ContainsTag(tagWithoutVariables))
|
|
{
|
|
DisplayName = TextManager.GetServerMessage(displayNameTag);
|
|
}
|
|
else if (TextManager.ContainsTag(fallbackTagWithoutVariables))
|
|
{
|
|
DisplayName = TextManager.GetServerMessage(fallbackTag);
|
|
}
|
|
}
|
|
|
|
if (DisplayName.IsNullOrEmpty())
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError($"Could not find a display name for the connection {Name} in the item {item.Name} (submarine: {item.Submarine?.Info?.Name ?? "none"})");
|
|
#endif
|
|
DisplayName = Name;
|
|
}
|
|
|
|
IsPower = element.GetAttributeBool("ispower", Name is "power_in" or "power" or "power_out");
|
|
|
|
LoadedWires = new List<(ushort wireId, int? connectionIndex)>();
|
|
foreach (var subElement in element.Elements())
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "link":
|
|
int id = subElement.GetAttributeInt("w", 0);
|
|
int? i = null;
|
|
if (subElement.GetAttribute("i") != null)
|
|
{
|
|
i = subElement.GetAttributeInt("i", 0);
|
|
}
|
|
if (id < 0) { id = 0; }
|
|
if (LoadedWires.Count < MaxWires) { LoadedWires.Add((idRemap.GetOffsetId(id), i)); }
|
|
break;
|
|
case "statuseffect":
|
|
Effects ??= new List<StatusEffect>();
|
|
Effects.Add(StatusEffect.Load(subElement, item.Name + ", connection " + Name));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the the connection is connected to a wire or a circuit box connection
|
|
/// </summary>
|
|
public bool IsConnectedToSomething()
|
|
=> wires.Count > 0 || CircuitBoxConnections.Count > 0;
|
|
|
|
public void SetRecipientsDirty()
|
|
{
|
|
recipientsDirty = true;
|
|
if (IsPower) { Powered.MarkConnectionChanged(this); }
|
|
}
|
|
|
|
private void RefreshRecipients()
|
|
{
|
|
recipients.Clear();
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (var wire in wires.ToArray())
|
|
{
|
|
Connection recipient = wire.OtherConnection(this);
|
|
if (recipient != null) { recipients.Add(recipient); }
|
|
}
|
|
recipientsDirty = false;
|
|
}
|
|
|
|
public Wire FindWireByItem(Item it)
|
|
=> Wires.FirstOrDefault(w => w.Item == it);
|
|
|
|
public bool WireSlotsAvailable()
|
|
=> wires.Count < MaxWires;
|
|
|
|
public bool TryAddLink(Wire wire)
|
|
{
|
|
if (wire is null
|
|
|| wires.Contains(wire)
|
|
|| !WireSlotsAvailable())
|
|
{
|
|
return false;
|
|
}
|
|
wires.Add(wire);
|
|
return true;
|
|
}
|
|
|
|
public void DisconnectWire(Wire wire)
|
|
{
|
|
if (wire == null || !wires.Contains(wire)) { return; }
|
|
|
|
var prevOtherConnection = wire.OtherConnection(this);
|
|
if (prevOtherConnection != null)
|
|
{
|
|
//Change the connection grids or flag them for updating
|
|
if (IsPower && prevOtherConnection.IsPower && Grid != null)
|
|
{
|
|
//Check if both connections belong to a larger grid
|
|
if (prevOtherConnection.recipients.Count > 1 && recipients.Count > 1)
|
|
{
|
|
Powered.MarkConnectionChanged(prevOtherConnection);
|
|
Powered.MarkConnectionChanged(this);
|
|
}
|
|
else if (recipients.Count > 1)
|
|
{
|
|
//This wire was the only one at the other grid
|
|
prevOtherConnection.Grid?.RemoveConnection(prevOtherConnection);
|
|
prevOtherConnection.Grid = null;
|
|
}
|
|
else if (prevOtherConnection.recipients.Count > 1)
|
|
{
|
|
Grid?.RemoveConnection(this);
|
|
Grid = null;
|
|
}
|
|
else if (Grid.Connections.Count == 2)
|
|
{
|
|
//Delete the grid as these were the only 2 devices
|
|
Powered.Grids.TryRemove(Grid.ID, out _);
|
|
Grid = null;
|
|
prevOtherConnection.Grid = null;
|
|
}
|
|
}
|
|
prevOtherConnection.recipientsDirty = true;
|
|
}
|
|
if (enumeratingWires)
|
|
{
|
|
removedWires.Add(wire);
|
|
}
|
|
else
|
|
{
|
|
wires.Remove(wire);
|
|
}
|
|
recipientsDirty = true;
|
|
}
|
|
|
|
public void ConnectWire(Wire wire)
|
|
{
|
|
if (wire == null || !TryAddLink(wire)) { return; }
|
|
ConnectionPanel.DisconnectedWires.Remove(wire);
|
|
var otherConnection = wire.OtherConnection(this);
|
|
if (otherConnection != null)
|
|
{
|
|
//Set the other connection grid if a grid exists already
|
|
if (Powered.ValidPowerConnection(this, otherConnection))
|
|
{
|
|
if (Grid == null && otherConnection.Grid != null)
|
|
{
|
|
otherConnection.Grid.AddConnection(this);
|
|
Grid = otherConnection.Grid;
|
|
}
|
|
else if (Grid != null && otherConnection.Grid == null)
|
|
{
|
|
Grid.AddConnection(otherConnection);
|
|
otherConnection.Grid = Grid;
|
|
}
|
|
else
|
|
{
|
|
//Flag change so that proper grids can be formed
|
|
Powered.MarkConnectionChanged(this);
|
|
Powered.MarkConnectionChanged(otherConnection);
|
|
}
|
|
}
|
|
|
|
otherConnection.recipientsDirty = true;
|
|
}
|
|
recipientsDirty = true;
|
|
}
|
|
|
|
public void SendSignal(Signal signal)
|
|
{
|
|
LastSentSignal = signal;
|
|
enumeratingWires = true;
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (var wire in wires.ToArray())
|
|
{
|
|
Connection recipient = wire.OtherConnection(this);
|
|
if (recipient == null) { continue; }
|
|
if (recipient.item == this.item || signal.source?.LastSentSignalRecipients.LastOrDefault() == recipient) { continue; }
|
|
|
|
signal.source?.LastSentSignalRecipients.Add(recipient);
|
|
#if CLIENT
|
|
wire.RegisterSignal(signal, source: this);
|
|
#endif
|
|
SendSignalIntoConnection(signal, recipient);
|
|
}
|
|
|
|
foreach (CircuitBoxConnection connection in CircuitBoxConnections.ToArray())
|
|
{
|
|
connection.ReceiveSignal(signal);
|
|
}
|
|
enumeratingWires = false;
|
|
foreach (var removedWire in removedWires.ToArray())
|
|
{
|
|
wires.Remove(removedWire);
|
|
}
|
|
removedWires.Clear();
|
|
}
|
|
|
|
public static void SendSignalIntoConnection(Signal signal, Connection conn)
|
|
{
|
|
conn.LastReceivedSignal = signal;
|
|
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (ItemComponent ic in conn.item.Components.ToArray())
|
|
{
|
|
ic.ReceiveSignal(signal, conn);
|
|
}
|
|
|
|
if (conn.Effects == null || signal.value == "0") { return; }
|
|
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (StatusEffect effect in conn.Effects.ToArray())
|
|
{
|
|
conn.Item.ApplyStatusEffect(effect, ActionType.OnUse, (float)Timing.Step);
|
|
}
|
|
}
|
|
|
|
public void ClearConnections()
|
|
{
|
|
if (IsPower && Grid != null)
|
|
{
|
|
Powered.MarkConnectionChanged(this);
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (Connection c in recipients.ToArray())
|
|
{
|
|
Powered.MarkConnectionChanged(c);
|
|
}
|
|
}
|
|
// Use ToArray() snapshot for thread-safe iteration
|
|
foreach (var wire in wires.ToArray())
|
|
{
|
|
wire.RemoveConnection(this);
|
|
recipientsDirty = true;
|
|
}
|
|
|
|
if (enumeratingWires)
|
|
{
|
|
foreach (var wire in wires.ToArray())
|
|
{
|
|
removedWires.Add(wire);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wires.Clear();
|
|
}
|
|
}
|
|
|
|
public void InitializeFromLoaded()
|
|
{
|
|
if (LoadedWires.Count == 0) { return; }
|
|
|
|
foreach ((ushort wireId, int? connectionIndex) in LoadedWires)
|
|
{
|
|
if (Entity.FindEntityByID(wireId) is not Item wireItem) { continue; }
|
|
|
|
var wire = wireItem.GetComponent<Wire>();
|
|
if (wire != null && TryAddLink(wire))
|
|
{
|
|
if (wire.Item.body != null) { wire.Item.body.Enabled = false; }
|
|
if (connectionIndex.HasValue)
|
|
{
|
|
wire.Connect(this, connectionIndex.Value, addNode: false, sendNetworkEvent: false);
|
|
}
|
|
else
|
|
{
|
|
wire.TryConnect(this, addNode: false, sendNetworkEvent: false);
|
|
}
|
|
wire.FixNodeEnds();
|
|
recipientsDirty = true;
|
|
}
|
|
}
|
|
LoadedWires.Clear();
|
|
}
|
|
|
|
|
|
public void Save(XElement parentElement)
|
|
{
|
|
XElement newElement = new XElement(IsOutput ? "output" : "input", new XAttribute("name", Name));
|
|
|
|
// Use ToArray() snapshot before OrderBy for thread-safe iteration
|
|
foreach (var wire in wires.ToArray().OrderBy(w => w.Item.ID))
|
|
{
|
|
newElement.Add(new XElement("link",
|
|
new XAttribute("w", wire.Item.ID.ToString()),
|
|
new XAttribute("i", wire.Connections[0] == this ? 0 : 1)));
|
|
}
|
|
|
|
parentElement.Add(newElement);
|
|
}
|
|
}
|
|
}
|