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);
}
