public IEnumerator Run(Graph graph, GraphNode root, IVariableDictionary variables, string source)
{
_graph = graph;
_graph.IsExiting = false;
GoTo(root, source);
#if UNITY_EDITOR
while (Iterate())
#else
while (_nextNode.Node != null)
#endif
{
var node = _nextNode;
_nextNode.Node = null;
node.Node.IsRunning = true;
#if UNITY_EDITOR
yield return(_graph.ProcessNode(this, node.Node, variables, node.Source));
#else
yield return(node.Node.Run(this, variables));
#endif
node.Node.IsRunning = false;
}
}
void Awake()
{
var parent = GetComponentInParent <IVariableHierarchy>() as IVariableDictionary;
_variables = new ChildDictionary(parent ?? VariableContext.Default);
_variables.AddVariable(ThisName, Variable.Object(this));
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
if (Target.IsValid)
{
var target = Target.Execute <Object>(variables);
if (target is GameObject gameObject)
{
gameObject.SetActive(true);
}
else if (target is Behaviour behaviour)
{
behaviour.enabled = true;
}
else if (target is Renderer renderer)
{
renderer.enabled = true;
}
else
{
Debug.LogWarningFormat(this, _invalidObjectWarning, name, Target);
}
}
graph.GoTo(Next, nameof(Next));
yield break;
}
public VariableDictionaryWatchControl(string name, IVariableDictionary variables, bool allowClose)
{
var proxy = new WatchProxy(variables);
var list = new ListField
{
Label = name,
AllowAdd = false,
AllowRemove = false,
AllowReorder = false,
Tooltip = "The variables in this map",
EmptyLabel = "This variable map is empty",
EmptyTooltip = "There are no variables in this map",
};
list.SetProxy(proxy, null, false);
if (allowClose)
{
list.Header.Add(new IconButton(RemoveFromHierarchy)
{
image = Icon.Close.Texture, tooltip = "Close this watch"
});
}
Add(list);
}
public IEnumerator Run(GraphNode node, IVariableDictionary variables, string source)
{
if (!_graph.IsExiting)
{
yield return(CompositionManager.Instance.GetEnumerator(_graph.Run(node, variables, source)));
}
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
if (Loop != null)
{
var variable = Container.Execute(variables);
if (variable.TryGetList(out var list))
{
for (var i = 0; i < list.VariableCount; i++)
{
var item = list.GetVariable(i);
yield return(SetValues(graph, variables, i, item));
}
}
else if (variable.TryGetDictionary(out var dictionary))
{
var i = 0;
var names = dictionary.VariableNames;
foreach (var name in names)
{
var item = dictionary.GetVariable(name);
yield return(SetValues(graph, variables, i++, item));
}
}
else
{
throw new VariableSourceException();
}
}
yield break;
}
public StoryboardParserTests()
{
blockFactory = new FakeBlockFactory();
dismissNodes = new();
parsingContext = A.Fake<IParsingContext>(i => i.Strict());
A.CallTo(() => parsingContext.RegisterDismissNode(A<INode>.Ignored))
.Invokes(i => dismissNodes.Add(i.Arguments.Get<INode>(0)));
A.CallTo(() => parsingContext.BlockFactory).Returns(blockFactory);
rootBlockParser = A.Fake<IRootBlockParser>(i => i.Strict());
sceneNavigator = A.Fake<ISceneNavigator>(i => i.Strict());
eventManager = A.Fake<IEventManager>(i => i.Strict());
randomizer = A.Fake<IRandomizer>(i => i.Strict());
navigationState = A.Fake<INavigationState>(i => i.Strict());
variableDictionary = A.Fake<IVariableDictionary>(i => i.Strict());
blockState = A.Fake<IBlockState>(i => i.Strict());
var serviceProvider = A.Fake<IServiceProvider>(i => i.Strict());
A.CallTo(() => serviceProvider.GetService(typeof(IParsingContext))).Returns(parsingContext);
A.CallTo(() => serviceProvider.GetService(typeof(IRootBlockParser))).Returns(rootBlockParser);
A.CallTo(() => serviceProvider.GetService(typeof(ISceneNavigator))).Returns(sceneNavigator);
A.CallTo(() => serviceProvider.GetService(typeof(IEventManager))).Returns(eventManager);
A.CallTo(() => serviceProvider.GetService(typeof(IRandomizer))).Returns(randomizer);
A.CallTo(() => serviceProvider.GetService(typeof(INavigationState))).Returns(navigationState);
A.CallTo(() => serviceProvider.GetService(typeof(IVariableDictionary))).Returns(variableDictionary);
A.CallTo(() => serviceProvider.GetService(typeof(IBlockState))).Returns(blockState);
sut = new StoryboardParser(serviceProvider);
}
public bool Evaluate(IVariableDictionary variables)
{
if (Max.Evaluate(variables) is not IComparable maxValue)
{
return(true);
}
var minValue = Min.Evaluate(variables) as IComparable;
if (Operand.Evaluate(variables) is not IComparable actual)
{
return(minValue is not null);
}
if (minValue is not null)
{
if (actual.GetType() != minValue.GetType())
{
return(false);
}
if (actual.CompareTo(minValue) < 0)
{
return(true);
}
}
return(actual.GetType() == maxValue.GetType() && actual.CompareTo(maxValue) > 0);
}
public void WriteInputs(GraphCaller graph, IList <GraphInput> inputs, IVariableDictionary variables)
{
foreach (var input in inputs)
{
if (input.Type == GraphInputType.Expression)
{
var value = input.Expression.Execute(variables);
var definition = graph?.Graph.GetInputDefinition(input);
value = ResolveValue(definition, value, graph.Graph, _invalidInputError, definition.Name);
if (!value.IsEmpty)
{
if (Input.AddVariable(input.Name, value) == SetVariableResult.NotFound)
{
Input.SetVariable(input.Name, value);
}
}
else
{
Debug.LogWarningFormat(_missingInputError, input.Name, graph.Graph, input.Expression);
}
}
else if (input.Type == GraphInputType.Value)
{
if (Input.AddVariable(input.Name, input.Value.Variable) == SetVariableResult.NotFound)
{
Input.SetVariable(input.Name, input.Value.Variable);
}
}
}
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
for (var i = 0; i < Nodes.Count; i++)
{
var node = Nodes[i];
if (node != null)
{
var state = new NodeState();
var enumerator = Run(graph, variables, node, GetConnectionName(nameof(Nodes), i), state);
CompositionManager.Instance.RunEnumerator(enumerator);
_states.Add(state);
}
}
while (_states.Count > 0)
{
for (var i = 0; i < _states.Count; i++)
{
var state = _states[i];
if (state.IsFinished)
{
_states.RemoveAt(i--);
}
}
yield return(null);
}
}
public static WatchEvent GetPooled(IVariableDictionary variables, string name)
{
var pooled = GetPooled();
pooled.Variables = variables;
pooled.Name = name;
return(pooled);
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
var text = Message.Execute(variables, VariableType.String);
Debug.Log(text.AsString);
graph.GoTo(Next, nameof(Next));
yield break;
}
public string ToString(IVariableDictionary variables)
{
var builder = new StringBuilder(AproxLength);
foreach (var item in Values)
{
builder.Append(item.ToString(variables));
}
return(builder.ToString());
}
private IEnumerator UnloadScene(IVariableDictionary variables)
{
var variable = Scene.Resolve(variables, VariableType.Asset);
yield return(variable.AsAsset.UnLoadScene());
if (Cleanup)
{
yield return(Resources.UnloadUnusedAssets());
}
}
public BalloonTextNodeTests()
{
variables = A.Dummy <IVariableDictionary>();
state = A.Dummy <INavigationState>();
context = A.Fake <INavigationContext>(i => i.Strict());
A.CallTo(() => context.State).Returns(state);
A.CallTo(() => context.Variables).Returns(variables);
textSource = A.Dummy <ITextSource>();
A.CallTo(() => textSource.ToString(variables)).Returns(balloonText);
}
public void ReadOutputs(GraphCaller graph, IList <GraphOutput> outputs, IVariableDictionary variables)
{
foreach (var output in outputs)
{
if (output.Type == GraphOutputType.Expression)
{
var value = Output.GetVariable(output.Name);
output.Expression.Assign(variables, value);
}
}
}
private IEnumerator LoadScene(IVariableDictionary variables)
{
var variable = Scene.Resolve(variables, VariableType.Asset);
yield return(variable.AsAsset.LoadSceneAsync(Additive ? LoadSceneMode.Additive : LoadSceneMode.Single));
if (Cleanup)
{
yield return(Resources.UnloadUnusedAssets());
}
}
private IEnumerator SetValues(IGraphRunner graph, IVariableDictionary variables, int iteration, Variable item)
{
if (Index.IsValid)
{
Index.Execute(variables); // Variable.Int(iteration)
}
if (Value.IsValid)
{
Value.Execute(variables); // item
}
yield return(graph.Run(Loop, variables, nameof(Loop)));
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
if (Target.IsValid)
{
var target = Target.Execute <Object>(variables);
Destroy(target);
}
graph.GoTo(Next, nameof(Next));
yield break;
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
for (var i = 0; i < Sequence.Count; i++)
{
var node = Sequence[i];
if (node)
{
yield return(graph.Run(node, variables, GetConnectionName(nameof(Sequence), i)));
}
}
}
public IVarSet Execute(IVariableDictionary variables)
{
if (OldStringValue is not null)
{
variables.Strings[Name] = OldStringValue;
}
else
{
variables.Integers[Name] = OldIntegerValue;
}
return(new VarUnset(Name));
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
var prefabVariable = Prefab.Resolve(variables);
if (prefabVariable.TryGetObject(out GameObject prefab))
{
GameObject spawned = null;
var position = Position.Resolve(variables, VariableType.Vector3);
var rotation = Rotation.Resolve(variables, VariableType.Quaternion);
if (Positioning == ObjectPositioning.Absolute)
{
spawned = Instantiate(prefab, position.AsVector3, rotation.AsQuaternion);
}
else if (Positioning == ObjectPositioning.Relative)
{
if (Object.IsValid)
{
var obj = Object.Execute <GameObject>(variables);
spawned = Instantiate(prefab, obj.transform.position + position.AsVector3, rotation.AsQuaternion);
}
}
else if (Positioning == ObjectPositioning.Child)
{
if (Parent.IsValid)
{
var parent = Parent.Execute <GameObject>(variables);
spawned = Instantiate(prefab, parent.transform.position + position.AsVector3, rotation.AsQuaternion, parent.transform);
}
}
if (spawned)
{
var objectName = ObjectName.Resolve(variables, VariableType.String).AsString;
if (!string.IsNullOrEmpty(objectName))
{
spawned.name = objectName;
}
if (ObjectVariable.IsValid)
{
ObjectVariable.Assign(variables, Variable.Object(spawned));
}
}
}
graph.GoTo(Next, nameof(Next));
yield break;
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
if (WaitForCompletion)
{
yield return(LoadScene(variables));
}
else
{
CompositionManager.Instance.StartCoroutine(LoadScene(variables));
}
graph.GoTo(Next, nameof(Next));
}
public void Reset()
{
// in case the editor exits play mode while the graph is running
Variables = null;
IsRunning = false;
DebugState = PlaybackState.Running;
foreach (var runner in _runners)
{
_graphRunnerPool.Release(runner as GraphRunner);
}
_runners.Clear();
}
public override bool Evaluate(IVariableDictionary variables)
{
if (Left.Evaluate(variables) is not IComparable leftValue)
{
return(false);
}
if (Right.Evaluate(variables) is not IComparable rightValue)
{
return(true);
}
return(leftValue.GetType() == rightValue.GetType() && leftValue.CompareTo(rightValue) > 0);
}
public bool Evaluate(IVariableDictionary variables)
{
var actual = Operand.Evaluate(variables);
foreach (var expected in Values)
{
if (Helper.AreEqual(expected.Evaluate(variables), actual))
{
return(true);
}
}
return(false);
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
var type = Type.GetType(ScriptableObjectType, false);
var obj = CreateInstance(type);
if (ObjectVariable.IsValid)
{
ObjectVariable.Assign(variables, Variable.Object(obj));
}
graph.GoTo(Next, nameof(Next));
yield break;
}
public IEnumerator Execute(IVariableDictionary variables)
{
if (Graph)
{
var store = GraphDictionary.Reserve();
store.WriteInputs(this, Inputs, variables);
store.WriteOutputs(Outputs);
yield return(Graph.Execute(store));
store.ReadOutputs(this, Outputs, variables);
GraphDictionary.Release(store);
}
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
var condition = Condition.Execute(variables, VariableType.Bool);
if (condition.AsBool)
{
graph.GoTo(OnTrue, nameof(OnTrue));
}
else
{
graph.GoTo(OnFalse, nameof(OnFalse));
}
yield break;
}
public override IEnumerator Run(IGraphRunner graph, IVariableDictionary variables)
{
var name = Switch.Execute(variables, VariableType.String).AsString;
if (Outputs.TryGetValue(name, out var output))
{
graph.GoTo(output, GetConnectionName(nameof(Outputs), name));
}
else
{
graph.GoTo(Default, nameof(Default));
}
yield break;
}
