public LoadBalancedUtilityAIClient(IUtilityAI ai, IContextProvider contextProvider, float executionIntervalMin, float executionIntervalMax, float startDelayMin, float startDelayMax) : base(ai, contextProvider)
{
this.executionIntervalMin = executionIntervalMin;
this.executionIntervalMax = executionIntervalMax;
this.startDelayMin = startDelayMin;
this.startDelayMax = startDelayMax;
}
private ITask FindTaskOfQualifier()
{
if (this._task == null)
{
SelectorAction selectorAction = base.action as SelectorAction;
if (selectorAction != null && selectorAction.selector != null)
{
this._task = selectorAction.selector as ITask;
if (this._task != null)
{
return(this._task);
}
}
AILinkAction aILinkAction = base.action as AILinkAction;
if (aILinkAction != null)
{
IUtilityAI aI = AIManager.GetAI(aILinkAction.aiId);
if (aI.rootSelector is ITask)
{
this._task = aI.rootSelector as ITask;
ITask task = this._task;
return(this._task);
}
}
}
return(this._task);
}
internal void InitAI()
{
if (_ai == null)
{
_ai = _visualizedAI = new UtilityAI();
}
}
internal UtilityAIVisualizer(IUtilityAI ai)
{
_ai = ai;
var selectorCount = ai.selectorCount;
_selectorVisualizers = new List <SelectorVisualizer>(ai.selectorCount);
for (int i = 0; i < selectorCount; i++)
{
var selector = _ai[i];
var selectorVisualizer = new SelectorVisualizer(selector, this);
_selectorVisualizers.Add(selectorVisualizer);
if (object.ReferenceEquals(selector, _ai.rootSelector))
{
_visualizerRootSelector = selectorVisualizer;
}
}
for (int i = 0; i < selectorCount; i++)
{
_selectorVisualizers[i].Init();
}
_postExecute = new List <Action>(1);
}
protected UtilityAIClient(IUtilityAI ai, IContextProvider contextProvider)
{
Ensure.ArgumentNotNull(ai, "ai");
Ensure.ArgumentNotNull(contextProvider, "contextProvider");
this._ai = ai;
this._contextProvider = contextProvider;
this.state = UtilityAIClientState.Stopped;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Apex.AI.Components.ZenAIClient" /> class.
/// </summary>
/// <param name="ai">The AI.</param>
/// <param name="contextProvider">The context provider.</param>
/// <param name="executionIntervalMin">The minimum execution interval in seconds.</param>
/// <param name="executionIntervalMax">The maximum execution interval in seconds.</param>
/// <param name="startDelayMin">The minimum number of seconds to delay the initial execution of the AI.</param>
/// <param name="startDelayMax">The maximum number of seconds to delay the initial execution of the AI.</param>
public ZenAIClient(IUtilityAI ai, IContextProvider contextProvider, float executionIntervalMin = 1f,
float executionIntervalMax = 1f, float startDelayMin = 0.0f, float startDelayMax = 0.0f)
: base(ai, contextProvider)
{
this.executionIntervalMin = executionIntervalMin;
this.executionIntervalMax = executionIntervalMax;
this.startDelayMin = startDelayMin;
this.startDelayMax = startDelayMax;
}
public static bool ExecuteAI(Guid id, IAIContext context)
{
IUtilityAI aI = AIManager.GetAI(id);
if (aI == null)
{
return(false);
}
return(aI.ExecuteOnce(context));
}
protected UtilityAIClient(Guid aiId, IContextProvider contextProvider)
{
Ensure.ArgumentNotNull(contextProvider, "contextProvider");
this._ai = AIManager.GetAI(aiId);
if (this._ai == null)
{
throw new ArgumentException("Unable to load associated AI.", "aiId");
}
this._contextProvider = contextProvider;
this.state = UtilityAIClientState.Stopped;
}
private bool LoadFrom(AIStorage data, bool refreshState)
{
_aiStorage = data;
try
{
if (EditorApplication.isPlaying)
{
_ai = _visualizedAI = AIManager.GetAI(new Guid(data.aiId));
}
else
{
_ai = _visualizedAI = SerializationMaster.Deserialize <UtilityAI>(_aiStorage.configuration);
}
this.canvas = GuiSerializer.Deserialize(this, _aiStorage.editorConfiguration);
}
catch (Exception e)
{
if (EditorUtility.DisplayDialog("Load Error", "The AI could not be loaded, deserialization failed - see the console for details.\n\nDo you wish to open the AI repair tool?.", "Yes", "No"))
{
RepairWindow.ShowWindow(data.name, data.aiId);
}
Debug.LogWarning("Failed to load AI: " + e.Message);
return(false);
}
var selectorViews = this.canvas.selectorViews.ToArray();
int selectorCount = _ai.selectorCount;
if (!VerifyCountMatch(selectorCount, selectorViews.Length))
{
return(false);
}
for (int i = 0; i < selectorCount; i++)
{
if (!selectorViews[i].Reconnect(_ai[i]))
{
return(false);
}
}
if (refreshState)
{
this.inspectorState.Refresh();
}
return(true);
}
internal override void Init()
{
IUtilityAI utilityAI = ((AILinkAction)base.action).linkedAI;
if (utilityAI != null)
{
List <UtilityAIVisualizer> utilityAIVisualizers = base.parent.parent.parent.linkedAIs;
this._linkedAI = utilityAIVisualizers.FirstOrDefault <UtilityAIVisualizer>((UtilityAIVisualizer lai) => lai.id == utilityAI.id);
if (this._linkedAI == null)
{
this._linkedAI = new UtilityAIVisualizer(utilityAI);
utilityAIVisualizers.Add(this._linkedAI);
}
}
}
/// <summary>
/// Executes an AI once.
/// </summary>
/// <param name="ai">The AI.</param>
/// <param name="context">The context.</param>
/// <returns><c>true</c> if an action was selected and executed; otherwise <c>false</c></returns>
public static bool ExecuteOnce(this IUtilityAI ai, IAIContext context)
{
var action = ai.Select(context);
bool finalActionFound = false;
bool actionExecuted = false;
while (!finalActionFound)
{
//While we could treat all connectors the same, most connectors will not have anything to execute, so this way we save the call to Execute.
var composite = action as ICompositeAction;
if (composite == null)
{
var connector = action as IConnectorAction;
if (connector == null)
{
finalActionFound = true;
}
else
{
action = connector.Select(context);
}
}
else
{
//For composites that also connect, we execute the child actions before moving on.
//So action is executed and then reassigned to the selected action if one exists.
action.Execute(context);
action = composite.Select(context);
finalActionFound = (action == null);
actionExecuted = true;
}
}
if (action != null)
{
action.Execute(context);
actionExecuted = true;
}
return(actionExecuted);
}
internal UtilityAIVisualizer(IUtilityAI ai)
{
this._ai = ai;
int num = ai.selectorCount;
this._selectorVisualizers = new List <SelectorVisualizer>(ai.selectorCount);
for (int i = 0; i < num; i++)
{
Selector item = this._ai[i];
SelectorVisualizer selectorVisualizer = new SelectorVisualizer(item, this);
this._selectorVisualizers.Add(selectorVisualizer);
if (item == this._ai.rootSelector)
{
this._visualizerRootSelector = selectorVisualizer;
}
}
for (int j = 0; j < num; j++)
{
this._selectorVisualizers[j].Init();
}
this._postExecute = new List <Action>(1);
}
internal void ShowVisualizedAI(UtilityAIVisualizer ai)
{
//The visualized ai is the same as the _ai instance in case no client is selected for visualization.
if (ai == null)
{
if (object.ReferenceEquals(_visualizedAI, _ai))
{
return;
}
_visualizedAI = _ai;
}
else
{
_visualizedAI = ai;
}
int i = 0;
foreach (var sv in this.canvas.selectorViews)
{
sv.Reconnect(_visualizedAI[i++]);
}
}
public static bool ExecuteOnce(this IUtilityAI ai, IAIContext context)
{
IAction action = ai.Select(context);
bool flag = false;
bool flag1 = false;
while (!flag)
{
ICompositeAction compositeAction = action as ICompositeAction;
if (compositeAction != null)
{
action.Execute(context);
action = compositeAction.Select(context);
flag = action == null;
flag1 = true;
}
else
{
IConnectorAction connectorAction = action as IConnectorAction;
if (connectorAction != null)
{
action = connectorAction.Select(context);
}
else
{
flag = true;
}
}
}
if (action != null)
{
action.Execute(context);
flag1 = true;
}
return(flag1);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadBalancedUtilityAIClient"/> class, with an execution interval of 1 second and no start delay.
/// </summary>
/// <param name="ai">The AI.</param>
/// <param name="contextProvider">The context provider.</param>
public LoadBalancedUtilityAIClient(IUtilityAI ai, IContextProvider contextProvider)
: this(ai, contextProvider, 1f, 1f, 0f, 0f)
{
}
public HTNUtilityAiClient(IUtilityAI ai, IContextProvider contextProvider) : base(ai, contextProvider)
{
}
public HTNUtilityAiClient(IUtilityAI ai, IContextProvider contextProvider)
{
base.\u002Ector(ai, contextProvider);
}
public BaseAiUtilityClient(IUtilityAI ai, IContextProvider contextProvider) : base(ai, contextProvider)
{
}
public BaseAiUtilityClient(IUtilityAI ai, IContextProvider contextProvider)
{
base.\u002Ector(ai, contextProvider);
}
