static private void ValidateCondition(RSConditionData inCondition, RSValidationState ioState, RSValidationContext inContext)
{
ioState.PushContext("Query");
ValidateResolvableValue(inCondition.Query, null, RSValidationFlags.None.ForConditionQuery(), ioState, inContext);
ioState.PopContext();
RSTypeInfo expectedType = inCondition.Query.TypeInfo(inContext.Trigger, inContext.Library);
if (inCondition.Query.Mode != ResolvableValueMode.Value && expectedType != null)
{
ioState.PushContext("Operator");
CompareOperator op = inCondition.Operator;
if (!expectedType.IsOperatorAllowed(op))
{
ioState.Error("Operator {0} is not allowed for type {1}", op, expectedType);
}
ioState.PopContext();
if (op.IsBinary())
{
ioState.PushContext("Target");
ValidateResolvableValue(inCondition.Target, expectedType, RSValidationFlags.None.ForConditionTarget(), ioState, inContext);
ioState.PopContext();
}
}
}
private void RenderConditionListElement(Rect rect, int index, bool isActive, bool isFocused)
{
RSConditionData condition = m_SelectionState.Rule.Conditions[index];
Rect labelRect = rect;
labelRect.width -= CLONE_BUTTON_WIDTH + CLONE_BUTTON_SPACING;
string labelText = condition.GetPreviewString(GetCurrentTrigger(), m_Context.Library);
using (new RSGUI.ColorScope(condition.Enabled ? Color.white : Color.gray))
{
EditorGUI.LabelField(labelRect, labelText);
}
Rect cloneRect = rect;
cloneRect.width = CLONE_BUTTON_WIDTH;
cloneRect.height -= 4;
cloneRect.x = labelRect.xMax + CLONE_BUTTON_SPACING;
using (new EditorGUI.DisabledScope(EditorApplication.isPlaying))
{
if (GUI.Button(cloneRect, "Clone"))
{
RSConditionData clone = condition.Clone();
InsertCondition(clone, index + 1);
}
}
if (DetectContextClick(rect))
{
ShowConditionElementContextMenu(condition, index);
}
}
static public void CopyCondition(RSConditionData inConditionData)
{
Clear();
s_CurrentTarget = Target.Condition;
s_CurrentCondition = inConditionData.Clone();
}
static public void Clear()
{
s_CurrentTarget = Target.None;
s_CurrentRule = null;
s_CurrentCondition = null;
s_CurrentAction = null;
}
/// <summary>
/// Evaluates a condition.
/// </summary>
public bool EvaluateCondition(RSConditionData inCondition)
{
Assert.True(!inCondition.Target.IsMultiValue(), "Multi-target queries cannot be right-hand values for conditions");
MultiReturn <RSValue> query = ResolveValue(inCondition.Query);
RSValue target = ResolveValue(inCondition.Target).ForceSingle();
CompareOperator op = inCondition.Operator;
if (query.Set != null)
{
Subset subset = inCondition.MultiQuerySubset;
foreach (var check in query.Set)
{
bool bPass = Evaluate(op, check, target);
switch (subset)
{
case Subset.All:
{
if (!bPass)
{
return(false);
}
break;
}
case Subset.Any:
{
if (bPass)
{
return(true);
}
break;
}
case Subset.None:
{
if (bPass)
{
return(false);
}
break;
}
}
}
switch (subset)
{
case Subset.All:
case Subset.None:
return(true);
default:
return(false);
}
}
return(Evaluate(op, query.Single, target));
}
static public void PasteCondition(RSConditionData ioTarget)
{
if (!HasCondition())
{
Debug.LogError("No condition copied");
return;
}
ioTarget.CopyFrom(s_CurrentCondition);
}
private void OnAddNewCondition(ReorderableList list)
{
RSConditionData conditionData = new RSConditionData();
int index = list.index;
if (index >= 0)
{
++index;
}
InsertCondition(conditionData, index);
}
private void InsertCondition(RSConditionData inCondition, int inIndex = -1)
{
m_TargetState.UndoTarget.MarkDirty("Added Condition", true);
if (inIndex < 0 || inIndex >= m_SelectionState.Rule.Conditions.Length)
{
ArrayUtility.Add(ref m_SelectionState.Rule.Conditions, inCondition);
inIndex = m_SelectionState.Rule.Conditions.Length - 1;
}
else
{
ArrayUtility.Insert(ref m_SelectionState.Rule.Conditions, inIndex, inCondition);
}
SelectCondition(inIndex);
}
private void ShowConditionElementContextMenu(RSConditionData inConditionData, int inIndex)
{
GenericMenu menu = new GenericMenu();
menu.AddItem(s_ContextMenuCopyLabel, false, () => RSEditorClipboard.CopyCondition(inConditionData));
if (RSEditorClipboard.HasCondition())
{
menu.AddItem(s_ContextMenuPasteOverwriteLabel, false, () =>
{
m_TargetState.UndoTarget.MarkDirty("Paste condition (overwrite)");
RSEditorClipboard.PasteCondition(inConditionData);
});
if (EditorApplication.isPlaying)
{
menu.AddDisabledItem(s_ContextMenuPasteInsertLabel, false);
}
else
{
menu.AddItem(s_ContextMenuPasteInsertLabel, false, () =>
{
RSConditionData clone = RSEditorClipboard.PasteCondition();
InsertCondition(clone, inIndex + 1);
});
}
}
else
{
menu.AddDisabledItem(s_ContextMenuPasteOverwriteLabel, false);
menu.AddDisabledItem(s_ContextMenuPasteInsertLabel, false);
}
if (EditorApplication.isPlaying)
{
menu.AddDisabledItem(s_ContextMenuDeleteLabel, false);
}
else
{
menu.AddItem(s_ContextMenuDeleteLabel, false, () => DeleteCondition(inIndex));
}
menu.ShowAsContext();
}
private void ShowConditionHeaderContextMenu()
{
GenericMenu menu = new GenericMenu();
if (EditorApplication.isPlaying)
{
menu.AddDisabledItem(s_ContextMenuPasteAddToEndLabel, false);
menu.AddDisabledItem(s_ContextMenuDeleteAllLabel, false);
}
else
{
if (RSEditorClipboard.HasCondition())
{
menu.AddItem(s_ContextMenuPasteAddToEndLabel, false, () =>
{
RSConditionData clone = RSEditorClipboard.PasteCondition();
InsertCondition(clone, -1);
});
}
else
{
menu.AddDisabledItem(s_ContextMenuPasteAddToEndLabel, false);
}
if (m_SelectionState.Rule.Conditions.Length > 0)
{
menu.AddItem(s_ContextMenuDeleteAllLabel, false, () =>
{
SelectCondition(-1);
m_TargetState.UndoTarget.MarkDirty("Removed all Conditions", true);
m_SelectionState.Rule.Conditions = new RSConditionData[0];
});
}
else
{
menu.AddDisabledItem(s_ContextMenuDeleteAllLabel, false);
}
}
menu.ShowAsContext();
}
/// <summary>
/// Renders editor for condition info.
/// </summary>
static public void ConditionData(UndoTarget inUndo, RSConditionData ioCondition, RSValidationFlags inFlags, RSValidationContext inContext)
{
string preview = ioCondition.GetPreviewString(inContext.Trigger, inContext.Library);
GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle);
EditorGUILayout.Space();
// Enabled
bool bEnabled = EditorGUILayout.Toggle(Content.ConditionEnabledLabel, ioCondition.Enabled);
if (bEnabled != ioCondition.Enabled)
{
inUndo.MarkDirty("Changed Condition Enabled");
ioCondition.Enabled = bEnabled;
}
EditorGUILayout.Space();
using (new EditorGUI.DisabledGroupScope(!bEnabled))
{
RSTypeInfo prevQueryType = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library);
// Query
ResolvableValueData(inUndo, Content.ConditionValueLabel, ioCondition.Query, null, inFlags.ForConditionQuery(), inContext);
// comparison
RSTypeInfo queryTypeInfo = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library);
if (ioCondition.Query.Mode != ResolvableValueMode.Value && queryTypeInfo != null)
{
EditorGUILayout.Space();
RSEditorUtility.s_ComparisonOperators.Clear();
foreach (var comparison in queryTypeInfo.AllowedOperators())
{
RSEditorUtility.s_ComparisonOperators.Add(comparison, comparison.Name(), (int)comparison);
}
CompareOperator nextOperator = ioCondition.Operator;
if (!RSEditorUtility.s_ComparisonOperators.Contains(nextOperator))
{
nextOperator = RSEditorUtility.s_ComparisonOperators.Get(0);
}
nextOperator = ListGUILayout.Popup(Content.ConditionComparisonLabel, nextOperator, RSEditorUtility.s_ComparisonOperators);
if (nextOperator != ioCondition.Operator)
{
inUndo.MarkDirty("Changed Condition Operator");
ioCondition.Operator = nextOperator;
}
if (nextOperator.IsBinary())
{
EditorGUILayout.Space();
if (prevQueryType != queryTypeInfo)
{
inUndo.MarkDirty("Changed Condition Query Type");
RSResolvableValueData.SetAsValue(ref ioCondition.Target, queryTypeInfo.DefaultValue);
}
ResolvableValueData(inUndo, Content.ConditionTargetLabel, ioCondition.Target, queryTypeInfo, inFlags.ForConditionTarget(), inContext);
}
else
{
if (ioCondition.Target != null)
{
inUndo.MarkDirty("Removed Condition Comparison Target");
ioCondition.Target = null;
}
}
if (ioCondition.Query.IsMultiValue())
{
EditorGUILayout.Space();
Subset subset = (Subset)EditorGUILayout.EnumPopup(Content.ConditionSubsetLabel, ioCondition.MultiQuerySubset);
if (subset != ioCondition.MultiQuerySubset)
{
inUndo.MarkDirty("Changed Condition MultiQuerySubset");
ioCondition.MultiQuerySubset = subset;
}
}
}
}
}
/// <summary>
/// Evaluates a set of conditions.
/// </summary>
public bool EvaluateConditions(RSConditionData[] inConditions, Subset inSubset)
{
if (inConditions == null)
{
return(true);
}
int activeConditions = 0;
for (int i = 0, numConditions = inConditions.Length; i < numConditions; ++i)
{
RSConditionData condition = inConditions[i];
if (!condition.Enabled)
{
continue;
}
++activeConditions;
bool bPass = EvaluateCondition(condition);
switch (inSubset)
{
case Subset.All:
{
if (!bPass)
{
return(false);
}
break;
}
case Subset.Any:
{
if (bPass)
{
return(true);
}
break;
}
case Subset.None:
{
if (bPass)
{
return(false);
}
break;
}
}
}
if (activeConditions == 0)
{
return(true);
}
switch (inSubset)
{
case Subset.All:
case Subset.None:
return(true);
default:
return(false);
}
}
