private bool CompareParameters(ScriptableVariable parameter1, ScriptableVariable parameter2)
{
if (parameter1.ValueObject is IComparable comparableParameter1)
{
object valueObject = parameter2.ValueObject;
int comparisonResult = comparableParameter1.CompareTo(valueObject);
switch (comparisonType)
{
case ComparisonType.Greater:
return(comparisonResult > 0);
case ComparisonType.Smaller:
return(comparisonResult < 0);
case ComparisonType.GreaterOrEqual:
return(comparisonResult >= 0);
case ComparisonType.SmallerOrEqual:
return(comparisonResult <= 0);
}
}
return(false);
}
public void setFloat(ScriptableVariable <float> variable)
{
if (!animator)
{
animator = GetComponent <Animator>();
}
animator.SetFloat(variable.Name, variable.Value);
}
public void setBool(ScriptableVariable <bool> variable)
{
if (!animator)
{
animator = GetComponent <Animator>();
}
animator.SetBool(variable.Name, variable.Value);
}
public void setInt(ScriptableVariable <int> variable)
{
if (!animator)
{
animator = GetComponent <Animator>();
}
animator.SetInteger(variable.Name, variable.Value);
}
public void Inject(string key, ScriptableVariable variable)
{
DataInjectorDataEntry injectableData = FindDataEntry(key);
if (injectableData != null)
{
ReplaceVariable(injectableData, variable);
}
}
public void Inject(ScriptableVariable from, ScriptableVariable to)
{
DataInjectorDataEntry injectableData = FindDataEntry(from);
if (injectableData != null)
{
ReplaceVariable(injectableData, to);
}
}
public T GetData <T>(string key)
{
ScriptableVariable variable = GetVariable(key);
if (variable)
{
return((T)variable.ValueObject);
}
return(default);
public override bool ReplaceVariable(ScriptableVariable from, ScriptableVariable to)
{
bool variableReplaced = base.ReplaceVariable(from, to);
if (variableReplaced)
{
UpdateChildren();
}
return(variableReplaced);
}
public override bool ReplaceVariable(ScriptableVariable from, ScriptableVariable to)
{
bool variableReplaced = base.ReplaceVariable(from, to);
if (variableReplaced && SetOnReplaceVariable)
{
Set();
}
return(variableReplaced);
}
public override bool ReplaceVariable(ScriptableVariable from, ScriptableVariable to)
{
bool replacementSuccessful = false;
foreach (var dataReceiver in GetInjectionReceivers(gameObject))
{
bool variableReplaced = dataReceiver.ReplaceVariable(from, to);
replacementSuccessful = replacementSuccessful || variableReplaced;
}
return(replacementSuccessful);
}
public virtual bool ReplaceVariable(ScriptableVariable from, ScriptableVariable to)
{
FindInjectableDataIfNotInitialized();
bool replacementSuccessful = false;
foreach (ScriptableVariableReference reference in injectableVariableReferences)
{
bool variableReplaced = reference.TryReplaceVariable(from, to);
replacementSuccessful = replacementSuccessful || variableReplaced;
}
return(replacementSuccessful);
}
public bool ReplaceVariable(DataInjectorDataEntry entry, ScriptableVariable to)
{
bool replacementSuccessful;
if (entry.replacementVariable == null)
{
replacementSuccessful = ReplaceVariable(entry.variableToReplace, to);
}
else
{
replacementSuccessful = ReplaceVariable(entry.replacementVariable, to);
}
entry.replacementVariable = to;
return(replacementSuccessful);
}
public void PlayerMove(ScriptableVariable <bool> move)
{
if (!isShowingSteps.Value)
{
if (CurrentPatten.FirstOrDefault()?.value == move)
{
CurrentPatten = CurrentPatten.Skip(1).ToArray();
}
else
{
StartCoroutine(Demo());
}
if (!CurrentPatten.Any())
{
LevelUP();
}
}
}
/// <summary>
/// Parent method for drawing both the ScriptableVariable field and its shortcut value field.
/// </summary>
protected virtual void DrawValueField(Rect position, SerializedProperty property)
{
ScriptableVariable <T> scriptableObject = (ScriptableVariable <T>)property.objectReferenceValue;
bool wasEnabled = GUI.enabled;
if (scriptableObject != null)
{
SerializedObject ser = new SerializedObject(scriptableObject);
SerializedProperty prop = ser.FindProperty("value");
GUI.enabled = scriptableObject.IsReadOnly;
DrawValueWhenNotNull(position, prop);
GUI.enabled = wasEnabled;
}
else
{
GUI.enabled = false;
DrawValueWhenNull(position);
GUI.enabled = wasEnabled;
}
}
/// <summary>
/// Draws the runtime value field like the regular inspector when in play mode, or a warning label when not playing.
/// </summary>
protected virtual void DrawRuntimeValueField()
{
if (EditorApplication.isPlaying)
{
ScriptableVariable <T> obj = serializedObject.targetObject as ScriptableVariable <T>;
BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
FieldInfo field = typeof(ScriptableVariable <T>).GetField("runtimeValue", bindFlags);
T runtime = (T)field.GetValue(obj);
bool wasEnabled = GUI.enabled;
GUI.enabled = false;
EditorGUILayout.LabelField("Runtime value", runtime.ToString());
GUI.enabled = wasEnabled;
}
else
{
EditorGUILayout.HelpBox("The runtime value will be visible in play mode.", MessageType.Info);
}
}
public override bool TryReplaceVariable(ScriptableVariable from, ScriptableVariable to)
{
if (base.TryReplaceVariable(from, to))
{
return(true);
}
// Try to replace contained variables
bool replacedAny = false;
for (int i = 0; i < Value.Elements.Count; i++)
{
if (Value.ElementAt(i).IsAReplacement(from, to))
{
Value.Replace(i, to);
replacedAny = true;
}
}
//if (replacedAny) HandleChange();
return(replacedAny);
}
public virtual bool IsAReplacement(ScriptableVariable from, ScriptableVariable to) => false;
public virtual bool CopyValueFrom(ScriptableVariable scriptableVariable) => false;
public void setValueReff(ScriptableVariable <T> value)
{
this.value = value;
register();
}
public virtual bool IsReplaceableBy(ScriptableVariable to) => false;
public abstract void SetAndUseVariable(ScriptableVariable variable);
public abstract bool TryReplaceVariable(ScriptableVariable from, ScriptableVariable to);
public virtual void UpdateVariable(ScriptableVariable scriptableVariable)
{
}
protected DataInjectorDataEntry FindDataEntry(ScriptableVariable variable)
{
return(dataEntries.Find((d) => d.variableToReplace == variable));
}
public virtual SaveToken CreateFrom(ScriptableVariable scriptableVariable)
{
return(null);
}
