static private void ValidateRule(RSRuleData inRule, RSValidationState ioState, RSValidationContext inContext)
{
if (inRule == null)
{
ioState.Error("Null rule");
return;
}
ioState.PushContext("Trigger");
RSTriggerInfo triggerInfo = ValidateTriggerId(inRule.TriggerId, RSValidationFlags.None, ioState, inContext);
inContext = inContext.WithTrigger(triggerInfo);
ioState.PopContext();
if (inRule.Conditions != null && inRule.Conditions.Length > 0)
{
for (int i = 0; i < inRule.Conditions.Length; ++i)
{
ioState.PushContext("Condition {0}", i);
ValidateCondition(inRule.Conditions[i], ioState, inContext);
ioState.PopContext();
}
}
if (inRule.Actions != null && inRule.Actions.Length > 0)
{
for (int i = 0; i < inRule.Actions.Length; ++i)
{
ioState.PushContext("Action {0}", i);
ValidateAction(inRule.Actions[i], ioState, inContext);
ioState.PopContext();
}
}
}
internal RSValidationContext(RSLibrary inLibrary, IRSEntityMgr inManager, IRSEntity inEntity, RSTriggerInfo inTrigger, RSParameterInfo inParameterInfo)
{
Library = inLibrary;
Manager = inManager;
Entity = inEntity;
Trigger = inTrigger;
Parameter = inParameterInfo;
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (Mode)
{
case ResolvableValueMode.Value:
return(Value.GetPreviewString(inTriggerContext, inLibrary));
case ResolvableValueMode.Argument:
return(string.Format("Arg({0})", inTriggerContext?.ParameterType?.Name ?? "TriggerArg"));
case ResolvableValueMode.Query:
{
using (PooledStringBuilder psb = PooledStringBuilder.Alloc())
{
var sb = psb.Builder;
sb.Append(Query.GetPreviewStringAsQuery(inTriggerContext, inLibrary));
if (QueryArguments != null && QueryArguments.Length > 0)
{
sb.Append("(");
RSQueryInfo queryInfo = inLibrary.GetQuery(Query.Id);
for (int i = 0; i < QueryArguments.Length; ++i)
{
if (i > 0)
{
sb.Append("; ");
}
if (queryInfo != null && i < queryInfo.Parameters.Length)
{
sb.Append(queryInfo.Parameters[i].Name);
}
else
{
sb.Append(i);
}
sb.Append(": ");
sb.Append(QueryArguments[i].GetPreviewString(inTriggerContext, inLibrary));
}
sb.Append(")");
}
return(sb.ToString());
}
}
case ResolvableValueMode.Register:
return(string.Format("Register({0})", Register));
default:
return("[No Value]");
}
}
static private RSTriggerInfo ValidateTriggerId(RSTriggerId inTriggerId, RSValidationFlags inFlags, RSValidationState ioState, RSValidationContext inContext)
{
RSTypeInfo restrictTriggerType = inContext.Parameter?.TriggerParameterType;
if (inTriggerId == RSTriggerId.Null)
{
if (restrictTriggerType != null)
{
ioState.Error("Null trigger id provided - require trigger with parameter type {0}", restrictTriggerType);
}
else
{
ioState.Warn("Null trigger provided");
}
return(null);
}
else
{
RSTriggerInfo triggerInfo = inContext.Library.GetTrigger(inTriggerId);
if (triggerInfo == null)
{
ioState.Error("Trigger {0} does not exist", inTriggerId);
}
else
{
if (restrictTriggerType != null)
{
if (restrictTriggerType == RSBuiltInTypes.Void)
{
if (triggerInfo.ParameterType != null)
{
ioState.Error("Trigger with no parameter required, but trigger {0} with parameter {1} provided", triggerInfo.Name, triggerInfo.ParameterType.Type);
}
}
else
{
if (triggerInfo.ParameterType == null)
{
ioState.Error("Trigger with parameter {0} required, but trigger {1} with no parameter provided", restrictTriggerType, triggerInfo.Name);
}
else if (!restrictTriggerType.CanConvert(triggerInfo.ParameterType.Type))
{
ioState.Error("Trigger with parameter {0} required, but trigger {1} with incompatible parameter {2} provided", restrictTriggerType, triggerInfo.Name, triggerInfo.ParameterType.Type);
}
}
}
}
return(triggerInfo);
}
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
string preview = GetBasePreviewString(inTriggerContext, inLibrary);
if (!string.IsNullOrEmpty(m_LinkSearch))
{
preview += "." + m_LinkSearch;
if (m_UseFirstLink)
{
preview += "[0]";
}
}
return(preview);
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
using (PooledStringBuilder psb = PooledStringBuilder.Alloc())
{
var sb = psb.Builder;
if (!Enabled)
{
sb.Append("[Disabled] ");
}
sb.Append(Action.GetPreviewStringAsAction(inTriggerContext, inLibrary));
if (Arguments != null && Arguments.Length > 0)
{
sb.Append("(");
RSActionInfo actionInfo = inLibrary.GetAction(Action.Id);
for (int i = 0; i < Arguments.Length; ++i)
{
if (i > 0)
{
sb.Append("; ");
}
if (actionInfo != null && i < actionInfo.Parameters.Length)
{
sb.Append(actionInfo.Parameters[i].Name);
}
else
{
sb.Append(i);
}
sb.Append(": ");
sb.Append(Arguments[i].GetPreviewString(inTriggerContext, inLibrary));
}
sb.Append(")");
}
return(sb.ToString());
}
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (m_Mode)
{
case ResolvableValueMode.Value:
return(m_Value.GetPreviewString(inTriggerContext, inLibrary));
case ResolvableValueMode.Argument:
return(string.Format("Arg({0})", inTriggerContext?.ParameterType?.Name ?? "TriggerArg"));
case ResolvableValueMode.Query:
return(m_Query.GetPreviewStringAsQuery(inTriggerContext, inLibrary));
case ResolvableValueMode.Register:
return(string.Format("Register({0})", m_Register));
default:
return("[No Value]");
}
}
public RSTypeInfo TypeInfo(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (Mode)
{
case ResolvableValueMode.Value:
return(RSInterop.RSTypeFor(Value, inLibrary.TypeAssembly));
case ResolvableValueMode.Query:
return(inLibrary.GetQuery(Query.Id)?.ReturnType);
case ResolvableValueMode.Argument:
return(inTriggerContext?.ParameterType?.Type);
case ResolvableValueMode.Register:
return(RSBuiltInTypes.Any);
default:
throw new InvalidOperationException("Unknown ResolvableValueMode " + Mode);
}
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
using (PooledStringBuilder psb = PooledStringBuilder.Alloc())
{
var sb = psb.Builder;
if (!Enabled)
{
sb.Append("[Disabled] ");
}
if (!string.IsNullOrEmpty(Name))
{
sb.Append(Name).Append(" :: ");
}
sb.Append(TriggerId.ToString(inLibrary));
return(sb.ToString());
}
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
using (PooledStringBuilder psb = PooledStringBuilder.Alloc())
{
var sb = psb.Builder;
if (!Enabled)
{
sb.Append("[Disabled] ");
}
sb.Append(Query.GetPreviewString(inTriggerContext, inLibrary));
sb.Append(" ").Append(Operator.Symbol());
if (Operator.IsBinary())
{
sb.Append(" ").Append(Target.GetPreviewString(inTriggerContext, inLibrary));
}
return(sb.ToString());
}
}
/// <summary>
/// Renders editor for rule info. Does not include conditions or actions.
/// </summary>
static public void RuleData(UndoTarget inUndo, RSRuleData ioRule, RSRuleTableData ioTable, RSValidationFlags inFlags, RSValidationContext inContext)
{
string preview = ioRule.GetPreviewString(null, inContext.Library);
GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle);
EditorGUILayout.Space();
string newName = EditorGUILayout.TextField(Content.RuleNameLabel, ioRule.Name);
if (newName != ioRule.Name)
{
inUndo.MarkDirty("Changed Rule Name");
ioRule.Name = newName;
}
RSTriggerId newTriggerId;
if (inFlags.Has(RSValidationFlags.FilterSelection) && inContext.Entity != null)
{
newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Entity, inContext.Library);
}
else
{
newTriggerId = LibraryGUILayout.TriggerSelector(Content.RuleTriggerLabel, ioRule.TriggerId, inContext.Library);
}
if (newTriggerId != ioRule.TriggerId)
{
inUndo.MarkDirty("Changed Rule Trigger", true);
ioRule.TriggerId = newTriggerId;
TableUtils.UpdateUniqueRuleTriggers(ioTable);
}
if (newTriggerId != RSTriggerId.Null)
{
RSTriggerInfo info = inContext.Library.GetTrigger(newTriggerId);
if (info != null && info.ParameterType != null)
{
using (new EditorGUI.IndentLevelScope())
{
EditorGUILayout.LabelField(Content.RuleParameterLabel, EditorGUIUtility.TrTextContent(info.ParameterType.ToStringWithoutDefault(), info.ParameterType.Tooltip));
}
}
}
EditorGUILayout.Space();
// Enabled
bool bEnabled = EditorGUILayout.Toggle(Content.RuleEnabledLabel, ioRule.Enabled);
if (bEnabled != ioRule.Enabled)
{
inUndo.MarkDirty("Changed Rule Enabled");
ioRule.Enabled = bEnabled;
}
bool bOnlyOnce = EditorGUILayout.Toggle(Content.RuleOnlyOnceLabel, ioRule.OnlyOnce);
if (bOnlyOnce != ioRule.OnlyOnce)
{
inUndo.MarkDirty("Changed Rule OnlyOnce");
ioRule.OnlyOnce = bOnlyOnce;
}
bool bDontInterrupt = EditorGUILayout.Toggle(Content.RuleDontInterruptLabel, ioRule.DontInterrupt);
if (bDontInterrupt != ioRule.DontInterrupt)
{
inUndo.MarkDirty("Changed Rule DontInterrupt");
ioRule.DontInterrupt = bDontInterrupt;
}
EditorGUILayout.Space();
string newGroup = EditorGUILayout.TextField(Content.RuleGroupLabel, ioRule.RoutineGroup);
if (newGroup != ioRule.RoutineGroup)
{
inUndo.MarkDirty("Changed Rule Group");
ioRule.RoutineGroup = newGroup;
}
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (m_Type)
{
case InnerType.String:
return(string.Format("\"{0}\"", m_StringValue));
case InnerType.Color:
return(ColorValue.ToString());
case InnerType.Bool:
return(BoolValue ? "true" : "false");
case InnerType.Float:
return(FloatValue.ToString());
case InnerType.Int32:
return(IntValue.ToString());
case InnerType.Null:
return("null");
case InnerType.Vector2:
return(AsVector2.ToString());
case InnerType.Vector3:
return(AsVector3.ToString());
case InnerType.Vector4:
return(AsVector4.ToString());
case InnerType.EntityScope:
return(EntityValue.GetPreviewString(inTriggerContext, inLibrary));
case InnerType.GroupId:
return(GroupIdValue.ToString(inLibrary));
case InnerType.TriggerId:
return(TriggerIdValue.ToString(inLibrary));
case InnerType.Enum:
{
Type enumType = Type.GetType(m_StringValue);
if (enumType == null)
{
Debug.LogErrorFormat("Enum type {0} no longer exists", m_StringValue);
return(m_IntValue.ToString());
}
try
{
return(Enum.ToObject(enumType, m_IntValue).ToString());
}
catch (Exception e)
{
Debug.LogException(e);
Debug.LogErrorFormat("Enum {0} cannot be represented as type {1}", m_IntValue, enumType);
return(m_IntValue.ToString());
}
}
case InnerType.Invalid:
return("INVALID");
default:
ThrowInvalidCastException(m_Type, typeof(string));
return(null);
}
}
public string GetPreviewStringAsQuery(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
string queryId = inLibrary.GetQuery(m_Id)?.Name ?? "null";
return(string.Format("{0}:{1}", m_Scope.GetPreviewString(inTriggerContext, inLibrary), queryId));
}
public string GetPreviewStringAsAction(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
string actionId = inLibrary.GetAction(m_Id)?.Name ?? "null";
return(string.Format("{0}:{1}", m_Scope.GetPreviewString(inTriggerContext, inLibrary), actionId));
}
string IRSPreviewable.GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
return(GetPreviewStringAsQuery(inTriggerContext, inLibrary));
}
private string GetBasePreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (m_Type)
{
case EntityScopeType.Null:
return("Null");
case EntityScopeType.Self:
return("Self");
case EntityScopeType.Argument:
return("Arg(" + (inTriggerContext?.ParameterType?.Name ?? "TriggerArg") + ")");
case EntityScopeType.Global:
return("Global");
case EntityScopeType.ObjectById:
return(string.Format("Entity(Id: {0})", m_Id));
case EntityScopeType.ObjectInRegister:
return(string.Format("Register({0})", RegisterArg));
case EntityScopeType.ObjectsWithName:
{
if (m_UseFirst)
{
return(string.Format("Entity(Name: {0})", m_Search));
}
return(string.Format("Entities(Name: {0})", m_Search));
}
case EntityScopeType.ObjectsWithPrefab:
{
if (m_UseFirst)
{
return(string.Format("Entity(Prefab: {0})", m_Search));
}
return(string.Format("Entities(Prefab: {0})", m_Search));
}
case EntityScopeType.ObjectsWithGroup:
{
using (PooledStringBuilder psb = PooledStringBuilder.Alloc())
{
var sb = psb.Builder;
if (m_UseFirst)
{
sb.Append("Entity");
}
else
{
sb.Append("Entities");
}
sb.Append("(Group: ");
if (m_Id == 0)
{
sb.Append("No Group");
}
else
{
var groupInfo = inLibrary?.GetGroup(m_Id);
if (groupInfo == null)
{
sb.Append(m_Id);
}
else
{
sb.Append(groupInfo.Name);
}
}
sb.Append(")");
return(sb.ToString());
}
}
case EntityScopeType.Invalid:
return("Invalid");
default:
return("Unknown");
}
}
public RSValidationContext WithTrigger(RSTriggerInfo inTrigger)
{
return(new RSValidationContext(Library, Manager, Entity, inTrigger, Parameter));
}
