public IEnumerator Run(InstructionGraph graph, InstructionStore variables, int executionIndex)
{
if (This.IsAssigned)
{
var value = This.GetValue(variables);
if (value.Type == VariableType.Empty)
{
Debug.LogWarningFormat(_missingThisWarning, This, name);
}
else if (value.Type != VariableType.Null)
{
// null is a valid this object, but primitive types are not
if (value.RawObject == null)
{
Debug.LogWarningFormat(_invalidThisWarning, This, name);
}
else
{
variables.ChangeThis(value.RawObject);
}
}
}
yield return(Run_(graph, variables, executionIndex));
}
private float GetFill(IVariableStore variables)
{
var amountValue = AmountVariable.GetValue(variables);
var totalValue = TotalVariable.GetValue(variables);
float amount, total;
switch (amountValue.Type)
{
case VariableType.Empty: Debug.LogErrorFormat(this, _missingAmountError, AmountVariable); amount = 0.0f; break;
case VariableType.Integer: amount = amountValue.Integer; break;
case VariableType.Number: amount = amountValue.Number; break;
default: Debug.LogErrorFormat(this, _invalidAmountError, AmountVariable); amount = 0.0f; break;
}
switch (totalValue.Type)
{
case VariableType.Empty: Debug.LogErrorFormat(this, _missingTotalError, TotalVariable); total = 1.0f; break;
case VariableType.Integer: total = totalValue.Integer; break;
case VariableType.Number: total = totalValue.Number; break;
default: Debug.LogErrorFormat(this, _invalidTotalError, TotalVariable); total = 1.0f; break;
}
return(amount / total);
}
private AsyncOperation Load(InstructionStore variables)
{
var mode = Additive ? LoadSceneMode.Additive : LoadSceneMode.Single;
switch (Source)
{
case SceneSource.Value: return(Load(Scene.Index, mode));
case SceneSource.Name: return(Load(SceneName, mode));
case SceneSource.Index: return(Load(SceneIndex, mode));
case SceneSource.Variable:
{
var value = SceneVariable.GetValue(variables);
if (value.TryGetInt(out var index))
{
return(Load(index, mode));
}
else if (value.TryGetString(out var name))
{
return(Load(name, mode));
}
else
{
Debug.LogWarningFormat(this, _invalidSceneWarning, Name, SceneVariable);
}
break;
}
}
return(null);
}
private void Append(IVariableStore variables, string input, StringBuilder output)
{
var start = 0;
while (start < input.Length)
{
var open = input.IndexOf('{', start);
var close = input.IndexOf('}', open + 1);
if (open > start && input[open - 1] == '\\')
{
output.Append(input, start, open - start - 1);
output.Append('{');
start = open + 1;
}
else if (open < 0 || close < 0)
{
output.Append(input, start, input.Length - start);
break;
}
else
{
output.Append(input, start, open - start);
var variable = input.Substring(open + 1, close - open - 1);
_temporaryReference.Update(variable);
var value = _temporaryReference.GetValue(variables);
Append(variables, value.ToString(), output);
start = close + 1;
}
}
}
public override IEnumerator Run(InstructionGraph graph, InstructionStore variables, int iteration)
{
if (ResolveObject(variables, Object, out BindingRoot root))
{
root.Value = Binding.GetValue(variables);
VariableBinding.UpdateBinding(root.gameObject, null, null);
}
graph.GoTo(Next, nameof(Next));
yield break;
}
public bool Resolve(IVariableStore variables, VariableReference reference, out IVariableList result)
{
var value = reference.GetValue(variables);
if (value.TryGetList(out result))
{
return(true);
}
LogResolveWarning(value, reference, VariableType.List);
return(false);
}
public bool ResolveList <ListType>(IVariableStore variables, VariableReference reference, out ListType result) where ListType : class, IVariableList
{
var value = reference.GetValue(variables);
if (value.TryGetReference(out result))
{
return(true);
}
LogResolveWarning(value, reference, VariableType.List, typeof(ListType));
return(false);
}
public bool Resolve <EnumType>(IVariableStore variables, VariableReference reference, out EnumType result) where EnumType : Enum
{
var value = reference.GetValue(variables);
if (value.TryGetEnum(out result))
{
return(true);
}
LogResolveWarning(value, reference, VariableType.Enum, typeof(EnumType));
return(false);
}
public bool ResolveReference(IVariableStore variables, VariableReference reference, out object result)
{
var value = reference.GetValue(variables);
if (value.HasReference)
{
result = value.Reference;
return(true);
}
result = null;
LogResolveWarning(value, reference, VariableType.Object);
return(false);
}
public override void UpdateBinding(IVariableStore variables, BindingAnimationStatus status)
{
var value = Variable.GetValue(variables);
if (value.TryGetObject(out Sprite sprite))
{
_image.sprite = sprite;
}
else if (value.Type == VariableType.Empty)
{
Debug.LogErrorFormat(this, _missingVariableError, Variable);
}
else
{
Debug.LogErrorFormat(this, _invalidVariableError, Variable);
}
}
public bool ResolveObject <ObjectType>(IVariableStore variables, VariableReference reference, out ObjectType result) where ObjectType : Object
{
var value = reference.GetValue(variables);
if (value.HasObject)
{
result = ComponentHelper.GetAsObject <ObjectType>(value.Object);
if (result != null)
{
return(true);
}
}
result = null;
LogResolveWarning(value, reference, VariableType.Object, typeof(ObjectType));
return(false);
}
public override void UpdateBindings(IVariableStore variables, string group, BindingAnimationStatus status)
{
Variables = variables;
var binding = Binding.GetValue(variables);
if (binding.TryGetStore(out IVariableStore store))
{
InterfaceBinding.UpdateBindings(gameObject, store, group, status);
}
else if (binding.Type == VariableType.Empty)
{
Debug.LogWarningFormat(this, _missingBindingError, Binding);
}
else
{
Debug.LogWarningFormat(this, _invalidBindingError, Binding);
}
}
public bool TryGetValue(IVariableStore variables, Object context, out T value)
{
switch (Type)
{
case VariableSourceType.Value:
{
value = Value;
return(true);
}
case VariableSourceType.Reference:
{
var variable = Reference.GetValue(variables);
if (variable.Type == VariableType.Empty)
{
value = default;
Debug.LogErrorFormat(context, _referenceMissingError, Reference);
return(false);
}
if (!TryGetValue(variable, out value))
{
var actualType = GetTypeName(variable);
var expectedType = GetTypeName(VariableValue.GetType(typeof(T)));
Debug.LogErrorFormat(context, _referenceInvalidError, Reference, actualType, expectedType);
return(false);
}
return(true);
}
default:
{
value = default;
return(false);
}
}
}
public bool ResolveInterface <InterfaceType>(IVariableStore variables, VariableReference reference, out InterfaceType result) where InterfaceType : class
{
var value = reference.GetValue(variables);
if (value.HasReference)
{
if (value.Reference is InterfaceType i)
{
result = i;
return(true);
}
else
{
result = null;
LogResolveWarning(value, reference, VariableType.Object, typeof(InterfaceType));
return(false);
}
}
result = null;
LogResolveWarning(value, reference, VariableType.Object);
return(false);
}
protected override IEnumerator Run_(InstructionGraph graph, InstructionStore variables, int iteration)
{
if (Prefab)
{
GameObject parent = null;
if (Parent.IsAssigned && !Parent.GetValue(variables).TryGetObject(out parent))
{
Debug.LogWarningFormat(this, _missingParentWarning, Name, Parent);
}
var spawned = parent ? Instantiate(Prefab, parent.transform.position + (Vector3)Position, Quaternion.identity, parent.transform) : Instantiate(Prefab, Position, Quaternion.identity);
spawned.name = ObjectName;
graph.GoTo(Next, spawned, nameof(Next));
}
else
{
Debug.LogWarningFormat(this, _missingObjectWarning, Name);
graph.GoTo(Next, variables.This, nameof(Next));
}
yield break;
}
public override void UpdateBinding(IVariableStore variables, BindingAnimationStatus status)
{
_variables = variables;
_text.textComponent.text = Variable.GetValue(_variables).ToString();
}
public bool Resolve(IVariableStore variables, VariableReference reference, out VariableValue result)
{
result = reference.GetValue(variables);
return(true);
}
private int GetValue(IVariableStore variables)
{
return(Variable.GetValue(variables).Integer);
}
public override VariableValue Evaluate(IVariableStore variables)
{
return(Reference.GetValue(variables));
}