private void SetItem(int index, VariableValue item)
{
if (_items[index] != null)
{
var equal = VariableHandler.IsEqual(_items[index].Value, item);
if (equal.HasValue && equal.Value)
{
return;
}
Destroy(_items[index].gameObject);
}
var binding = Instantiate(Template, transform);
binding.transform.SetSiblingIndex(index);
binding.Value = item;
_items[index] = binding;
}
protected override void UpdateBinding(IVariableStore variables, BindingAnimationStatus status)
{
if (Resolve(variables, Variable, out VariableValue value))
{
var equal = VariableHandler.IsEqual(value, _previousValue);
if (!equal.HasValue || !equal.Value)
{
if (value.TryGetInt(out int i))
{
var text = Format.GetFormattedString(i);
SetText(text, true);
_previousValue = value;
}
else if (value.TryGetFloat(out float f))
{
var text = Format.GetFormattedString(f);
SetText(text, true);
_previousValue = value;
}
else
{
if (!SuppressErrors)
{
Debug.LogWarningFormat(this, _invalidVariableWarning, Variable, name, value.Type);
}
SetText(string.Empty, false);
_previousValue = VariableValue.Empty;
}
}
}
else
{
_previousValue = VariableValue.Empty;
SetText(string.Empty, false);
}
}
public VariableValue GetValue(IVariableStore variables)
{
var value = IsAssigned ? VariableValue.Create(variables) : VariableValue.Empty;
foreach (var token in _tokens)
{
switch (token.Type)
{
case VariableTokenType.Name: value = VariableHandler.Lookup(value, VariableValue.Create(token.Text)); break;
case VariableTokenType.Number: value = VariableHandler.Lookup(value, VariableValue.Create(int.Parse(token.Text))); break;
case VariableTokenType.Type: value = VariableHandler.Cast(value, token.Text); break;
}
if (value.IsEmpty)
{
break;
}
}
return(value);
}
public void OnAfterDeserialize()
{
_variables = VariableHandler.LoadVariables(ref _variablesData, ref _variablesObjects);
}
public void OnBeforeSerialize()
{
_variablesData = VariableHandler.SaveVariables(_variables, ref _variablesObjects);
}
private SetVariableResult SetValue_(ref VariableValue owner, VariableValue value, int index)
{
var token = _tokens[index];
if (index == _tokens.Count - 1)
{
switch (token.Type)
{
case VariableTokenType.Name:
{
return(VariableHandler.Apply(ref owner, VariableValue.Create(token.Text), value));
}
case VariableTokenType.Number:
{
if (int.TryParse(token.Text, out var number))
{
return(VariableHandler.Apply(ref owner, VariableValue.Create(number), value));
}
break;
}
case VariableTokenType.Type:
{
return(SetVariableResult.ReadOnly);
}
}
}
else
{
var lookup = VariableValue.Empty;
var child = VariableValue.Empty;
switch (token.Type)
{
case VariableTokenType.Name:
{
lookup = VariableValue.Create(token.Text);
child = VariableHandler.Lookup(owner, lookup);
break;
}
case VariableTokenType.Number:
{
if (int.TryParse(token.Text, out var number))
{
lookup = VariableValue.Create(number);
child = VariableHandler.Lookup(owner, lookup);
}
break;
}
case VariableTokenType.Type:
{
child = VariableHandler.Cast(owner, token.Text);
break;
}
}
if (!child.IsEmpty)
{
// if a value is set on a struct (Vector3.x for instance), the variable value needs to be
// reassigned to its owner
var result = SetValue_(ref child, value, index + 1);
if (result == SetVariableResult.Success && !child.HasReference)
{
result = VariableHandler.Apply(ref owner, lookup, child);
}
return(result);
}
}
return(SetVariableResult.NotFound);
}
protected override void UpdateBinding(IVariableStore variables, BindingAnimationStatus status)
{
var enabled = false;
var text = string.Empty;
try
{
var result = Expression.Evaluate(variables);
var equal = VariableHandler.IsEqual(result, _resultValue);
if (_resultState != ResultState.Value || !equal.HasValue || !equal.Value)
{
if (result.IsEmpty)
{
if (!SuppressErrors)
{
Debug.LogWarningFormat(this, _missingExpressionWarning, this);
}
}
else
{
enabled = true;
if (result.TryGetInt(out var intValue))
{
text = Formatting.GetFormattedString(intValue);
}
if (result.TryGetFloat(out var floatValue))
{
text = Formatting.GetFormattedString(floatValue);
}
else
{
text = result.ToString();
}
}
}
_resultValue = result;
}
catch (ExpressionEvaluationException exception)
{
if (_resultState != ResultState.Error)
{
Debug.LogWarningFormat(this, _failedExpressionWarning, this, Expression.LastOperation, exception.Message);
}
_resultState = ResultState.Error;
}
catch (CommandEvaluationException exception)
{
if (_resultState != ResultState.Error)
{
Debug.LogWarningFormat(this, _failedCommandWarning, this, exception.Command, exception.Message);
}
_resultState = ResultState.Error;
}
SetText(text, enabled);
}
public override void ToString(StringBuilder builder)
{
switch (Value.Type)
{
case VariableType.Object:
{
if (Value.IsNull)
{
builder.Append(ExpressionLexer.NullConstant);
}
else
{
VariableHandler.ToString(Value, builder);
}
break;
}
case VariableType.Bool:
{
if (Value.Bool)
{
builder.Append(ExpressionLexer.TrueConstant);
}
else
{
builder.Append(ExpressionLexer.FalseConstant);
}
break;
}
case VariableType.Float:
{
if (Value.Float == Mathf.PI)
{
builder.Append(ExpressionLexer.PiConstant);
}
else if (Value.Float == Mathf.Deg2Rad)
{
builder.Append(ExpressionLexer.Deg2RadConstant);
}
else if (Value.Float == Mathf.Rad2Deg)
{
builder.Append(ExpressionLexer.Rad2DegConstant);
}
else
{
VariableHandler.ToString(Value, builder);
}
break;
}
default:
{
VariableHandler.ToString(Value, builder);
break;
}
}
}
public VariableValue GetValue(IVariableStore variables, VariableValue owner)
{
return(VariableHandler.Lookup(owner, VariableValue.Create(Name)));
}
public override void ToString(StringBuilder builder)
{
VariableHandler.ToString(_value, builder);
}
