private IEnumerable <Node> EmitNodes(NodeType type, string name = null, string value = null, bool fallback = false, bool imaginary = false) { if (scope.Imaginary) { scope.Imaginary = false; if (type == NodeType.Value) { scope.Discarded = true; } else if (type == NodeType.Value || type.HasFlag(NodeType.End)) { scope.Discarded = true; yield return(new Node(NodeType.Value, null)); } else { yield return(new Node(scope.Type | NodeType.Start, scope.Name)); } } if (type.HasFlag(NodeType.Start)) { scope = new Scope { Parent = scope, Name = name ?? reader.Name, Type = type & ~NodeType.Start, Imaginary = imaginary, Fallback = fallback }; if (!scope.Imaginary) { yield return(new Node(scope.Type | NodeType.Start, scope.Name)); } } else if (type.HasFlag(NodeType.End)) { if (!scope.Discarded) { yield return(new Node(type)); } scope = scope.Parent; while (scope.Fallback) { yield return(new Node(scope.Type | NodeType.End)); scope = scope.Parent; } } else { yield return(new Node(type, value?.Trim())); } }
/// <summary> /// Sorts the game explorer row. /// </summary> /// <returns>The sorting priority of the row. This value can be -1, 0 or 1 if /// A sorts before B, A sorts with B or A sorts after B, respectively.</returns> /// <param name="model">Model.</param> /// <param name="a">Iter a.</param> /// <param name="b">Iter b.</param> private int SortGameTreeRow(ITreeModel model, TreeIter a, TreeIter b) { const int sortABeforeB = -1; const int sortAWithB = 0; const int sortAAfterB = 1; var nodeA = (FileNode)model.GetValue(a, 0); var nodeB = (FileNode)model.GetValue(b, 0); NodeType typeofA = nodeA.Type; NodeType typeofB = nodeB.Type; // Special case for meta nodes - if A is a meta node, but B is not if (typeofA.HasFlag(NodeType.Meta) && !typeofB.HasFlag(NodeType.Meta)) { // Then it should always sort after B return(sortAAfterB); } if (typeofB.HasFlag(NodeType.Meta) && !typeofA.HasFlag(NodeType.Meta)) { // Then it should always sort before B return(sortABeforeB); } if (typeofA < typeofB) { return(sortAAfterB); } if (typeofA > typeofB) { return(sortABeforeB); } string nodeAName = this.TreeModel.GetNodeName(nodeA); string nodeBName = this.TreeModel.GetNodeName(nodeB); int result = string.CompareOrdinal(nodeAName, nodeBName); if (result <= sortABeforeB) { return(sortAAfterB); } if (result >= sortAAfterB) { return(sortABeforeB); } return(sortAWithB); }
public static NodeType[] GetCandidate(NodeType type, int level) { if (!type.HasFlag(NodeType.FlagAbstract)) { return(new[] { type }); } type -= NodeType.FlagAbstract; if (level > MaxLevel && !type.HasFlag(NodeType.FlagType)) { return(new[] { NodeType.End }); } return(candidateTypes.Where(x => (x & type) == type).ToArray()); }
static TreeBase CreateNode(NodeType type) { Debug.Assert(!type.HasFlag(NodeType.FlagAbstract)); ModifierType mt; if (ModifierTable.TryGetValue(type, out mt)) { return(new Modifier(mt)); } switch (type) { case NodeType.NopA: return(new Nop(Nop.ConnectionType.A)); case NodeType.NopB: return(new Nop(Nop.ConnectionType.B)); case NodeType.NopW: return(new Nop(Nop.ConnectionType.W)); case NodeType.End: return(new EndA()); case NodeType.Add: return(new FunctionNode <Adder>()); case NodeType.Mult: return(new FunctionNode <Multiplier>()); case NodeType.Filter: return(new FunctionNode <Filter>()); case NodeType.Delay: return(new FunctionNode <Delay>()); case NodeType.Split: return(new FunctionNode <Splitter>()); case NodeType.Oscil: return(new FunctionNode <ConstantOscillator>()); case NodeType.Parabola: return(new FunctionNode <Parabola>()); case NodeType.Wire: return(new FunctionNode <Wire>()); case NodeType.Constant: return(new Constant(RandomProvider.GetThreadRandom().NextDouble() * 2.0 - 1.0)); default: throw new ArgumentException(); } }