public override object Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject)
{
if (this.A() == null)
{
Log.Error("LogicCallAsIsMethodAction: Execute: CastType = null");
return(null);
}
object obj;
if (this.abN)
{
if (this.A().IsAssignableFrom(thisObject.GetType()))
{
obj = thisObject;
}
else
{
obj = null;
}
}
else
{
obj = this.A().IsAssignableFrom(thisObject.GetType());
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject)
{
if (this.EventInfo == null)
{
Log.Error("LogicEventAction: Error: event \"{0}\" not exists", this.EventName);
return(null);
}
MethodInfo methodInfo = null;
Type logicSystemScriptsAssemblyClassByClassName = EntitySystemWorld.Instance.GetLogicSystemScriptsAssemblyClassByClassName(base.ParentMethod.ParentClass.ClassName);
try
{
methodInfo = logicSystemScriptsAssemblyClassByClassName.GetMethod(this.MethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
catch
{
}
if (methodInfo == null)
{
Log.Error("LogicEventAction: Error: method \"{0}\" not exists ", this.MethodName);
return(null);
}
MethodInfo addMethod = this.EventInfo.GetAddMethod();
Type parameterType = addMethod.GetParameters()[0].ParameterType;
object logicEntityObject = executeMethodInformation.LogicEntityObject;
Delegate @delegate = Delegate.CreateDelegate(parameterType, logicEntityObject, methodInfo);
addMethod.Invoke(thisObject, new object[]
{
@delegate
});
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject)
{
object obj;
if (!string.IsNullOrEmpty(base.MethodName))
{
if (this.SystemMethod == null)
{
Log.Error("LogicCallNonStaticMethodAction: Execute: method not exists \"{0}\"", base.MethodName);
return(null);
}
object[] array = new object[(base.ParameterActions != null) ? base.ParameterActions.Length : 0];
for (int i = 0; i < array.Length; i++)
{
if (base.ParameterActions[i] != null)
{
array[i] = base.ParameterActions[i].Execute(executeMethodInformation);
}
}
obj = this.SystemMethod.Invoke(thisObject, array);
}
else
{
if (string.IsNullOrEmpty(base.PropertyName))
{
Log.Fatal("LogicCallNonStaticMethodAction: Execute: not implemented");
return(null);
}
if (this.SystemProperty == null)
{
Log.Error("LogicCallNonStaticMethodAction: Execute: property not exists \"{0}\"", base.PropertyName);
return(null);
}
object[] array2 = null;
if (base.ParameterActions != null)
{
array2 = new object[base.ParameterActions.Length];
for (int j = 0; j < array2.Length; j++)
{
if (base.ParameterActions[j] != null)
{
array2[j] = base.ParameterActions[j].Execute(executeMethodInformation);
}
}
}
if (base.DotPathAction != null && base.DotPathAction is LogicAssignPropertyAction)
{
((LogicAssignPropertyAction)base.DotPathAction).Execute(executeMethodInformation, thisObject, array2, this.SystemProperty);
return(null);
}
obj = this.SystemProperty.GetValue(thisObject, array2);
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public void Execute(LogicExecuteMethodInformation executeMethodInformation, LogicLocalVariable localVariable)
{
if (this.abj != null)
{
object value = this.abj.Execute(executeMethodInformation);
localVariable.Value = value;
return;
}
localVariable.Value = null;
}
public void Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject, object[] parameters, PropertyInfo propertyInfo)
{
if (this.abJ != null)
{
object value = this.abJ.Execute(executeMethodInformation);
propertyInfo.SetValue(thisObject, value, parameters);
return;
}
propertyInfo.SetValue(thisObject, null, parameters);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
object result = null;
if (this.abA != null)
{
result = this.abA.Execute(executeMethodInformation);
}
executeMethodInformation.NeedReturn = true;
return(result);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
LogicLocalVariable logicLocalVariable = executeMethodInformation.DeclareLocalVariable(this);
if (logicLocalVariable == null)
{
return(null);
}
if (this.abD != null)
{
logicLocalVariable.Value = this.abD.Execute(executeMethodInformation);
}
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (this.abT == null)
{
Log.Error("LogicCallGetEntityMethodAction: entity = null");
return(null);
}
object obj = this.abT;
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public void Execute(LogicExecuteMethodInformation executeMethodInformation, LogicVariable variable)
{
object value;
if (this.abj != null)
{
value = this.abj.Execute(executeMethodInformation);
}
else
{
value = null;
}
FieldInfo field = executeMethodInformation.LogicClassType.GetField(variable.VariableName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
field.SetValue(executeMethodInformation.LogicEntityObject, value);
}
public object Execute(Type staticClassType, object[] parameterValues)
{
if (staticClassType == null)
{
Log.Fatal("LogicDesignedMethod: staticClassType = null");
return(null);
}
LogicExecuteMethodInformation logicExecuteMethodInformation = new LogicExecuteMethodInformation(this, staticClassType);
if (!this.A(logicExecuteMethodInformation, parameterValues))
{
return(null);
}
return(this.A(logicExecuteMethodInformation));
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (string.IsNullOrEmpty(this.abo))
{
Log.Error("LogicCallStaticUserMethodAction: class not defined \"{0}\"");
return(null);
}
if (this.A() == null)
{
Log.Error("LogicCallStaticUserMethodAction: class not exists \"{0}\"", this.abo);
return(null);
}
if (string.IsNullOrEmpty(base.MethodName))
{
Log.Fatal("LogicCallStaticUserMethodAction: Execute: not implemented");
return(null);
}
if (this.a() == null)
{
Log.Error("LogicCallStaticUserMethodAction: class method not exists \"{0}.{1}\"", this.abo, base.MethodName);
return(null);
}
object[] array = new object[base.ParameterActions.Length];
for (int i = 0; i < array.Length; i++)
{
if (base.ParameterActions[i] != null)
{
array[i] = base.ParameterActions[i].Execute(executeMethodInformation);
}
}
Type logicSystemScriptsAssemblyClassByClassName = EntitySystemWorld.Instance.GetLogicSystemScriptsAssemblyClassByClassName(this.ClassName);
if (logicSystemScriptsAssemblyClassByClassName == null)
{
Log.Fatal("LogicCallStaticUserMethodAction: class not exists \"{0}\"", this.ClassName);
return(null);
}
MethodInfo method = logicSystemScriptsAssemblyClassByClassName.GetMethod(base.MethodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
object obj = method.Invoke(null, array);
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (string.IsNullOrEmpty(this.abm))
{
Log.Error("Get Variable: variableName not defined");
return(null);
}
object obj = null;
LogicVariable variableByName = base.ParentMethod.ParentClass.GetVariableByName(this.abm);
if (variableByName != null)
{
if (base.DotPathAction != null && base.DotPathAction is LogicAssignVariableAction)
{
((LogicAssignVariableAction)base.DotPathAction).Execute(executeMethodInformation, variableByName);
return(null);
}
FieldInfo field = executeMethodInformation.LogicClassType.GetField(variableByName.VariableName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
obj = field.GetValue(executeMethodInformation.LogicEntityObject);
}
LogicLocalVariable logicLocalVariable = null;
if (variableByName == null)
{
logicLocalVariable = executeMethodInformation.GetLocalVariable(this.abm);
if (logicLocalVariable != null)
{
if (base.DotPathAction != null && base.DotPathAction is LogicAssignVariableAction)
{
((LogicAssignVariableAction)base.DotPathAction).Execute(executeMethodInformation, logicLocalVariable);
return(null);
}
obj = logicLocalVariable.Value;
}
}
if (variableByName == null && logicLocalVariable == null)
{
Log.Error("Get Variable: variable not exists \"{0}\"", this.abm);
return(null);
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
object obj;
if (!this.abq)
{
if (this.LogicMethod == null)
{
Log.Error("LogicCallThisMethodAction: class method not exists \"{0}\"", "null");
return(null);
}
MethodInfo method = executeMethodInformation.LogicClassType.GetMethod(this.abQ.MethodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (method == null)
{
Log.Fatal("LogicCallThisMethodAction: MethodInfo = null");
return(null);
}
object[] array = new object[base.ParameterActions.Length];
for (int i = 0; i < array.Length; i++)
{
if (base.ParameterActions[i] != null)
{
array[i] = base.ParameterActions[i].Execute(executeMethodInformation);
}
}
obj = method.Invoke(executeMethodInformation.LogicEntityObject, array);
}
else
{
PropertyInfo property = executeMethodInformation.LogicClassType.GetProperty("Owner", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property == null)
{
Log.Fatal("LogicCallThisMethodAction: propertyInfo = null");
return(null);
}
obj = property.GetValue(executeMethodInformation.LogicEntityObject, null);
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
private bool A(LogicExecuteMethodInformation logicExecuteMethodInformation, object[] array)
{
for (int i = 0; i < base.Parameters.Count; i++)
{
LogicParameter logicParameter = base.Parameters[i];
object obj = array[i];
if (!logicParameter.parameterType.IsAssignableFrom((obj != null) ? obj.GetType() : null))
{
Log.Error("Method: invalid parameter value type \"{0}\"", logicParameter.ParameterName);
return(false);
}
if (!string.IsNullOrEmpty(logicParameter.ParameterName))
{
LogicLocalVariable logicLocalVariable = logicExecuteMethodInformation.DeclareLocalVariable(logicParameter);
logicLocalVariable.Value = obj;
}
}
return(true);
}
internal bool A(TextBlock textBlock)
{
TextBlock textBlock2 = textBlock.FindChild("waitItems");
if (textBlock2 != null)
{
foreach (TextBlock current in textBlock2.Children)
{
LogicEntityObject.WaitingThreadItem waitingThreadItem = new LogicEntityObject.WaitingThreadItem();
if (current.IsAttributeExist("threadName"))
{
waitingThreadItem.ThreadName = current.GetAttribute("threadName");
}
if (current.IsAttributeExist("remainingTime"))
{
waitingThreadItem.RemainingTime = float.Parse(current.GetAttribute("remainingTime"));
}
TextBlock textBlock3 = current.FindChild("executeMethodInformations");
if (textBlock3 != null)
{
waitingThreadItem.currentExecutingMethodInformations = new List <LogicExecuteMethodInformation>();
foreach (TextBlock current2 in textBlock3.Children)
{
LogicExecuteMethodInformation logicExecuteMethodInformation = new LogicExecuteMethodInformation();
if (!logicExecuteMethodInformation.A(current2))
{
return(false);
}
waitingThreadItem.currentExecutingMethodInformations.Add(logicExecuteMethodInformation);
}
}
this.waitintThreads.Add(waitingThreadItem);
}
}
if (this.waitintThreads.Count != 0)
{
this.ownerEntity.SubscribeToTickEvent();
}
return(true);
}
public object Execute(LogicEntityObject logicEntityObject, object[] parameterValues)
{
if (logicEntityObject == null)
{
Log.Fatal("LogicDesignedMethod: logicEntityObject = null");
return(null);
}
LogicExecuteMethodInformation logicExecuteMethodInformation;
if (logicEntityObject.GetCurrentExecutingMethodInformations() != null && logicEntityObject.GetCurrentExecutingMethodLevel() + 1 < logicEntityObject.GetCurrentExecutingMethodInformations().Count)
{
logicExecuteMethodInformation = logicEntityObject.GetCurrentExecutingMethodInformations()[logicEntityObject.GetCurrentExecutingMethodLevel() + 1];
}
else
{
logicExecuteMethodInformation = new LogicExecuteMethodInformation(this, logicEntityObject);
if (!this.A(logicExecuteMethodInformation, parameterValues))
{
return(null);
}
}
object result;
if (logicEntityObject.GetCurrentExecutingMethodInformations() == null)
{
logicEntityObject.SetCurrentExecutingMethodInformations(new List <LogicExecuteMethodInformation>());
result = this.A(logicExecuteMethodInformation);
logicEntityObject.SetCurrentExecutingMethodInformations((List <LogicExecuteMethodInformation>)null);
}
else
{
result = this.A(logicExecuteMethodInformation);
}
return(result);
}
internal object A(LogicExecuteMethodInformation logicExecuteMethodInformation)
{
LogicEntityObject logicEntityObject = logicExecuteMethodInformation.LogicEntityObject;
bool flag = false;
int num = 0;
if (logicEntityObject != null)
{
LogicEntityObject expr_0F = logicEntityObject;
expr_0F.SetCurrentExecutingMethodLevel(expr_0F.GetCurrentExecutingMethodLevel() + 1);
if (logicEntityObject.GetCurrentExecutingMethodLevel() >= logicEntityObject.GetCurrentExecutingMethodInformations().Count)
{
logicEntityObject.GetCurrentExecutingMethodInformations().Add(logicExecuteMethodInformation);
}
else
{
if (logicEntityObject.GetCurrentExecutingMethodInformations()[logicEntityObject.GetCurrentExecutingMethodLevel()] != logicExecuteMethodInformation)
{
Log.Fatal("LogicDesignerMethod: Internal error: Execute: logicEntityObject.CurrentExecutingMethodInformations[logicEntityObject.CurrentExecutingMethodLevel] != executeMethodInformation");
}
flag = true;
num = logicExecuteMethodInformation.CallActionsLevelIndexes[logicExecuteMethodInformation.CurrentClassActionsLevelIndex];
}
}
object result = null;
for (int i = num; i < this.actions.Count; i++)
{
LogicAction logicAction = this.actions[i];
if (!flag)
{
logicExecuteMethodInformation.PushCallActionsLevelIndex(i);
}
flag = false;
logicExecuteMethodInformation.CurrentClassActionsLevelIndex++;
object obj = logicAction.Execute(logicExecuteMethodInformation);
logicExecuteMethodInformation.CurrentClassActionsLevelIndex--;
if (logicExecuteMethodInformation.NeedReturnForWait)
{
if (logicEntityObject != null)
{
LogicEntityObject expr_C7 = logicEntityObject;
expr_C7.SetCurrentExecutingMethodLevel(expr_C7.GetCurrentExecutingMethodLevel() - 1);
}
return(null);
}
logicExecuteMethodInformation.PopCallActionsLevelIndex();
if (LogicUtils.A() != 0f)
{
logicExecuteMethodInformation.PushCallActionsLevelIndex(i + 1);
if (logicExecuteMethodInformation.LogicEntityObject != null)
{
logicExecuteMethodInformation.LogicEntityObject.CreateWaitingThreadItem(LogicUtils.a(), LogicUtils.A());
}
LogicUtils.A(0f);
LogicUtils.A("");
if (logicEntityObject != null)
{
LogicEntityObject expr_128 = logicEntityObject;
expr_128.SetCurrentExecutingMethodLevel(expr_128.GetCurrentExecutingMethodLevel() - 1);
}
return(null);
}
if (logicExecuteMethodInformation.NeedReturn)
{
result = obj;
break;
}
}
if (logicExecuteMethodInformation.LogicEntityObject != null)
{
logicExecuteMethodInformation.LogicEntityObject.GetCurrentExecutingMethodInformations().RemoveAt(logicExecuteMethodInformation.LogicEntityObject.GetCurrentExecutingMethodInformations().Count - 1);
}
if (logicEntityObject != null)
{
LogicEntityObject expr_18A = logicEntityObject;
expr_18A.SetCurrentExecutingMethodLevel(expr_18A.GetCurrentExecutingMethodLevel() - 1);
}
return(result);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (this.abf == null)
{
Log.Error("LogicWhileAction: ConditionAction = null");
return(null);
}
LogicEntityObject logicEntityObject = executeMethodInformation.LogicEntityObject;
bool flag = false;
int num = 0;
bool flag2;
if (logicEntityObject != null)
{
if (executeMethodInformation.CurrentClassActionsLevelIndex < executeMethodInformation.CallActionsLevelIndexes.Count)
{
flag = true;
num = executeMethodInformation.CallActionsLevelIndexes[executeMethodInformation.CurrentClassActionsLevelIndex];
flag2 = true;
}
else
{
flag2 = (bool)this.abf.Execute(executeMethodInformation);
}
}
else
{
flag2 = (bool)this.abf.Execute(executeMethodInformation);
}
while (flag2)
{
for (int i = num; i < this.abG.Count; i++)
{
LogicAction logicAction = this.abG[i];
if (!flag)
{
executeMethodInformation.PushCallActionsLevelIndex(i);
}
flag = false;
executeMethodInformation.CurrentClassActionsLevelIndex++;
object result = logicAction.Execute(executeMethodInformation);
executeMethodInformation.CurrentClassActionsLevelIndex--;
if (executeMethodInformation.NeedReturnForWait)
{
return(null);
}
executeMethodInformation.PopCallActionsLevelIndex();
if (LogicUtils.A() != 0f)
{
executeMethodInformation.PushCallActionsLevelIndex(i + 1);
if (executeMethodInformation.LogicEntityObject != null)
{
executeMethodInformation.LogicEntityObject.CreateWaitingThreadItem(LogicUtils.a(), LogicUtils.A());
}
LogicUtils.A(0f);
LogicUtils.A("");
return(null);
}
if (executeMethodInformation.NeedReturn)
{
return(result);
}
}
num = 0;
flag2 = (bool)this.abf.Execute(executeMethodInformation);
}
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
return(null);
}
public virtual object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
Log.Fatal("LogicAction: Execute");
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject)
{
Log.Fatal("LogicCallThisMethodAction: Execute: internal error");
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (string.IsNullOrEmpty(this.abR))
{
Log.Error("LogicCallStaticSystemMethodAction: class not defined \"{0}\"");
return(null);
}
if (this.A() == null)
{
Log.Error("LogicCallStaticSystemMethodAction: class not exists \"{0}\"", this.abR);
return(null);
}
object obj;
if (!string.IsNullOrEmpty(base.MethodName))
{
if (this.SystemMethod == null)
{
Log.Error("LogicCallStaticSystemMethodAction: class method not exists \"{0}.{1}\"", this.abR, base.MethodName);
return(null);
}
object[] array = new object[(base.ParameterActions != null) ? base.ParameterActions.Length : 0];
for (int i = 0; i < array.Length; i++)
{
if (base.ParameterActions[i] != null)
{
array[i] = base.ParameterActions[i].Execute(executeMethodInformation);
}
}
if (!this.abr.CallStaticOverInstance)
{
obj = this.SystemMethod.Invoke(null, array);
}
else
{
object value = this.abr.CallStaticOverInstanceProperty.GetValue(null, null);
obj = this.SystemMethod.Invoke(value, array);
}
}
else
{
if (string.IsNullOrEmpty(base.PropertyName))
{
Log.Fatal("LogicCallStaticSystemMethodAction: Execute: not implemented");
return(null);
}
if (this.SystemProperty == null)
{
Log.Error("LogicCallStaticSystemMethodAction: Execute: property not exists \"{0}\"", base.PropertyName);
return(null);
}
object[] array2 = null;
if (base.ParameterActions != null)
{
array2 = new object[base.ParameterActions.Length];
for (int j = 0; j < array2.Length; j++)
{
if (base.ParameterActions[j] != null)
{
array2[j] = base.ParameterActions[j].Execute(executeMethodInformation);
}
}
}
if (!this.abr.CallStaticOverInstance)
{
obj = this.SystemProperty.GetValue(null, array2);
}
else
{
object value2 = this.abr.CallStaticOverInstanceProperty.GetValue(null, null);
if (base.DotPathAction != null && base.DotPathAction is LogicAssignPropertyAction)
{
((LogicAssignPropertyAction)base.DotPathAction).Execute(executeMethodInformation, value2, array2, this.SystemProperty);
return(null);
}
obj = this.SystemProperty.GetValue(value2, array2);
}
}
if (base.DotPathAction != null)
{
obj = base.DotPathAction.Execute(executeMethodInformation, obj);
}
return(obj);
}
public virtual object Execute(LogicExecuteMethodInformation executeMethodInformation, object thisObject)
{
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
if (this.aba == null)
{
Log.Error("LogicIfThenElseAction: ConditionAction = null");
return(null);
}
LogicEntityObject logicEntityObject = executeMethodInformation.LogicEntityObject;
bool flag = false;
int num = 0;
bool flag2;
if (logicEntityObject != null)
{
if (executeMethodInformation.CurrentClassActionsLevelIndex < executeMethodInformation.CallActionsLevelIndexes.Count)
{
flag = true;
num = executeMethodInformation.CallActionsLevelIndexes[executeMethodInformation.CurrentClassActionsLevelIndex];
flag2 = (num < 10000);
if (num >= 10000)
{
num -= 10000;
}
}
else
{
flag2 = (bool)this.aba.Execute(executeMethodInformation);
}
}
else
{
flag2 = (bool)this.aba.Execute(executeMethodInformation);
}
List <LogicAction> list = flag2 ? this.abB : this.abb;
for (int i = num; i < list.Count; i++)
{
LogicAction logicAction = list[i];
if (!flag)
{
executeMethodInformation.PushCallActionsLevelIndex(flag2 ? i : (i + 10000));
}
flag = false;
executeMethodInformation.CurrentClassActionsLevelIndex++;
object result = logicAction.Execute(executeMethodInformation);
executeMethodInformation.CurrentClassActionsLevelIndex--;
if (executeMethodInformation.NeedReturnForWait)
{
return(null);
}
executeMethodInformation.PopCallActionsLevelIndex();
if (LogicUtils.A() != 0f)
{
executeMethodInformation.PushCallActionsLevelIndex((flag2 ? i : (i + 10000)) + 1);
if (executeMethodInformation.LogicEntityObject != null)
{
executeMethodInformation.LogicEntityObject.CreateWaitingThreadItem(LogicUtils.a(), LogicUtils.A());
}
LogicUtils.A(0f);
LogicUtils.A("");
return(null);
}
if (executeMethodInformation.NeedReturn)
{
return(result);
}
}
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
Log.Fatal("LogicAssignPropertyAction: Execute: internal error");
return(null);
}
public override object Execute(LogicExecuteMethodInformation executeMethodInformation)
{
return(this.aBX);
}
