public IEnumerable <AIResult> Selector(AIExecutionContext context)
{
bool succeedOut = false;
foreach (var child in context.children)
{
foreach (var result in child.Call(context))
{
if (result == AIResult.Running)
{
yield return(AIResult.Running);
}
else if (result == AIResult.Success)
{
succeedOut = true;
}
else if (result == AIResult.Failure)
{
continue;
}
if (succeedOut)
{
break;
}
}
if (succeedOut)
{
break;
}
}
yield return(succeedOut ? AIResult.Success : AIResult.Failure);
}
public IEnumerable <AIResult> PrintMemoryCell(AIExecutionContext context, object cell)
{
Debug.Log($"Printing Cell: {cell?.ToString()}");
if (cell != null)
{
yield return(AIResult.Success);
}
else
{
yield return(AIResult.Failure);
}
}
public IEnumerable <AIResult> Running(AIExecutionContext context, int frameCount, float timeCount)
{
var children = context.children;
var log = context.log;
var memoryMap = context.memoryMap;
var gameObject = context.gameObject;
float startTime = Time.time;
for (int i = 0; i < frameCount; i++)
{
yield return(AIResult.Running);
}
while (Time.time <= startTime + timeCount)
{
yield return(AIResult.Running);
}
if (children.Length > 0)
{
var firstChild = children[0];
if (firstChild != null)
{
bool breakChildLoop = false;
foreach (var result in firstChild.Call(context))
{
switch (result)
{
case AIResult.Success:
case AIResult.Failure:
yield return(result);
breakChildLoop = true;
break;
case AIResult.Running:
yield return(AIResult.Running);
break;
}
if (breakChildLoop)
{
break;
}
}
}
}
}
public IEnumerable <AIResult> Succeed(AIExecutionContext context)
{
foreach (var child in context.children)
{
foreach (var result in child.Call(context))
{
if (result == AIResult.Running)
{
yield return(result);
}
}
}
yield return(AIResult.Success);
}
public IEnumerable <AIResult> Loop(AIExecutionContext context, int count)
{
var children = context.children;
var log = context.log;
var memoryMap = context.memoryMap;
var gameObject = context.gameObject;
bool failBreak = false;
for (int i = 0; i < count; i++)
{
foreach (var child in children)
{
foreach (var result in child.Call(context))
{
switch (result)
{
case AIResult.Success:
continue;
case AIResult.Failure:
failBreak = true;
break;
case AIResult.Running:
yield return(AIResult.Running);
break;
}
if (failBreak)
{
break;
}
}
if (failBreak)
{
break;
}
}
if (failBreak)
{
break;
}
}
yield return(failBreak ? AIResult.Failure : AIResult.Success);
}
public IEnumerable <AIResult> Call(AIExecutionContext context)
{
context = new AIExecutionContext(context.gameObject, context.log, children, context.memoryMap);
context.log.AppenTreeNode(guid);
var itterator = methodBinding.Bind <AIResult>(context.gameObject, context.memoryMap, context.log, ("context", context));
foreach (var value in itterator)
{
if (value == AIResult.Success || value == AIResult.Failure)
{
yield return(value);
break;
}
else if (value == AIResult.Running)
{
yield return(AIResult.Running);
}
}
}
private IEnumerable <AIResult> ProcessIfThenChild(AITreeNode node, AIExecutionContext context)
{
if (node == null)
{
yield return(AIResult.Failure);
}
bool breakLoop = false;
foreach (var result in node.Call(context))
{
switch (result)
{
case AIResult.Success:
yield return(AIResult.Success);
breakLoop = true;
break;
case AIResult.Failure:
yield return(AIResult.Failure);
breakLoop = true;
break;
case AIResult.Running:
yield return(AIResult.Running);
break;
}
if (breakLoop)
{
break;
}
}
}
public IEnumerable <AIResult> IfElse(AIExecutionContext context)
{
GameObject gameObject = context.gameObject;
AITreeNode[] children = context.children;
AIExecutionLog log = context.log;
IReadOnlyDictionary <object, object> memoryMap = context.memoryMap;
AITreeNode ifChild = null, thenChild = null, elseChild = null;
if (children.Length >= 1)
{
ifChild = children[0];
}
if (children.Length >= 2)
{
thenChild = children[1];
}
if (children.Length >= 3)
{
elseChild = children[2];
}
bool?success = false;
if (ifChild != null)
{
bool breakIfElseLoop = false;
foreach (var result in ifChild.Call(context))
{
switch (result)
{
case AIResult.Success:
success = true;
breakIfElseLoop = true;
break;
case AIResult.Failure:
success = false;
breakIfElseLoop = true;
break;
case AIResult.Running:
break;
}
if (breakIfElseLoop)
{
break;
}
}
}
if (success == null)
{
yield return(AIResult.Failure);
}
else
{
foreach (var result in ProcessIfThenChild(success.Value ? thenChild : elseChild, context))
{
// Process if then child method will ensure appropriate returns
yield return(result);
}
}
}
public IEnumerable <AIResult> Call(AIExecutionContext context, AITreeAsset asset, params (string argName, object argValue)[] arguments)
public IEnumerable <AIResult> Failure(AIExecutionContext context)
{
Debug.Log("Failure");
yield return(AIResult.Failure);
}
