/// <summary> /// Registers the specified comp. /// </summary> /// <param name="comp">The comp.</param> /// <exception cref="ArgumentNullException">comp</exception> public virtual void Register([NotNull] SlurryNetComp comp) { if (comp == null) { throw new ArgumentNullException(nameof(comp)); } _connectors.Add(comp); if (comp is ISlurryNetTrader trader) { _traders.Add(trader); } if (comp is ISlurryNetStorage storage) { _storage.Add(storage); } comp.Network = this; foreach (IntVec3 intVec3 in comp.parent.OccupiedRect().Cells) { _disjointSet.Set(intVec3, true); } #if DEBUG _drawer.SetDirty(); #endif }
public static IEnumerable <SlurryNetComp> GetAdjacentSlurryComps([NotNull] this SlurryNetComp comp) { if (comp == null) { throw new ArgumentNullException(nameof(comp)); } foreach (IntVec3 intVec3 in comp.parent.CellsAdjacent8WayAndInside()) { if (comp.parent.Map == null) { continue; } var l = intVec3.GetThingList(comp.parent.Map); if (l == null) { continue; } foreach (Thing thing in l) { if (thing == comp.parent) { continue; } var c = thing?.TryGetComp <SlurryNetComp>(); if (c == null) { continue; } yield return(c); } } }
/// <summary> /// Notifies this instance that the connector was destroyed. /// </summary> /// <param name="comp">The comp.</param> /// <exception cref="ArgumentNullException">comp</exception> public void NotifyConnectorDestroyed([NotNull] SlurryNetComp comp) { if (comp == null) { throw new ArgumentNullException(nameof(comp)); } if (comp.Network == null) { return; } DestroyNet(comp.Network); CreateSlurryNets(comp.GetAdjacentSlurryComps()); }
private SlurryNet CreateSlurryNetFrom([NotNull] SlurryNetComp root, [CanBeNull] HashSet <SlurryNetComp> seen) { if (root == null) { throw new ArgumentNullException(nameof(root)); } seen = seen ?? new HashSet <SlurryNetComp>(); var queue = new Queue <SlurryNetComp>(); var network = new HashSet <SlurryNetComp>(); if (!root.TransmitsNow) { seen.Add(root); return(new SlurryNet(map, root)); } // basic flood fill. Start somewhere, put all neighbours on a queue, // continue until there are no more neighbours. queue.Enqueue(root); seen.Add(root); while (queue.Count > 0) { SlurryNetComp cur = queue.Dequeue(); // sanity check; is this already in a network? if (cur.Network != null) { Log.Error($"trying to add {cur.parent.Label} to a new network while it still has a network"); } network.Add(cur); // check neighbours, add to queue if eligible foreach (SlurryNetComp neighbour in cur.GetAdjacentSlurryComps()) { if (!seen.Contains(neighbour)) { seen.Add(neighbour); if (!neighbour.TransmitsNow) { continue; } queue.Enqueue(neighbour); } } } return(new SlurryNet(map, network)); }
/// <summary> /// notifies this instance that a connector was added /// </summary> /// <param name="comp">The comp.</param> /// <exception cref="ArgumentNullException">comp</exception> public void NotifyConnectorAdded([NotNull] SlurryNetComp comp) { if (comp == null) { throw new ArgumentNullException(nameof(comp)); } DebugLogUtils.LogMsg(LogLevel.Messages, $"adding connector for '{comp.parent.Label}'"); if (comp.Network != null || Nets.Any(n => n.Connectors.Contains(comp))) { Log.Error($"adding slurry comp {comp.parent.Label} which is already part of a network"); return; } List <SlurryNet> neighbors = comp.GetAdjacentSlurryComps() .Select(n => n.Network) .Where(n => n != null) .Distinct() .ToList(); if (neighbors.Count == 1) { neighbors[0].Register(comp); } else { foreach (SlurryNet slurryNet in neighbors) { DestroyNet(slurryNet); } SlurryNet net = CreateSlurryNetFrom(comp, null); _nets.Add(net); } }
/// <summary> /// Initializes a new instance of the <see cref="SlurryNet"/> class. /// </summary> /// <param name="map">The map.</param> /// <param name="netComp">The net comp.</param> public SlurryNet([NotNull] Map map, [NotNull] SlurryNetComp netComp) : this(map, new [] { netComp }) { }