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); }