Pixel Crushers Forum

Code: Select all

if(vertically){}

Code: Select all

currentConversation.dialogueEntries[0].canvasRect = new Rect(2500, 1 * (canvasRectHeight + 24), canvasRectWidth, canvasRectHeight);

HandleChildren(currentConversation.dialogueEntries[0].outgoingLinks, currentConversation.dialogueEntries[0], 2);
nodeGridDict.Clear();
handledNodes.Clear();

Code: Select all

Dictionary<(int x, int y), DialogueEntry> nodeGridDict = new();
List<DialogueEntry> handledNodes = new();
private void HandleChildren(List<Link> links, DialogueEntry parent, int layer, int startX = 8, List<(int x, int y)> parentLocations = null)
{
	Rect leftMost = new Rect();
	Rect rightMost = new Rect();
	int leftIndex = 0;
	int rightIndex = 0;
	
	for (int i = 0; i < links.Count; i++)
	{
		DialogueEntry child = currentConversation.dialogueEntries.Find(x => x.id == links[i].destinationDialogueID);
		if(child == null || handledNodes.Contains(child))
		{
			continue;
		}

		while (nodeGridDict.ContainsKey((i + startX, layer)))
		{
			startX++;
		}

		int xIndex = i + startX;
		
		nodeGridDict[(xIndex,layer)] = child;
		handledNodes.Add(child);

		child.canvasRect = new Rect((xIndex * (canvasRectWidth+10)), layer * (canvasRectHeight + 24), canvasRectWidth, canvasRectHeight);

		if (child.outgoingLinks.Count > 0)
		{
			if(child.outgoingLinks.Count == 1)
			{
				if(parentLocations == null)
				{
					parentLocations = new();
				}
				parentLocations.Add((xIndex, layer));
				HandleChildren(child.outgoingLinks, child, layer + 1, xIndex, parentLocations);
			}
			else
			{
				int childIndexStart = xIndex - (child.outgoingLinks.Count / 2);

				if (parentLocations != null)
				{
					//Fill gaps above single stacks with branches below
					foreach(var location in parentLocations)
					{
						// Move parents in line with child, hypothetically
						if (nodeGridDict.ContainsKey(location))
						{
							DialogueEntry value = nodeGridDict[location];
							if (value != null)
							{
								value.canvasRect.x = (xIndex * (canvasRectWidth + 10));
							}
							nodeGridDict[(xIndex, location.y)] = value;
							nodeGridDict.Remove(location);
						}

						for (int j = 0; j < child.outgoingLinks.Count; j++)
						{
							nodeGridDict[(childIndexStart + j, location.y)] = null;
						}
					}
				}
				HandleChildren(child.outgoingLinks, child, layer + 1, childIndexStart);
			}
		}
		
		if(i == 0)
		{
			leftMost = child.canvasRect;
			leftIndex = xIndex;
		}
		rightMost = child.canvasRect;
		rightIndex = xIndex;

	}
	parent.canvasRect.x = ((leftIndex + rightIndex) * 0.5f) * (canvasRectWidth+10);
}

Code: Select all

if(vertically){}

Code: Select all

CalculatePositions(currentConversation.dialogueEntries[0], 0, 0);
visited.Clear();
subtreeVisited.Clear();
subTreeWidths.Clear();

Code: Select all

private float HorizontalSpacing => canvasRectWidth * 0.3f; // The horizontal spacing between nodes
private float VerticalSpacing => canvasRectHeight + 24; // The vertical spacing between nodes

private HashSet<DialogueEntry> visited = new();
private HashSet<DialogueEntry> subtreeVisited = new();
private Dictionary<DialogueEntry, float> subTreeWidths = new();
// Calculate the positions of all nodes recursively
private void CalculatePositions(DialogueEntry node, int level, float offset)
{
	if (node == null) return;

	// If the node has been visited before, return
	if (visited.Contains(node)) return;

	// Mark the node as visited
	visited.Add(node);

	// Calculate the width of the subtree rooted at this node
	float subtreeWidth = GetSubtreeWidth(node);

	node.canvasRect = new Rect(0, 0, canvasRectWidth, canvasRectHeight);
	// Set the X position of this node to be the center of its subtree
	node.canvasRect.x = offset + subtreeWidth / 2;

	// Set the Y position of this node to be based on its level
	node.canvasRect.y = level * (canvasRectHeight + VerticalSpacing) + 50;
	// Recursively calculate the positions of the child nodes
	float childOffset = offset;
	foreach (Link childLink in node.outgoingLinks)
	{
		if(childLink.destinationConversationID != currentConversation.id)
		{
			continue;
		}
		DialogueEntry child = currentConversation.GetDialogueEntry(childLink.destinationDialogueID);
		CalculatePositions(child, level + 1, childOffset);
		childOffset += GetSubtreeWidth(child) + HorizontalSpacing;
	}
}

// Calculate the width of the subtree rooted at a node
private float GetSubtreeWidth(DialogueEntry node)
{
	if (node == null) return 0;

	// If the node has no children, return its own width
	if (node.outgoingLinks.Count == 0) return canvasRectWidth;

	// Check if we've been to this subtree before so we don't infinite loop
	if (subtreeVisited.Contains(node))
	{
		if (subTreeWidths.ContainsKey(node))
		{
			return subTreeWidths[node];
		}
		else
		{
			return canvasRectWidth;
		}
	}

	subtreeVisited.Add(node);
	// Otherwise, return the sum of the widths of its children and the spacings between them
	float width = 0;
	foreach (Link childLink in node.outgoingLinks)
	{
		if(childLink.destinationConversationID != currentConversation.id)
		{
			continue;
		}
		DialogueEntry child = currentConversation.GetDialogueEntry(childLink.destinationDialogueID);
		if (!subtreeVisited.Contains(child))
                {
                    width += GetSubtreeWidth(child) + HorizontalSpacing;
                }
	}
	width -= HorizontalSpacing; // Subtract the extra spacing at the end

	// Return the maximum of the node's own width and its children's width
	subTreeWidths[node] = Mathf.Max(width, canvasRectWidth);
	return subTreeWidths[node];
}