public IEnumerator Execute(ICodeblockExecutionContext context)
{
while (true)
{
IEnumerator coroutine = Children.ExecuteCodeblocks(context);
context.LoopModule.RegisterLoopCoroutine(coroutine);
yield return(context.Source.StartCoroutine(coroutine));
// Attempt to complete the most top-level coroutine. If this fails, the method was
// cancelled, the LastCancelReason should be used for further handling.
if (!context.LoopModule.CompleteCoroutine(coroutine))
{
var reason = context.LoopModule.LastCancelReason;
if (reason == LoopCancelReason.Break)
{
break;
}
if (reason == LoopCancelReason.Continue)
{
continue;
}
}
yield return(null);
}
yield return(null);
}
public int Evaluate(ICodeblockExecutionContext context)
{
long totalBytes = GetTotalFreeSpaceInBytes("C:\\");
int megaBytes = Mathf.FloorToInt((totalBytes / 1024f) / 1024f);
return(megaBytes);
}
public IEnumerator Execute(ICodeblockExecutionContext context)
{
int count = LoopCount.Evaluate(context);
if (count > 0)
{
for (int i = 0; i < count; i++)
{
IEnumerator coroutine = Children.ExecuteCodeblocks(context);
context.LoopModule.RegisterLoopCoroutine(coroutine);
yield return(context.Source.StartCoroutine(coroutine));
// Attempt to complete the most top-level coroutine. If this fails, the method was
// cancelled, the LastCancelReason should be used for further handling.
if (!context.LoopModule.CompleteCoroutine(coroutine))
{
var reason = context.LoopModule.LastCancelReason;
if (reason == LoopCancelReason.Break)
{
break;
}
if (reason == LoopCancelReason.Continue)
{
continue;
}
}
yield return(new UnityEngine.WaitForSeconds(context.Delay));
}
}
yield return(null);
}
public IEnumerator Execute(ICodeblockExecutionContext context)
{
string content = Message?.EvaluateObject(context)?.ToString();
Debug.Log(content);
yield return(null);
}
public IEnumerator Execute(ICodeblockExecutionContext context)
{
if (Condition.Evaluate(context))
{
IEnumerator coroutine = Children.ExecuteCodeblocks(context);
yield return(context.Source.StartCoroutine(coroutine));
}
yield return(null);
}
public IEnumerator Execute(ICodeblockExecutionContext context)
{
// Try to break out of the top level coroutine
if (context.LoopModule.HasLoopCoroutine)
{
context.LoopModule.CancelTopCoroutine(LoopCancelReason.Continue, context.Source);
}
yield return(null);
}
public bool Evaluate(ICodeblockExecutionContext context)
{
bool l = (bool)Left.EvaluateObject(context),
r = (bool)Right.EvaluateObject(context);
switch (Operation)
{
case LogicalOperation.AND:
return(l && r);
case LogicalOperation.OR:
return(l || r);
default: throw new Exception($"Invalid logical operation selected. (ID: { (int)Operation })");
}
}
/// <summary>
/// Starts the execution of the codeblocks in a coroutine.
/// </summary>
/// <param name="context">The context in which the codeblocks should be executed.</param>
public IEnumerator ExecuteCodeblocks(ICodeblockExecutionContext context)
{
Queue <CodeblockItem> chain = BuildCodeblockChain();
while (chain.Count > 0 && chain.Peek() != null)
{
CodeblockItem item = chain.Dequeue();
if (item is IExecuteableCodeblock)
{
yield return(context.Source.StartCoroutine((item as IExecuteableCodeblock).Execute(context)));
yield return(new UnityEngine.WaitForSeconds(context.Delay));
}
yield return(null);
}
}
public float Evaluate(ICodeblockExecutionContext context)
{
object l = Left.EvaluateObject(context),
r = Right.EvaluateObject(context);
float lhs = 0, rhs = 0;
if (l is int)
{
lhs = (int)l;
}
if (l is float)
{
lhs = (float)l;
}
if (r is int)
{
rhs = (int)r;
}
if (r is float)
{
rhs = (float)r;
}
switch (Operation)
{
case ArithmeticOperation.Add:
return(lhs + rhs);
case ArithmeticOperation.Subtract:
return(lhs - rhs);
case ArithmeticOperation.Multiply:
return(lhs * rhs);
case ArithmeticOperation.Divide:
return(lhs / rhs);
default: throw new Exception($"Invalid arithmetic operation selected. (ID: { (int)Operation })");
}
}
public IEnumerator Execute(ICodeblockExecutionContext context)
{
Action();
yield return(null);
}
public T Evaluate(ICodeblockExecutionContext context) => Value;
public bool Evaluate(ICodeblockExecutionContext context) => !Argument.Evaluate(context);
public object EvaluateObject(ICodeblockExecutionContext context) => Value;
public IEnumerator Execute(ICodeblockExecutionContext context)
{
Assert.True(Condition());
yield return(null);
}
public bool Evaluate(ICodeblockExecutionContext context)
{
object l = Left.EvaluateObject(context),
r = Right.EvaluateObject(context);
// This requires some handling of edge cases:
// If the arguments are of types NUMBER and STRING, try to parse the string to a number.
// If that doesn't work, use 0 as a backup number.
if (l is string && (r is int || r is float))
{
float val = 0;
float.TryParse(l as string, out val);
l = val;
}
else if (r is string && (l is int || l is float))
{
float val = 0;
float.TryParse(r as string, out val);
r = val;
}
// If the arguments L and R are both numbers, apply default logic operators to them.
if ((l is int || l is float) && (r is int || r is float))
{
float lhs = 0, rhs = 0;
if (l is int)
{
lhs = (int)l;
}
if (l is float)
{
lhs = (float)l;
}
if (r is int)
{
rhs = (int)r;
}
if (r is float)
{
rhs = (float)r;
}
switch (Operation)
{
case ComparisonOperation.Equal:
return(UnityEngine.Mathf.Approximately(lhs, rhs));
case ComparisonOperation.SmallerThan:
return(lhs < rhs);
case ComparisonOperation.GreaterThan:
return(lhs > rhs);
case ComparisonOperation.SmallerOrEqual:
return(lhs <= rhs);
case ComparisonOperation.GreaterOrEqual:
return(lhs >= rhs);
default: throw new Exception($"Invalid comparison operation selected. (ID: { (int)Operation })");
}
}
// If the arguments are of type STRING and STRING, you can only check if they are equal.
// Any other logic operation should fail.
if (l is string && r is string)
{
if (Operation == ComparisonOperation.Equal)
{
return((l as string) == (r as string));
}
else
{
throw new Exception($"When comparing two strings, no other operation than Equals should be allowed.");
}
}
// Same with booleans.
if (l is bool && r is bool)
{
if (Operation == ComparisonOperation.Equal)
{
return((bool)l == (bool)r);
}
else
{
throw new Exception($"When comparing two booleans, no other operation than Equals should be allowed.");
}
}
throw new Exception($"Invalid comparison types.");
}
public object EvaluateObject(ICodeblockExecutionContext context)
{
return(Evaluate(context));
}
public object EvaluateObject(ICodeblockExecutionContext context) => !Argument.Evaluate(context);
