Hightlighting cluster perimeter components

CriticalPathAnalyzer/CriticalPathAnalyzer/src/client/tool/PathHighLighter.cs

@@ -9,56 +9,72 @@ using LogicWorld.Outlines;
 namespace CriticalPathAnalyzer.Client.Tool {
     public class PathHighLighter {
         private static readonly OutlineData Color = new OutlineData(new Color24(0xff0000));
-        
+        private static readonly OutlineData PerimeterColor = new OutlineData(new Color24(0xffff00));
+
         private static List<ClusterDetails> _clusters = new List<ClusterDetails>();
+        private static List<ComponentAddress> _highlightedComponents = new List<ComponentAddress>();
         private static List<WireAddress> _highlightedWires = new List<WireAddress>();
 
         public static void HighlightWires(AnalyzePathResponse response) {
             _clusters = response.Clusters;
 
+            foreach (ClusterDetails clusterDetails in _clusters) {
+                HighlightCluster(clusterDetails);
+            }
+            
             IWorldData world = Instances.MainWorld.Data;
+            
+            foreach (ComponentAddress componentAddress in response.PerimeterComponents) {
+                if (!world.Contains(componentAddress)) {
+                    continue;
+                }
 
+                Outliner.Outline(componentAddress, PerimeterColor);
+                _highlightedComponents.Add(componentAddress);
+            }
+        }
 
-            foreach (ClusterDetails clusterDetails in _clusters) {
+        private static void HighlightCluster(ClusterDetails cluster) {
-                foreach (ComponentAddress address in clusterDetails.ConnectingComponents) {
+            IWorldData world = Instances.MainWorld.Data;
-                    if (!world.Contains(address)) {
-                        continue;
-                    }
 
-                    Outliner.Outline(address, Color);
+            foreach (ComponentAddress address in cluster.ConnectingComponents) {
+                if (!world.Contains(address)) {
+                    continue;
                 }
 
-                foreach (ComponentAddress address in clusterDetails.LinkingComponents) {
+                Outliner.Outline(address, Color);
-                    if (!world.Contains(address)) {
+            }
-                        continue;
-                    }
 
-                    Outliner.Outline(address, Color);
+            foreach (ComponentAddress address in cluster.LinkingComponents) {
+                if (!world.Contains(address)) {
+                    continue;
                 }
 
-                foreach (PegAddress pegAddress in clusterDetails.Pegs) {
+                Outliner.Outline(address, Color);
-                    if (!world.Contains(pegAddress.ComponentAddress)) {
+            }
-                        continue;
+
-                    }
+            foreach (PegAddress pegAddress in cluster.Pegs) {
+                if (!world.Contains(pegAddress.ComponentAddress)) {
+                    continue;
+                }
+
+                Outliner.Outline(pegAddress, Color);
 
-                    Outliner.Outline(pegAddress, Color);
+                HashSet<WireAddress> wires = Instances.MainWorld.Data.LookupPegWires(pegAddress);
+                if (wires == null) {
+                    continue;
+                }
 
-                    HashSet<WireAddress> wires = Instances.MainWorld.Data.LookupPegWires(pegAddress);
+                foreach (WireAddress wireAddress in wires) {
-                    if (wires == null) {
+                    Wire wire = Instances.MainWorld.Data.Lookup(wireAddress);
-                        continue;
+                    if (wire == null) {
+                        return;
                     }
 
-                    foreach (WireAddress wireAddress in wires) {
+                    // We do not collect wires from output pegs. So if the first is an output peg, the other side must be an input -> collect.
-                        Wire wire = Instances.MainWorld.Data.Lookup(wireAddress);
+                    if (wire.Point1 == pegAddress || !wire.Point1.IsInputAddress()) {
-                        if (wire == null) {
+                        _highlightedWires.Add(wireAddress);
-                            return;
+                        Outliner.Outline(wireAddress, Color);
-                        }
-
-                        // We do not collect wires from output pegs. So if the first is an output peg, the other side must be an input -> collect.
-                        if (wire.Point1 == pegAddress || !wire.Point1.IsInputAddress()) {
-                            _highlightedWires.Add(wireAddress);
-                            Outliner.Outline(wireAddress, Color);
-                        }
                     }
                 }
             }
@@ -69,6 +85,7 @@ namespace CriticalPathAnalyzer.Client.Tool {
                 CriticalPathAnalyzerClient.LoggerInstance.Warn("Ignoring remove highlighting, clusters is null");
                 return;
             }
+
             foreach (ClusterDetails cluster in _clusters) {
                 UnhighlightCluster(cluster);
             }
@@ -76,9 +93,14 @@ namespace CriticalPathAnalyzer.Client.Tool {
             foreach (WireAddress wireAddress in _highlightedWires) {
                 Outliner.RemoveOutline(wireAddress);
             }
+            
+            foreach (ComponentAddress componentAddress in _highlightedComponents) {
+                Outliner.RemoveOutline(componentAddress);
+            }
 
             _clusters = null;
             _highlightedWires.Clear();
+            _highlightedComponents.Clear();
         }
 
         private static void UnhighlightCluster(ClusterDetails cluster) {

CriticalPathAnalyzer/CriticalPathAnalyzer/src/server/ServerPathTracer.cs

@@ -54,27 +54,43 @@ namespace CriticalPathAnalyzer.Server {
             // An input peg, only has a single cluster.
             // An output peg however can be connected to multiple clusters.
             // It only makes sense to then select all these clusters as primary cluster.
-            if (!CollectMainClusters(start, out HashSet<Cluster> primaryClusters)) {
+            if (!CollectMainClusters(start, out HashSet<Cluster> collectedClusters)) {
                 return false; // Whoops, cannot collect the primary clusters, probably probing an output peg.
             }
+            
+            CriticalPathAnalyzerServer.LoggerInstance.Info("collected main clusters");
 
             // Collect clusters that get powered by the original cluster by fast buffers
             var collectedDrains = new HashSet<Cluster>();
-            foreach (Cluster cluster in primaryClusters) {
+            foreach (Cluster cluster in collectedClusters) {
-                CollectClusters(cluster, collectedDrains, GetFollowers);
+                GetLinkedClusters(cluster, collectedDrains, GetFollowers);
             }
-
+            
-            foreach (Cluster cluster in primaryClusters) {
+            collectedClusters.UnionWith(collectedDrains);
-                collectedDrains.Remove(cluster);
+            
+            CriticalPathAnalyzerServer.LoggerInstance.Info("collected linked clusters");
+
+            var perimeterComponents = new HashSet<ComponentAddress>();
+            foreach (Cluster cluster in collectedClusters) {
+                foreach (InputPeg inputPeg in cluster.ConnectedInputs) {
+                    if (inputPeg.LogicComponent == null) {
+                        // These are regular pegs, they are not attached to any logic component, skip them
+                        continue;
+                    }
+                    perimeterComponents.Add(inputPeg.LogicComponent.Address);
+                }
             }
 
-            //Collect information about each cluster:
+            CriticalPathAnalyzerServer.LoggerInstance.Info("collected perimeter components");
+            
+            // Collect information about each cluster:
             response = new AnalyzePathResponse() {
                 RequestGuid = requestGuid,
-                Clusters = new List<ClusterDetails>(),
+                Clusters = collectedClusters.Select(CollectClusterInformation).ToList(),
+                PerimeterComponents = perimeterComponents.ToList()
             };
-            response.Clusters.AddRange(primaryClusters.Select(CollectClusterInformation));
+            
-            response.Clusters.AddRange(collectedDrains.Select(CollectClusterInformation));
+            CriticalPathAnalyzerServer.LoggerInstance.Info("Trace end");
 
             return true;
         }
@@ -141,7 +157,7 @@ namespace CriticalPathAnalyzer.Server {
             return true;
         }
 
-        private static void CollectClusters(
+        private static void GetLinkedClusters(
             Cluster startingPoint,
             HashSet<Cluster> collectedClusters,
             Func<ClusterLinker, List<ClusterLinker>> linkedLinkerGetter

CriticalPathAnalyzer/CriticalPathAnalyzer/src/shared/packets/s2c/AnalyzePathResponse.cs

@@ -9,6 +9,7 @@ namespace CriticalPathAnalyzer.Shared.Packets.S2C {
     public class AnalyzePathResponse : Packet {
         [Key(0)] public Guid RequestGuid;
         [Key(1)] public List<ClusterDetails> Clusters;
+        [Key(2)] public List<ComponentAddress> PerimeterComponents;
     }
 
     [MessagePackObject]