public static LinkedListNode <int> Flatten(MultiNode head)
{
if (head == null)
{
return(null);
}
Queue <MultiNode> q = new Queue <MultiNode>();
LinkedList <int> result = new LinkedList <int>();
q.Enqueue(head);
while (q.Count > 0)
{
MultiNode temp = q.Dequeue();
result.AddLast(temp.Data);
if (temp.Down != null)
{
q.Enqueue(temp.Down);
}
if (temp.Right != null)
{
q.Enqueue(temp.Right);
}
}
return(result.First);
}
static void findWordLadder(HashSet <string> dict, string start, string target)
{
MultiNode node = new MultiNode(start);
buildTree(dict, start, node, "");
getHeights(node);
MultiNode temp = new MultiNode(string.Empty);
while (node.Children.Count != 0)
{
int minHeight = 9999999;
Console.Write(node.Value + " ");
for (int i = 0; i < node.Children.Count; i++)
{
if (node.Children[i].Height <= minHeight)
{
minHeight = node.Children[i].Height;
temp = node.Children[i];
}
}
node = temp;
}
}
static void Main(string[] args)
{
MultiNode head = new MultiNode(5);
MultiNode list1 = new MultiNode(1);
MultiNode sub = new MultiNode();
sub.Right = new MultiNode(10);
MultiNode list1Sub = new MultiNode(12);
list1Sub.Right = sub;
list1Sub.Down = new MultiNode(3);
list1.Down = list1Sub;
list1.Right = new MultiNode(4);
head.Right = list1;
LinkedListNode <int> test = Flatten(head);
var flattened = FlattenAlt(head);
Console.ReadLine();
}
//TODO use NodeType to categorize Types.
public static BaseNode CreateNode(ActionNodeData aData)
{
if (aData.NodeType == null)
{
Debug.LogError("Type not set");
return(null);
}
aData.GUID = string.IsNullOrEmpty(aData.GUID) ? Guid.NewGuid().ToString() : aData.GUID;
aData.OutputPortIDs = aData.OutputPortIDs ?? new List <string>();
//The copy prevent the node to modify the list in the ActionNodeData
List <string> copy = new List <string>();
foreach (var outputPort in aData.OutputPortIDs)
{
copy.Add(outputPort);
}
BaseNode node;
Type type = Type.GetType(aData.NodeType);
if (type == typeof(ChangeSceneNode))
{
node = ChangeSceneNode.Create("Change Scene", aData.Position, aData.GUID, copy);
}
else if (type == typeof(StartNode))
{
node = StartNode.Create("Start Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(ConditionalNode))
{
node = ConditionalNode.Create("Conditional", aData.Position, aData.GUID, copy);
}
else if (type == typeof(MultiNode))
{
node = MultiNode.Create("Multi Output", aData.Position, aData.GUID, copy);
}
else if (type == typeof(ExitNode))
{
node = ExitNode.Create("Exit Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(RandomNode))
{
node = RandomNode.Create("Random Node", aData.Position, aData.GUID, copy);
}
else if (type == typeof(TakeObjectNode))
{
node = TakeObjectNode.Create("Take Object", aData.Position, aData.GUID, copy);
}
else
{
throw new NotImplementedException($"Node type {type} not handled in NodeFactory");
}
node?.SetSerializedScript(aData.SerializedScript);
return(node);
}
public Graph gen_test()
{
ret = new Graph();
ret.bbs_after = new List <List <int> >(new List <int> [13]);
ret.bbs_before = new List <List <int> >(new List <int> [13]);
ret.bb_starts = new List <BaseNode>(new BaseNode[13]);
ret.bb_ends = new List <BaseNode>(new BaseNode[13]);
n = new MultiNode[13];
for (int i = 0; i < 13; i++)
{
n[i] = new MultiNode();
n[i].bb = i;
ret.bb_starts[i] = n[i];
ret.bb_ends[i] = n[i];
ret.bbs_after[i] = new List <int>();
ret.bbs_before[i] = new List <int>();
ret.blocks.Add(new List <BaseNode> {
n[i]
});
}
AddEdge(1, 2);
AddEdge(2, 3);
AddEdge(3, 3);
AddEdge(3, 4);
AddEdge(4, 13);
AddEdge(1, 5);
AddEdge(5, 6);
AddEdge(6, 4);
AddEdge(6, 8);
AddEdge(8, 13);
AddEdge(8, 5);
AddEdge(5, 7);
AddEdge(7, 8);
AddEdge(7, 12);
AddEdge(1, 9);
AddEdge(9, 10);
AddEdge(10, 12);
AddEdge(12, 13);
AddEdge(9, 11);
AddEdge(11, 12);
ret.Starts.Add(n[0]);
return(ret);
}
static void buildTree(HashSet <string> dict, string currentWord, MultiNode root, string prevWord)
{
HashSet <string> visited = new HashSet <string>();
foreach (string w in dict)
{
if (isAdjascent(currentWord, w) && prevWord != w)
{
MultiNode tempNode = new MultiNode(w);
root.Children.Add(tempNode);
visited.Add(w);
buildTree(dict, w, tempNode, currentWord);
}
}
}
private static void AddToLast(MultiNode node, MultiNode head)
{
if (head == null)
{
head = node;
}
MultiNode curr = head;
while (curr.Right != null)
{
curr = curr.Right;
}
curr.Right = node;
}
public static MultiNode FlattenAlt(MultiNode head)
{
if (head == null)
{
return(null);
}
Queue <MultiNode> q = new Queue <MultiNode>();
MultiNode resultHead = null;
MultiNode currResult = null;
q.Enqueue(head);
while (q.Count > 0)
{
MultiNode current = q.Dequeue();
if (current.Right != null)
{
q.Enqueue(current.Right);
}
if (current.Down != null)
{
q.Enqueue(current.Down);
}
current.Right = null;
current.Down = null;
if (resultHead == null)
{
resultHead = current;
currResult = resultHead;
}
currResult.Right = current;
currResult = currResult.Right;
//else
// AddToLast(current, resultHead);
}
return(resultHead);
}
static int getHeights(MultiNode n)
{
if (n.Children.Count == 0)
{
return(1);
}
else
{
int maxHeight = 0;
foreach (var t in n.Children)
{
int height = getHeights(t);
if (height > maxHeight)
{
maxHeight = height;
}
}
n.Height = maxHeight + 1;
return(n.Height);
}
}
private bool ValidateRuleData()
{
if (string.IsNullOrWhiteSpace(txtID.Text))
{
pnlInfo.Visible = true;
lblInfo.Text = "ID cannot be blank";
return(false);
}
if (string.IsNullOrWhiteSpace(txtName.Text))
{
pnlInfo.Visible = true;
lblInfo.Text = "Name cannot be blank";
return(false);
}
if (string.IsNullOrWhiteSpace(Expression))
{
Root = new MultiNode();
Root.AddNode(new CriteriaNode());
pnlInfo.Visible = false;
}
pnlInfo.Visible = false;
return(true);
}
void OnEnable()
{
mn = target as MultiNode;
mn.GetChildNodes();
}
