NodeRegistry NodeRegistryProvider.GetRegistry(NodeRegistry prev)
{
var nr = prev.Derive();
RegisterNode(nr);
return(nr);
}
protected override void RegisterNode(NodeRegistry nr)
{
base.RegisterNode(nr);
nr.AddAction <PlayJumpNode>("playJump");
nr.AddAction <JumpUntilFallToGroundNode>("jumpUntilFallToGround");
nr.AddAction <ScreenShakeNode>("screenShake");
}
public void StepByStepFirstAndLastCallIsSingle()
{
var provider = new NodeDefinitionProvider();
provider.Register("FirstCall");
provider.Register("ManyCalls", "FirstCall");
provider.Register("LastCall", "ManyCalls");
provider.SetRoot("LastCall");
var node = provider.GetByName("LastCall");
node.SingleCall = true;
node = provider.GetByName("FirstCall");
node.SingleCall = true;
List <string> messages = new List <string>();
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("FirstCall", new BaseNode <string>(new FirstCallDataDriver(messages), provider.GetByName("FirstCall")));
nodeRegistry.Register("ManyCalls", new BaseNode <string>(new ManyCallsDataDriver(messages), provider.GetByName("ManyCalls")));
nodeRegistry.Register("LastCall", new BaseNode <string>(new LastCallDataDriver(messages), provider.GetByName("LastCall")));
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
Assert.AreEqual("FirstCall", messages[0]);
Assert.AreEqual("Data0", messages[1]);
Assert.AreEqual("LastCall", messages[2]);
Assert.AreEqual("Data1", messages[3]);
Assert.AreEqual("Data2", messages[4]);
}
public void ThreeRowsSimple()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var counterWrapper = new TestCounterWrapper();
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number < 3)
{
p.Item = $"AAA{counterWrapper.Counter++}";
}
else
{
p.Stop();
}
}), definitionA));
nodeRegistry.Register("B",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "BBB"; }), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
var wrapper = new DataItemWrapper <string>();
runner.Step(wrapper);
Assert.AreEqual("AAA0BBBCCC", wrapper.Item);
runner.Step(wrapper);
Assert.AreEqual("AAA1BBBCCC", wrapper.Item);
runner.Step(wrapper);
Assert.AreEqual("AAA2BBBCCC", wrapper.Item);
}
public void ThreeRowsSimpleRunAllNodesMustBeDisposed()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var counterWrapper = new TestCounterWrapper();
var nodeRegistry = new NodeRegistry <string>();
var a = new TestActionProcess(p =>
{
if (p.Number < 3)
{
p.Item = $"AAA{counterWrapper.Counter++}";
}
if (p.Number == 2)
{
p.Stop();
}
});
var b = new TestActionProcess(p => { p.Item = p.Item += "BBB"; });
var c = new TestActionProcess(p => { p.Item = p.Item += "CCC"; });
nodeRegistry.Register("A", new BaseNode <string>(a, definitionA));
nodeRegistry.Register("B", new BaseNode <string>(b, definitionB));
nodeRegistry.Register("C", new BaseNode <string>(c, definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
runner.Dispose();
Assert.IsTrue(a.IsDisposed);
Assert.IsTrue(b.IsDisposed);
Assert.IsTrue(c.IsDisposed);
}
public void CommitThrowsTest()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number < 3)
{
p.Item = $"AAA{p.Number}";
}
if (p.Number == 2)
{
p.Stop();
}
}, () => throw new Exception("Houston we have a problem")), definitionA));
nodeRegistry.Register("B",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "BBB"; }), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
var current = runner.Current;
Assert.AreEqual(1, current.CommitExceptions.Count);
}
public void CommitTest()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var nodeRegistry = new NodeRegistry <string>();
var flag = new TestFlag();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number < 3)
{
p.Item = $"AAA{p.Number}";
}
if (p.Number == 2)
{
p.Stop();
}
}, () => { flag.Flag = true; }), definitionA));
nodeRegistry.Register("B",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "BBB"; }), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
Assert.IsTrue(flag.Flag);
}
public void Run()
{
var provider = new NodeDefinitionProvider("FileWriter");
provider.Register("FileReader", new NodeDefinition()
{
Name = "FileReader"
});
provider.Register("FileWriter", new NodeDefinition()
{
Name = "FileWriter",
DependsOn = new List <string>()
{
"ErrorWriter"
}
});
provider.Register("ErrorWriter", new NodeDefinition()
{
Name = "ErrorWriter",
DependsOn = new List <string>()
{
"FileReader"
}
});
var input = @"C:\Temp\My\1.txt";
var output = @"C:\Temp\My\2.txt";
var error = @"C:\Temp\My\errors.txt";
using (StreamWriter sw = new StreamWriter(input))
{
for (int i = 0; i < 100000; i++)
{
if (i % 3000 == 0)
{
sw.WriteLine($"POOP{i}");
}
else
{
sw.WriteLine(i);
}
}
}
var nodeRegistry = new NodeRegistry <FileMoverData>();
nodeRegistry.Register("FileReader", new BaseNode <FileMoverData>(new FileReader(input), provider.GetByName("FileReader")));
nodeRegistry.Register("FileWriter", new BaseNode <FileMoverData>(new FileWriter(output), provider.GetByName("FileWriter")));
nodeRegistry.Register("ErrorWriter", new BaseNode <FileMoverData>(new ErrorWriter(error), provider.GetByName("ErrorWriter")));
var runner = new DataNodeRunner <FileMoverData>(provider, nodeRegistry);
runner.Run();
runner.Dispose();
}
protected virtual void RegisterNode(NodeRegistry nr)
{
nr.AddAction <RunToEdgeNode>("runToEdge");
nr.AddAction <TurnAroundNode>("turnAround");
nr.AddAction <SpineAnimateNode>("playAnim");
nr.AddAction <SpineAnimateOffsetNode>("animOffset");
nr.AddAction <FallToGroundNode>("fallToGround");
nr.AddAction <FaceToPlayerNode>("faceToPlayer");
nr.AddAction <JumpNode>("jump");
nr.AddAction <StandNode>("stand");
nr.AddAction <PlaySoundNode>("playSound");
}
public Transform FindLCA(Transform a, Transform b)
{
NodeRegistry nodeA = _nodeIndex[a];
if (nodeA == null)
{
return(null);
}
NodeRegistry nodeB = _nodeIndex[b];
if (nodeB == null)
{
return(null);
}
if (a == b)
{
return(a);
}
int indexA = nodeA.firstVisitIndex;
int indexB = nodeB.firstVisitIndex;
if (indexB < indexA)
{
int temp = indexA;
indexA = indexB;
indexB = temp;
}
else if (indexA == indexB)
{
return(_nodes[indexA]);
}
//Find the lowest value.
int lowest = int.MaxValue;
for (int i = indexA; i < indexB; i++)
{
if (_eulerianPath[i] < lowest)
{
lowest = _eulerianPath[i];
}
}
if (lowest >= _nodes.Count)
{
return(null);
}
return(_nodes[lowest]);
}
public void NodeName([SelectionList("Channels")]string name, string[] channels)
{
_registry = Context.State.Retrieve<ServiceBusNodes>().CreateNew(name);
channels.Each(channelName =>
{
var prop = ServiceBusNodes.Channels.First(x => x.Name == name);
_registry.AlterSettings<ChannelGraph>(graph =>
{
var channel = graph.ChannelFor(new SingleProperty(prop));
channel.Incoming = true;
});
});
}
void EulerTour(int rootIndex)
{
Transform node = _nodes[rootIndex];
_nodeIndex[node] = new NodeRegistry()
{
transform = node, firstVisitIndex = _eulerianPath.Count
};
_eulerianPath.Add(rootIndex);
for (int i = 0; i < node.childCount; i++)
{
_nodes.Add(node.GetChild(i));
EulerTour(_nodes.Count - 1);
_eulerianPath.Add(rootIndex);
}
}
public void InitializeChannels()
{
var nodeExchange = NodeConfiguration.NodeChannel;
var nodeQueue = NodeConfiguration.NodeChannel + "Q";
var meshExchange = NodeConfiguration.MeshChannel;
Bus.AddRabbitExchange(x => x
.Direct(nodeExchange)
.Immediate()
.Mandatory()
.AutoDelete()
.PersistentDelivery()
// we do want messages sticking around even if the broker dies
);
Bus.AddRabbitQueue(x => x
.QueueName(nodeQueue)
.ExchangeName(nodeExchange)
.Durable() // we do want messages sticking around even if the broker dies
.AutoDelete() // we don't want queues lingering after the node is gone
.StartSubscription());
Bus.AddRabbitExchange(x => x
.Fanout(meshExchange)
.Durable()
);
//Now for the magic
Bus.BindExchangeToQueue(meshExchange, nodeExchange, NodeConfiguration.NodeChannel);
//If not an 'edge' node then add 'self' to the node registry
if (!NodeConfiguration.AsProxy)
{
NodeRegistry.AddNode(NodeConfiguration.IdentityProvider.Identity);
}
//Start the monitor
if (!NodeConfiguration.AsProxy)
{
NodeMonitor.Start();
}
}
public override void OnReady <T>(T node, System.Reflection.MemberInfo memberInfo)
{
if (Name == null)
{
Name = FilterName(memberInfo.Name);
}
var val = NodeRegistry.GetOrNull(Name);
if (val == null)
{
if (!Required)
{
return;
}
var err = $"Node '{Name}' must be registered but could not be found.";
if (!Engine.EditorHint)
{
throw new NullReferenceException(err);
}
Logger.PushError(err);
return;
}
var varInfo = new VariableMemberInfo(memberInfo);
if (varInfo.VariableType.ContainsGenericParameters &&
typeof(IEnumerable <>)
.MakeGenericType(varInfo.VariableType.GenericTypeArguments[0])
.IsAssignableFrom(varInfo.VariableType))
{
var assignable = val.GetChildren <Node>().Where(n => varInfo.VariableType.GenericTypeArguments[0].IsInstanceOfType(n));
varInfo.SetValue(node, varInfo.VariableType == typeof(IList <>)
.MakeGenericType(varInfo.VariableType.GenericTypeArguments[0])
? assignable.ToList()
: assignable);
}
else if (varInfo.VariableType.IsInstanceOfType(val))
{
varInfo.SetValue(node, val);
}
else
{
GD.PushWarning($"{val} not of type {varInfo.VariableType.FullName}");
}
}
public void ABBCSimpleWhenANodeShouldntBeCalledTwice()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B",
"A"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p => { p.Item = "AAA"; }), definitionA));
nodeRegistry.Register("B",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "BBB"; }), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
var wrapper = new DataItemWrapper <string>();
runner.Step(wrapper);
Assert.AreEqual("AAABBBCCC", wrapper.Item);
}
public override void OnConstructor <T>(T node, MemberInfo info)
{
if (Name == null)
{
Name = node.GetType().Name;
}
var counter = 2;
var currentName = string.Format(Name, "");
switch (Singular)
{
case false:
while (NodeRegistry.IsRegistered(currentName))
{
currentName = string.Format(Name, counter++);
}
break;
case true:
if (NodeRegistry.IsRegistered(Name))
{
GD.PushError($"{Name} already register in {nameof(NodeRegistry)}");
return;
}
break;
default:
if (NodeRegistry.IsRegistered(Name))
{
node.RegisterOrReplace(Name);
return;
}
break;
}
node.Register(currentName);
}
static GameLogger()
{
_baseConsole = NodeRegistry.Get <BaseConsole>();
}
public AbstractNode(NodeRegistry registry, string id)
{
this._registry = registry;
this._id = id;
}
static GameData()
{
controlGroups = new BaseUnit.InternalSelectList[NodeRegistry.Get <ControlGroupButtonList>().ControlGroupMaxCount];
}
public Digraph(NodeRegistry registry, string title) : this(registry, title, null)
{
}
public Node(NodeRegistry registry, string id) : base(registry, id)
{
}
public void ThreeRowsAndBThrowsErrorOnTheSecond()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var counterWrapper = new TestCounterWrapper();
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number < 3)
{
p.Item = $"AAA{counterWrapper.Counter++}";
}
if (p.Number == 2)
{
p.Stop();
}
}), definitionA));
nodeRegistry.Register("B", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number == 1)
{
throw new Exception("Houston we have a problem");
}
p.Item += "BBB";
}), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
var result = runner.Current;
Assert.AreEqual("AAA2BBBCCC", result.Item);
}
public FullTreeStrategy(NodeRegistry nodeRegistry, IValueProviderRegistry valueProviderRegistry)
{
_nodeRegistry = nodeRegistry;
_valueProviderRegistry = valueProviderRegistry;
}
public void ThreeRowsTheSecondSkip()
{
var definitionC = new NodeDefinition
{
Name = "C",
DependsOn = new List <string>
{
"B"
}
};
var definitionB = new NodeDefinition
{
Name = "B",
DependsOn = new List <string>
{
"A"
}
};
var definitionA = new NodeDefinition
{
Name = "A"
};
var counterWrapper = new TestCounterWrapper();
var nodeRegistry = new NodeRegistry <string>();
nodeRegistry.Register("A", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number < 3)
{
if (p.Item == null)
{
p.Item = "";
}
p.Item = p.Item + $"AAA{counterWrapper.Counter++}";
}
if (p.Number == 2)
{
p.Stop();
}
}), definitionA));
nodeRegistry.Register("B", new BaseNode <string>(new TestActionProcess(p =>
{
if (p.Number == 1)
{
p.Skip();
}
else
{
p.Item = p.Item += "BBB";
}
}), definitionB));
nodeRegistry.Register("C",
new BaseNode <string>(new TestActionProcess(p => { p.Item = p.Item += "CCC"; }), definitionC));
var provider = new NodeDefinitionProvider("C");
provider.Register("C", definitionC);
provider.Register("B", definitionB);
provider.Register("A", definitionA);
var runner = new DataNodeRunner <string>(provider, nodeRegistry);
runner.Run();
var result = runner.Current;
Assert.AreEqual("AAA0BBBCCCAAA1AAA2BBBCCC", result.Item);
}
protected override void Execute(ICommandInterface console, ArgList arguments)
{
var coreInterface = NodeRegistry.Get <Control>(nameof(GameFrontend));
coreInterface.Visible = !coreInterface.Visible;
}
public Cluster(NodeRegistry registry, string id) : base(registry, id)
{
}
public Digraph(NodeRegistry registry, string title, string dir) : base(registry, title)
{
this._dir = dir;
SetLabel(title);
}
public void NodeRegistry_can_scan_assembly_without_crashing()
{
var registry = new NodeRegistry(new Container(), new MockValueProviderRegistry());
}
