public static void If(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters)
{
bool isTrue = (bool)parameters[0];
PseudocodeAction TrueDoSth = (PseudocodeAction)parameters[1];
PseudocodeAction FalseDoSth = (PseudocodeAction)parameters[2];
if (isTrue)
{
if (TrueDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(TrueDoSth.funcs),
() => { callback?.Invoke(null); });
}
else
{
callback?.Invoke(null);
}
}
else
{
if (FalseDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(FalseDoSth.funcs),
() => { callback?.Invoke(null); });
}
else
{
callback?.Invoke(null);
}
}
}
/// <summary>
/// 并行处理多个动作，非多线程
/// </summary>
public static void Parallel(Pseudocode Pseudocode, string funcName, Action <object> callback,
object[] parameters, object[] commonParameters)
{
var count = parameters.Length;
var cur = 0;
for (int i = 0; i < parameters.Length; i++)
{
PseudocodeAction act = (PseudocodeAction)parameters[i];
if (!act)
{
Debug.LogError("Parallel 方法只接受NewAction方法返回的参数！");
cur++;
if (cur == count)
{
// 全部并行处理完，再返回
callback?.Invoke(null);
}
continue;
}
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(act.funcs), () =>
{
// 单线程处理，不用担心
cur++;
if (cur == count)
{
// 全部并行处理完，再返回
callback?.Invoke(null);
}
}, commonParameters);
}
}
public static void While(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters)
{
if (parameters[0] is bool)
{
throw new Exception("定义While方法的条件参数，需要使用方法: NewFunc(表达式)");
}
PseudocodeFunc isTruePseudocodeFunc = (PseudocodeFunc)parameters[0];
PseudocodeAction LoopDoSth = (PseudocodeAction)parameters[1];
Pseudocode.Run(isTruePseudocodeFunc, () =>
{
if ((bool)isTruePseudocodeFunc.result)
{
if (LoopDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(LoopDoSth.funcs),
() => { While(Pseudocode, funcName, callback, parameters); });
}
else
{
callback?.Invoke(null);
}
}
else
{
callback?.Invoke(null);
}
});
}
/// <summary>
/// 指定循环次数连续做几次某事
/// </summary>
public static void Foreach(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters, object[] commonParameters)
{
IList <object> list = parameters[0].GetList();
var mList = list.ToList();
PseudocodeAction act = (PseudocodeAction)parameters[1];
string loopId = parameters.GetItem(2).GetStr();
if (mList.Count > 0)
{
if (act != null)
{
var one = mList[0];
if (loopId != null)
{
Pseudocode.vars[loopId] = one;
}
mList.RemoveAt(0);
parameters[0] = mList;
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(act.funcs),
() => { Foreach(Pseudocode, funcName, callback, parameters, commonParameters); }, commonParameters);
}
else
{
callback?.Invoke(null);
}
}
else
{
callback?.Invoke(null);
}
}
/// <summary>
/// 指定循环次数连续做几次某事
/// </summary>
public static void For(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters, object[] commonParameters)
{
int loopCount = parameters[0].GetInt();
PseudocodeAction LoopDoSth = (PseudocodeAction)parameters[1];
string loopId = parameters.GetItem(2).GetStr();
if (loopCount > 0)
{
loopCount--;
parameters[0] = loopCount;
if (loopId != null)
{
Pseudocode.vars[loopId] = loopCount;
}
if (LoopDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(LoopDoSth.funcs),
() => { For(Pseudocode, funcName, callback, parameters, commonParameters); }, commonParameters);
}
else
{
callback?.Invoke(null);
}
}
else
{
callback?.Invoke(null);
}
}
private static IEnumerator DelayCor(Pseudocode Pseudocode, string funcName, Action <object> callback,
float duration, PseudocodeAction act, object[] commonParameters)
{
yield return(new WaitForSeconds(duration));
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(act.funcs), () =>
{
callback?.Invoke(null);
}, commonParameters);
}
public static void Delay(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters, object[] commonParameters)
{
float duration = parameters[0].GetFloat();
PseudocodeAction LoopDoSth = (PseudocodeAction)parameters[1];
if (!LoopDoSth)
{
Debug.LogError("Loop 方法第3个参数只接受NewAction方法返回的参数！");
}
CoroutineHelper.Instance.StartCoroutine(DelayCor(Pseudocode, funcName, callback,
duration, LoopDoSth, commonParameters));
}
/// <summary>
/// 按固定时间周期做某事
/// </summary>
public static void Loop(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters, object[] commonParameters)
{
int loopCount = parameters[0].GetInt();
float startTime = parameters[1].GetFloat();
float duration = parameters[2].GetFloat();
PseudocodeAction LoopDoSth = (PseudocodeAction)parameters[3];
if (!LoopDoSth)
{
Debug.LogError("Loop 方法第4个参数只接受NewAction方法返回的参数！");
}
string loopId = parameters.GetItem(4).GetStr();
CoroutineHelper.Instance.StartCoroutine(LoopCor(Pseudocode, funcName, callback,
loopCount, startTime, duration, LoopDoSth, loopId, commonParameters));
}
public static void IF(Pseudocode Pseudocode, string funcName, Action <object> callback, object[] parameters, object[] commonParameters)
{
if (parameters[0] is bool)
{
throw new Exception("定义IF方法的条件参数，需要使用方法: NewFunc(表达式)");
}
PseudocodeFunc isTruePseudocodeFunc = (PseudocodeFunc)parameters[0];
PseudocodeAction TrueDoSth = (PseudocodeAction)parameters[1];
PseudocodeAction FalseDoSth = (PseudocodeAction)parameters[2];
Pseudocode.Run(isTruePseudocodeFunc, () =>
{
if ((bool)isTruePseudocodeFunc.result)
{
if (TrueDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(TrueDoSth.funcs),
() => { callback?.Invoke(null); }, commonParameters);
}
else
{
callback?.Invoke(null);
}
}
else
{
if (FalseDoSth != null)
{
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(FalseDoSth.funcs),
() => { callback?.Invoke(null); }, commonParameters);
}
else
{
callback?.Invoke(null);
}
}
});
}
private static IEnumerator LoopCor(Pseudocode Pseudocode, string funcName, Action <object> callback,
int loopCount, float startTime, float duration, PseudocodeAction act, string loopId, object[] commonParameters)
{
yield return(new WaitForSeconds(startTime));
var cur = 0;
while (cur < loopCount || loopCount == -1)
{
if (loopId != null)
{
Pseudocode.vars[loopId] = cur;
}
cur++;
Pseudocode.RunQueue(Pseudocode.GetFuncParamFuncsQueue(act.funcs), () =>
{
// 单线程处理，不用担心
}, commonParameters);
yield return(new WaitForSeconds(duration));
}
callback?.Invoke(null);
}
