private void HandleCreationOfASingleNewNetwork(ElectricNetworkNode addedNode, List <ElectricNetworkNode> adjacentNodes) { // Check if adjacentNodes all have no network; // If they do, another method about handling addon to network(s) should be called. foreach (ElectricNetworkNode adjacentNode in adjacentNodes) { if (adjacentNode.connectedNetwork != null) { Debug.LogError($"ERROR CREATING NODE: Node {addedNode} should be only one with network, " + $"but Node {adjacentNode} already has network {adjacentNode.connectedNetwork}. "); return; } } ElectricNetwork network = CreateNewElectricNetwork(); ElectricNetworkUtil.Register(network, addedNode); Debug.Log($"INFO CREATING NODE: Node {addedNode} was created with network {network}. "); if (adjacentNodes != null && adjacentNodes.Count > 0) { foreach (ElectricNetworkNode adjacentNode in adjacentNodes) { ElectricNetworkUtil.Register(network, adjacentNode); Debug.Log($"INFO REGISTERING: Node {adjacentNode} was added to network {network}. "); } } SortElectricNetworks(); }
public static bool CheckNodesConnection(ElectricNetworkNode node1, ElectricNetworkNode node2) { bool node1AndNode2AreNotConnectedWithEachOther = !node1.connectedNodes.Contains(node2) && !node2.connectedNodes.Contains(node1); bool node1IsConnectedOneSidedWithNode2 = node1.connectedNodes.Contains(node2) && !node2.connectedNodes.Contains(node1); bool node2IsConnectedOneSidedWithNode1 = node2.connectedNodes.Contains(node1) && !node1.connectedNodes.Contains(node2); if (node1AndNode2AreNotConnectedWithEachOther) { Debug.LogError($"ERROR: Node 1 {node1} and Node 2 {node2} are not connected with each other. "); return(false); } if (node1IsConnectedOneSidedWithNode2) { Debug.LogError($"ERROR: Node 1 {node1} is connected to Node 2 {node2}, but Node 2 is not connected to Node 1. "); return(false); } if (node2IsConnectedOneSidedWithNode1) { Debug.LogError($"ERROR: Node 2 {node2} is connected to Node 1 {node1}, but Node 1 is not connected to Node 2. "); return(false); } return(true); }
public static bool CheckEdgeAndNodesCongruence(ElectricNetworkEdge edge, ElectricNetworkNode node1, ElectricNetworkNode node2) { bool nodesAreConnectedProperly = CheckNodesConnection(node1, node2); bool nodesHaveOneCommonEdge = CheckCommonEdge(node1, node2); return(nodesAreConnectedProperly && nodesHaveOneCommonEdge); }
public static void Disconnect(ElectricNetworkNode node1, ElectricNetworkNode node2) { // Check if both nodes are connected with each other if (!node1.connectedNodes.Contains(node2) && !node2.connectedNodes.Contains(node1)) { Debug.LogError($"ERROR DISCONNECTING: Node 1 {node1} and Node 2 {node2} are not connected with each other. "); } else if (!node1.connectedNodes.Contains(node2)) { Debug.LogError($"ERROR DISCONNECTING: Node 1 {node1} is not connected to Node 2 {node2}. "); } else if (!node2.connectedNodes.Contains(node1)) { Debug.LogError($"ERROR DISCONNECTING: Node 2 {node2} is not connected to Node 1 {node1}. "); } List <ElectricNetworkEdge> commonEdges = node1.connectedEdges.Intersect(node2.connectedEdges).ToList(); if (commonEdges.Count() == 0) { Debug.LogError($"ERROR DISCONNECTING: There is no common edge between Node 1 {node1} and Node 2 {node2}. "); } else if (commonEdges.Count() > 1) { Debug.LogError($"ERROR DISCONNECTING: There are {commonEdges.Count()} edges between Node 1 {node1} and Node 2 {node2}, " + $"but there should be only 1. "); } else { Disconnect(commonEdges[0]); } }
private void HandleAddonToAnExistingNetwork(ElectricNetworkNode addedNode, List <ElectricNetworkNode> adjacentNodes) { ElectricNetwork network = adjacentNodes[0].connectedNetwork; ElectricNetworkUtil.Register(network, addedNode); SortElectricNetworks(); Debug.Log($"INFO: Node {addedNode} was added to network {network}. "); }
/* * This method should not be called each Update, rather only on changes. */ public void AddPreviewNode(ElectricNetworkNode previewNode, List <ElectricNetworkNode> interactedNodes) { foreach (ElectricNetworkNode interactedNode in interactedNodes) { ElectricNetworkUtil.ConnectPreview(previewNode, interactedNode, previewNetwork); } CreateCablesForNetwork(previewNetwork); }
// Unlike the other Connect method, this one is used to create a preview edge. This preview edge is shown, when // hovering a building, so the according cables are displayed. The preview edge is only added to the previewNetwork. public static void ConnectPreview(ElectricNetworkNode node1, ElectricNetworkNode node2, ElectricNetwork previewNetwork) { // Create preview edge between node1 and node2 ElectricNetworkEdge previewEdge = new ElectricNetworkEdge(node1, node2); previewEdge.type = ElectricNetworkEdge.Type.Preview; // Register edge in previewNetwork and vice versa Register(previewNetwork, previewEdge); }
public static void Unregister(ElectricNetwork network, ElectricNetworkNode node) { if (!network.nodes.Contains(node)) { Debug.LogError($"ERROR UNREGISTERING: Network \"{network}\" does not contain Node \"{node}\". "); } network.nodes.Remove(node); if (node.connectedNetwork != network) { Debug.LogError($"ERROR UNREGISTERING: Node \"{node}\" was not connected to Network \"{network}\" in the first place. "); } node.connectedNetwork = null; }
/* * There are actually two lists with traveresed nodes in this NetworkResolver: * 1) traversedNodes represents all nodes that have been passed through the traversal * 2) nodesInThisNetwork represents a subset of all traversed nodes, namely only those that are connected with each other (--> network) */ private ElectricNetworkSeed TraverseNodesInQueueAndResolveAsNetwork(Queue <ElectricNetworkNode> nodeQueue) { List <ElectricNetworkNode> nodesInThisNetwork = new List <ElectricNetworkNode>(); List <ElectricNetworkEdge> edgesInThisNetwork = new List <ElectricNetworkEdge>(); ElectricNetworkSeed resolvedNetworkSeed = new ElectricNetworkSeed(); while (nodeQueue.Count > 0) { ElectricNetworkNode nodeOnTop = nodeQueue.Peek(); // Add each connected node to the network (plus the corresponding edge) foreach (ElectricNetworkNode connectedNode in nodeOnTop.connectedNodes) { // If the resolver already visited this node, continue if (traversedNodes.Contains(connectedNode)) { continue; } // Add connected Node to queue nodeQueue.Enqueue(connectedNode); // Add node to traversed nodes (as soon as they are in queue, they count as traversed/visited) traversedNodes.Add(connectedNode); // Get edge between two nodes ElectricNetworkEdge commonEdge = ElectricNetworkUtil.GetCommonEdge(nodeOnTop, connectedNode); if (commonEdge == null) { Debug.LogError($"ERROR RESOLVING NETWORKS: " + $"There is no common edge between Node 1 {nodeOnTop} and Node 2 {connectedNode}. "); } edgesInThisNetwork.Add(commonEdge); } // Add traversed node to all 1) visited nodes and 2) nodes for network traversedNodes.Add(nodeOnTop); nodesInThisNetwork.Add(nodeOnTop); // Remove top node from queue nodeQueue.Dequeue(); } // Return resolved network resolvedNetworkSeed.nodes = nodesInThisNetwork; resolvedNetworkSeed.edges = edgesInThisNetwork; return(resolvedNetworkSeed); }
public static bool CheckCommonEdge(ElectricNetworkNode node1, ElectricNetworkNode node2) { List <ElectricNetworkEdge> commonEdges = node1.connectedEdges.Intersect(node2.connectedEdges).ToList(); if (commonEdges.Count == 0) { Debug.LogError($"ERROR: There is no common edge between Node 1 {node1} and Node 2 {node2}. "); return(false); } if (commonEdges.Count > 1) { Debug.LogError($"ERROR: There is more than 1 edge ({commonEdges.Count}) between Node 1 {node1} and Node 2 {node2}. "); return(false); } return(true); }
// Effectively destroys the edge public static void Disconnect(ElectricNetworkEdge edge) { // Disconnect nodes from each other ElectricNetworkNode node1 = edge.nodes.Item1; ElectricNetworkNode node2 = edge.nodes.Item2; node1.connectedNodes.Remove(node2); node2.connectedNodes.Remove(node1); // "Destroy" edge between nodes edge.nodes.Item1.connectedEdges.Remove(edge); edge.nodes.Item2.connectedEdges.Remove(edge); // Unregister edge from network Unregister(edge.connectedNetwork, edge); }
// Method is called "Register" and not "Connect" to distinguish between creating a connection between two nodes // and registering a given node or edge in a eletric network. public static void Register(ElectricNetwork network, ElectricNetworkNode node) { // Normally, these two error messages should always come at the same time. // But of course, it is possible that the connection is only one sided because of some error. if (network.nodes.Contains(node)) { Debug.LogError($"ERROR REGISTERING: Network \"{network}\" already contains Node \"{node}\". "); } network.nodes.Add(node); if (node.connectedNetwork == network) { Debug.LogError($"ERROR REGISTERING: Node \"{node}\" is already linked to Network \"{network}\". "); } node.connectedNetwork = network; }
public void AddNode(ElectricNetworkNode addedNode, List <ElectricNetworkNode> interactedNodes) { int numberOfInvolvedNetworksInConnectionAttempt = ElectricNetworkUtil.GetDifferentNetworksOf(interactedNodes.ToArray()).Length; // Debug info if (GameManager.Instance.isDebugging) { for (int i = 0; i < interactedNodes.Count(); i++) { Debug.Log($"INFO NETWORK ADDON: Interacted Node {i}: {interactedNodes[i]}. "); } } // Handle addon to network if (numberOfInvolvedNetworksInConnectionAttempt == 0) { // Interacted Nodes are passed as parameter, because there can be a connection attempt with // interacted/adjacent nodes, that have connectedNetwork = null. HandleCreationOfASingleNewNetwork(addedNode, interactedNodes); } else if (numberOfInvolvedNetworksInConnectionAttempt == 1) { HandleAddonToAnExistingNetwork(addedNode, interactedNodes); } else if (numberOfInvolvedNetworksInConnectionAttempt > 1) { HandleAddonToMultipleExistingNetworks(addedNode, interactedNodes); } else { Debug.LogError($"ERROR NETWORK ADDON: There is an illegal number of involved networks " + $"({numberOfInvolvedNetworksInConnectionAttempt}) when trying to add a new node. "); } // Connect nodes with each other and create edges foreach (ElectricNetworkNode interactedNode in interactedNodes) { ElectricNetworkUtil.Connect(addedNode, interactedNode); } // Create cables between power poles, if they are missing CreateAllCables(); }
private void HandleAddonToMultipleExistingNetworks(ElectricNetworkNode addedNode, List <ElectricNetworkNode> adjacentNodes) { ElectricNetwork[] existingNetworks = ElectricNetworkUtil.GetDifferentNetworksOf(adjacentNodes.ToArray()); existingNetworks = ElectricNetwork.SortBySize(existingNetworks); ElectricNetwork biggestNetwork = existingNetworks[0]; // Integrate smaller networks into the biggest one foreach (ElectricNetwork disintegratedNetwork in existingNetworks) { if (disintegratedNetwork == biggestNetwork) { continue; } IntegrateElectricNetworkIntoAnother(biggestNetwork, disintegratedNetwork); } // Register added node into biggest network all other networks get integrated into ElectricNetworkUtil.Register(biggestNetwork, addedNode); SortElectricNetworks(); }
//TODO: Iterate over electric network and create cable objects for each edge public static void Connect(ElectricNetworkNode node1, ElectricNetworkNode node2) { // Connect nodes with each other node1.connectedNodes.Add(node2); node2.connectedNodes.Add(node1); // Create edge between node1 and node2 ElectricNetworkEdge edge = new ElectricNetworkEdge(node1, node2); // Add edge to nodes node1.connectedEdges.Add(edge); node2.connectedEdges.Add(edge); // Check if both nodes have the same network if (node1.connectedNetwork != node2.connectedNetwork) { Debug.LogError($"ERROR CONNECTING: Node 1 and Node 2 have a different network. " + $"Node 1: {node1} - {node1.connectedNetwork}; Node 2: {node2} - {node2.connectedNetwork}. "); } // Register edge in network and vice versa Register(node1.connectedNetwork, edge); }
public void DestroyNode(ElectricNetworkNode node) { ElectricNetwork networkOfDestroyedNode = node.connectedNetwork; // Could throw error, when "node.connectedNodes = null" and then "adjacentNodes[0]"? List <ElectricNetworkNode> adjacentNodes = new List <ElectricNetworkNode>(node.connectedNodes); // Unregister from network ElectricNetworkUtil.Unregister(node.connectedNetwork, node); // If no nodes are connected, destroy the network (the destroyed node was the last one in the network) if (node.connectedNodes.Count() == 0 && node.connectedEdges.Count() == 0) { if (ElectricNetworkUtil.CheckIfNetworkIsEmpty(networkOfDestroyedNode)) { DestroyElectricNetwork(networkOfDestroyedNode); } else { Debug.LogError($"ERROR DELETING NODE: Network {networkOfDestroyedNode} is not empty, but it should be. " + $"On Removal, there were no adjacent nodes, so Node {node} must be the only member. "); } return; } // Destroy cables and disconnect edges List <ElectricNetworkEdge> connectedEdges = new List <ElectricNetworkEdge>(node.connectedEdges); foreach (ElectricNetworkEdge edge in connectedEdges) { Destroy(edge.cable.gameObject); ElectricNetworkUtil.Disconnect(edge); } // Handle adjacent nodes HandleAdjacentNodesAfterNodeRemoval(adjacentNodes); }
private void Awake() { node = new ElectricNetworkNode(this); }
public ElectricNetworkEdge(ElectricNetworkNode node1, ElectricNetworkNode node2) { nodes = new Tuple <ElectricNetworkNode, ElectricNetworkNode>(node1, node2); }