/// <summary>
/// Evaluates a query with static scope.
/// </summary>
public RSValue EvaluateQuery(IRSRuntimeEntity inEntity, string inQueryId, params object[] inArgs)
{
RSQueryInfo queryInfo = Library.GetQuery(inQueryId);
ExecutionScope scope = CreateScope(inEntity, RSValue.Null, TableUtils.GetRuleFlags(queryInfo.Flags));
using (new SharedRef <ExecutionScope>(scope))
{
return(EvaluateQuery(inEntity, queryInfo, InternalScriptUtils.Convert(inArgs), scope));
}
}
/// <summary>
/// Performs an action with static scope.
/// </summary>
public object PerformAction(IRSRuntimeEntity inEntity, string inActionId, params object[] inArgs)
{
RSActionInfo actionInfo = Library.GetAction(inActionId);
ExecutionScope scope = CreateScope(inEntity, RSValue.Null, TableUtils.GetRuleFlags(actionInfo.Flags));
using (new SharedRef <ExecutionScope>(scope))
{
return(PerformAction(inEntity, actionInfo, InternalScriptUtils.Convert(inArgs), scope).Value);
}
}
internal bool CloneScopeIfNecessary(ExecutionScope inScope, RuleFlags inFlags, out ExecutionScope outScope)
{
if ((inFlags & RuleFlags.UsesRegisters) != 0)
{
outScope = CloneScope(inScope, inFlags);
return(true);
}
outScope = inScope;
return(false);
}
/// <summary>
/// Evaluates a query with static scope.
/// </summary>
public RSValue EvaluateQuery(string inQueryId, params object[] inArgs)
{
RSQueryInfo queryInfo = Library.GetQuery(inQueryId);
ExecutionScope scope = m_StaticScope;
CloneScopeIfNecessary(scope, TableUtils.GetRuleFlags(queryInfo.Flags), out scope);
using (new SharedRef <ExecutionScope>(scope))
{
return(EvaluateQuery(null, queryInfo, InternalScriptUtils.Convert(inArgs), scope));
}
}
internal void RecycleScope(ExecutionScope inScope)
{
Assert.True(inScope != null && inScope.m_Environment == this);
if ((inScope.m_Type & ExecutionScope.Type.Registers) != 0)
{
m_RegisterScopePool.Add(inScope);
}
else
{
m_LocalScopePool.Add(inScope);
}
}
/// <summary>
/// Performs an action with static scope.
/// </summary>
public object PerformAction(string inActionId, params object[] inArgs)
{
RSActionInfo actionInfo = Library.GetAction(inActionId);
ExecutionScope scope = m_StaticScope;
CloneScopeIfNecessary(scope, TableUtils.GetRuleFlags(actionInfo.Flags), out scope);
using (new SharedRef <ExecutionScope>(scope))
{
return(PerformAction(null, actionInfo, InternalScriptUtils.Convert(inArgs), scope).Value);
}
}
internal void TriggerRS(IRSRuntimeEntity inEntity, RSTriggerId inTriggerId, RSValue inArgument, bool inbForce)
{
if (!inbForce && inEntity.IsLocked())
{
return;
}
ExecutionScope scope = CreateScope(inEntity, inArgument, 0);
using (new SharedRef <ExecutionScope>(scope))
{
inEntity?.RuleTable?.EvaluateTrigger(inTriggerId, scope);
}
}
public RSEnvironment(RSLibrary inDatabase, IRSRuntimeEntityMgr inEntityMgr, IRSRuleTableMgr inTableMgr, IRSDebugLogger inLogger)
{
Library = inDatabase;
Entities = inEntityMgr;
Tables = inTableMgr;
Logger = inLogger;
if (Entities != null)
{
Entities.Context = this;
}
m_StaticScope = new ExecutionScope(this, ExecutionScope.Type.Registers);
m_StaticScope.Initialize(null, RSValue.Null);
m_LocalScopePool = new List <ExecutionScope>();
m_RegisterScopePool = new List <ExecutionScope>();
}
public void PrewarmPools(int inScopeCount, int inRegisterScopeCount)
{
if (m_LocalScopePool.Capacity < inScopeCount)
{
m_LocalScopePool.Capacity = inScopeCount;
}
while (m_LocalScopePool.Count < inScopeCount)
{
ExecutionScope scope = new ExecutionScope(this, ExecutionScope.Type.Pooled);
m_LocalScopePool.Add(scope);
}
if (m_RegisterScopePool.Capacity < inRegisterScopeCount)
{
m_RegisterScopePool.Capacity = inRegisterScopeCount;
}
while (m_RegisterScopePool.Count < inRegisterScopeCount)
{
ExecutionScope scope = new ExecutionScope(this, ExecutionScope.Type.Pooled | ExecutionScope.Type.Registers);
m_RegisterScopePool.Add(scope);
}
}
/// <summary>
/// Converts an RSValue to its closest mapped C# type.
/// </summary>
static public object ToObject(RSValue inValue, ExecutionScope inContext)
{
return(ToObject(inValue.GetInteropType(), inValue, inContext));
}
/// <summary>
/// Converts an RSValue to the given C# type.
/// </summary>
static public T ToObject <T>(RSValue inValue, ExecutionScope inContext)
{
return((T)ToObject(typeof(T), inValue, inContext));
}
internal IEnumerable <RSValue> EvaluateQueries(IEnumerable <IRSRuntimeEntity> inEntities, RSQueryInfo inQuery, RSValue[] inArguments, ExecutionScope inContext)
{
inQuery.PrepArguments(inArguments, inContext);
foreach (var entity in inEntities)
{
yield return(inQuery.InvokeWithCachedArgs(entity, inContext));
}
}
internal IEnumerable <ActionResult> PerformActions(IEnumerable <IRSRuntimeEntity> inEntities, RSActionInfo inAction, RSValue[] inArguments, ExecutionScope inContext)
{
inAction.PrepArguments(inArguments, inContext);
foreach (var entity in inEntities)
{
yield return(inAction.InvokeWithCachedArgs(entity, inContext));
}
}
internal ActionResult PerformAction(IRSRuntimeEntity inEntity, RSActionInfo inAction, RSValue[] inArguments, ExecutionScope inContext)
{
return(inAction.Invoke(inEntity, inArguments, inContext));
}
/// <summary>
/// Converts an RSValue to the given C# type.
/// </summary>
static public object ToObject(Type inType, RSValue inValue, ExecutionScope inContext)
{
if (inType == null || inType == typeof(void))
{
return(null);
}
if (inType == typeof(object))
{
return(inValue);
}
if (inType == typeof(RSValue))
{
return(inValue);
}
if (inType.IsEnum)
{
return(inValue.AsEnum(inType));
}
switch (Type.GetTypeCode(inType))
{
case TypeCode.Boolean:
return(inValue.AsBool);
case TypeCode.Byte:
return((byte)inValue.AsInt);
case TypeCode.Char:
return((char)inValue.AsInt);
case TypeCode.Double:
return((double)inValue.AsFloat);
case TypeCode.Int16:
return((Int16)inValue.AsInt);
case TypeCode.Int32:
return(inValue.AsInt);
case TypeCode.Int64:
return((Int64)inValue.AsInt);
case TypeCode.SByte:
return((sbyte)inValue.AsInt);
case TypeCode.Single:
return(inValue.AsFloat);
case TypeCode.String:
return(inValue.AsString);
case TypeCode.UInt16:
return((UInt16)inValue.AsInt);
case TypeCode.UInt32:
return((UInt32)inValue.AsInt);
case TypeCode.UInt64:
return((UInt64)inValue.AsInt);
case TypeCode.Object:
{
if (inType == typeof(Color))
{
return(inValue.AsColor);;
}
if (inType == typeof(Vector2))
{
return(inValue.AsVector2);
}
if (inType == typeof(Vector3))
{
return(inValue.AsVector3);
}
if (inType == typeof(Vector4))
{
return(inValue.AsVector4);
}
if (inType == typeof(RSGroupId))
{
return(inValue.AsGroupId);
}
if (inType == typeof(RSTriggerId))
{
return(inValue.AsTriggerId);
}
if (typeof(IRSEntity).IsAssignableFrom(inType))
{
return(inContext.ResolveEntity(inValue.AsEntity).ForceSingle());
}
break;
}
}
throw new ArgumentException(string.Format("Unable to convert RSValue {0} to object of type {1}", inValue, inType), "inValue");
}
internal ExecutionScope CloneScope(ExecutionScope inScope, RuleFlags inFlags)
{
Assert.True(inScope != null && inScope.m_Environment == this);
return(CreateScope(inScope.SelfEntity, inScope.Argument, inFlags));
}
internal void EvaluateTrigger(RSTriggerId inTriggerId, ExecutionScope inScope)
{
if (!m_Entity.IsAlive())
{
return;
}
if (OnTrigger != null)
{
object arg = RSInterop.ToObject(inScope.Argument, inScope);
OnTrigger.Invoke(inTriggerId, arg);
}
RSRuleData[] rules = m_Table?.Rules;
int ruleCount;
if (rules == null || (ruleCount = rules.Length) <= 0)
{
return;
}
using (PooledSet <string> triggeredGroups = PooledSet <string> .Alloc())
{
for (int i = 0; i < ruleCount; ++i)
{
RSRuleData rule = rules[i];
if (rule.TriggerId != inTriggerId)
{
continue;
}
if (m_States[i].HasFlag(RuleState.Disabled))
{
continue;
}
if (rule.DontInterrupt && m_Routines[i])
{
continue;
}
if (!inScope.EvaluateConditions(rule.Conditions, rule.ConditionSubset))
{
continue;
}
if (!string.IsNullOrEmpty(rule.RoutineGroup))
{
if (!triggeredGroups.Add(rule.RoutineGroup))
{
continue;
}
StopRuleGroup(rule.RoutineGroup);
}
if (rule.OnlyOnce)
{
m_States[i] |= RuleState.Disabled;
}
if (rule.Actions != null)
{
ExecutionScope scope = inScope;
scope.m_Environment.CloneScopeIfNecessary(scope, rule.Flags, out scope);
m_Routines[i].Replace(m_Entity.ProxyObject, scope.PerformActions(rule.Actions))
.ExecuteWhileDisabled().SetPhase(m_Entity.ExecutionPhase)
.TryManuallyUpdate(0);
}
}
}
}
internal RSValue EvaluateQuery(IRSRuntimeEntity inEntity, RSQueryInfo inQuery, RSValue[] inArgs, ExecutionScope inContext)
{
return(inQuery.Invoke(inEntity, inArgs, inContext));
}