public static BehaviorTreeTask CreateBehaviorTreeTask(string relativePath)
{
BehaviorTree tree = null;
if (BehaviorTrees.ContainsKey(relativePath))
{
tree = BehaviorTrees[relativePath];
}
else if (Load(relativePath))
{
tree = BehaviorTrees[relativePath];
}
if (tree == null)
{
return(null);
}
BehaviorTreeTask item = tree.CreateAndInitTask() as BehaviorTreeTask;
if (!ms_allBehaviorTreeTasks.ContainsKey(relativePath))
{
ms_allBehaviorTreeTasks[relativePath] = new BTItem_t();
}
BTItem_t _t = ms_allBehaviorTreeTasks[relativePath];
if (!_t.bts.Contains(item))
{
_t.bts.Add(item);
}
return(item);
}
protected virtual void OnDestroy()
{
this.UnSubsribeToNetwork();
if (this.m_contextId >= 0)
{
Context context = Context.GetContext(this.m_contextId);
World world = context.GetWorld(false);
if (!object.ReferenceEquals(world, null) && !object.ReferenceEquals(world, this))
{
world.RemoveAgent(this);
}
}
if (this.m_behaviorTreeTasks != null)
{
for (int i = 0; i < this.m_behaviorTreeTasks.Count; i++)
{
BehaviorTreeTask behaviorTreeTask = this.m_behaviorTreeTasks[i];
Workspace.DestroyBehaviorTreeTask(behaviorTreeTask, this);
}
this.m_behaviorTreeTasks.Clear();
this.m_behaviorTreeTasks = null;
}
if (this.m_eventInfos != null)
{
this.m_eventInfos.Clear();
this.m_eventInfos = null;
}
}
public bool btload(Agent.State_t state)
{
state.Vars.CopyTo(this, this.m_variables);
if (state.BT != null)
{
if (this.m_currentBT != null)
{
for (int i = 0; i < this.m_behaviorTreeTasks.Count; i++)
{
BehaviorTreeTask behaviorTreeTask = this.m_behaviorTreeTasks[i];
if (behaviorTreeTask == this.m_currentBT)
{
Workspace.DestroyBehaviorTreeTask(behaviorTreeTask, this);
this.m_behaviorTreeTasks.Remove(behaviorTreeTask);
break;
}
}
}
BehaviorNode node = state.BT.GetNode();
this.m_currentBT = (BehaviorTreeTask)node.CreateAndInitTask();
state.BT.CopyTo(this.m_currentBT);
return(true);
}
return(false);
}
protected override EBTStatus update(Agent pAgent, EBTStatus childStatus)
{
Debug.Check(this.m_node is ReferencedBehavior);
ReferencedBehavior pNode = this.m_node as ReferencedBehavior;
Debug.Check(pNode != null);
EBTStatus status = EBTStatus.BT_RUNNING;
if (pNode.RootTaskNode(pAgent) == null)
{
status = this.m_subTree.exec(pAgent);
}
else
{
#if !BEHAVIAC_RELEASE
if (!_logged)
{
pAgent.LogJumpTree(pNode.GetReferencedTree(pAgent));
_logged = true;
}
#endif
Debug.Check(this.m_children.Count == 1);
BehaviorTask c = this.m_children[0];
BehaviorTreeTask oldTreeTask = pAgent.ExcutingTreeTask;
pAgent.ExcutingTreeTask = this.m_subTree;
status = c.exec(pAgent);
pAgent.ExcutingTreeTask = oldTreeTask;
}
return(status);
}
public void btunloadall()
{
ListView <BehaviorTree> listView = new ListView <BehaviorTree>();
foreach (BehaviorTreeTask current in this.BehaviorTreeTasks)
{
BehaviorNode node = current.GetNode();
BehaviorTree behaviorTree = (BehaviorTree)node;
bool flag = false;
foreach (BehaviorTree current2 in listView)
{
if (current2 == behaviorTree)
{
flag = true;
break;
}
}
if (!flag)
{
listView.Add(behaviorTree);
}
Workspace.DestroyBehaviorTreeTask(current, this);
}
foreach (BehaviorTree current3 in listView)
{
this.btunload_pars(current3);
Workspace.UnLoad(current3.GetName());
}
this.BehaviorTreeTasks.Clear();
this.m_currentBT = null;
this.BTStack.Clear();
this.Variables.Unload();
}
public void btunloadall()
{
ListView <BehaviorTree> view = new ListView <BehaviorTree>();
foreach (BehaviorTreeTask task in this.BehaviorTreeTasks)
{
BehaviorTree node = (BehaviorTree)task.GetNode();
bool flag = false;
foreach (BehaviorTree tree2 in view)
{
if (tree2 == node)
{
flag = true;
break;
}
}
if (!flag)
{
view.Add(node);
}
Workspace.DestroyBehaviorTreeTask(task, this);
}
foreach (BehaviorTree tree3 in view)
{
this.btunload_pars(tree3);
Workspace.UnLoad(tree3.GetName());
}
this.BehaviorTreeTasks.Clear();
this.m_currentBT = null;
this.BTStack.Clear();
this.Variables.Unload();
}
public void SetTaskParams(Agent agent, BehaviorTreeTask treeTask)
{
if (this.m_taskMethod != null)
{
this.m_taskMethod.SetTaskParams(agent, treeTask);
}
}
public void btunload(string relativePath)
{
if (this.m_currentBT != null && this.m_currentBT.GetName() == relativePath)
{
BehaviorNode node = this.m_currentBT.GetNode();
BehaviorTree bt = node as BehaviorTree;
this.btunload_pars(bt);
this.m_currentBT = null;
}
for (int i = 0; i < this.BTStack.Count; i++)
{
Agent.BehaviorTreeStackItem_t behaviorTreeStackItem_t = this.BTStack[i];
if (behaviorTreeStackItem_t.bt.GetName() == relativePath)
{
this.BTStack.Remove(behaviorTreeStackItem_t);
break;
}
}
for (int j = 0; j < this.BehaviorTreeTasks.Count; j++)
{
BehaviorTreeTask behaviorTreeTask = this.BehaviorTreeTasks[j];
if (behaviorTreeTask.GetName() == relativePath)
{
Workspace.DestroyBehaviorTreeTask(behaviorTreeTask, this);
this.BehaviorTreeTasks.Remove(behaviorTreeTask);
break;
}
}
Workspace.UnLoad(relativePath);
}
public static BehaviorTreeTask CreateBehaviorTreeTask(string relativePath)
{
BehaviorTree behaviorTree = null;
if (Workspace.BehaviorTrees.ContainsKey(relativePath))
{
behaviorTree = Workspace.BehaviorTrees.get_Item(relativePath);
}
else
{
bool flag = Workspace.Load(relativePath);
if (flag)
{
behaviorTree = Workspace.BehaviorTrees.get_Item(relativePath);
}
}
if (behaviorTree != null)
{
BehaviorTask behaviorTask = behaviorTree.CreateAndInitTask();
BehaviorTreeTask behaviorTreeTask = behaviorTask as BehaviorTreeTask;
if (!Workspace.ms_allBehaviorTreeTasks.ContainsKey(relativePath))
{
Workspace.ms_allBehaviorTreeTasks.set_Item(relativePath, new Workspace.BTItem_t());
}
Workspace.BTItem_t bTItem_t = Workspace.ms_allBehaviorTreeTasks.get_Item(relativePath);
if (!bTItem_t.bts.Contains(behaviorTreeTask))
{
bTItem_t.bts.Add(behaviorTreeTask);
}
return(behaviorTreeTask);
}
return(null);
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
this.m_subTree = null;
Debug.Check(this.currentState != null);
this.currentState.Pop();
base.onexit(pAgent, s);
}
public void btreloadall()
{
this.m_currentBT = null;
this.BTStack.Clear();
if (this.m_behaviorTreeTasks != null)
{
List <string> list = new List <string>();
using (ListView <BehaviorTreeTask> .Enumerator enumerator = this.m_behaviorTreeTasks.GetEnumerator())
{
while (enumerator.MoveNext())
{
BehaviorTreeTask current = enumerator.get_Current();
string name = current.GetName();
if (list.IndexOf(name) == -1)
{
list.Add(name);
}
}
}
for (int i = 0; i < list.get_Count(); i++)
{
string relativePath = list.get_Item(i);
Workspace.Load(relativePath, true);
}
this.BehaviorTreeTasks.Clear();
}
this.Variables.Unload();
}
protected override bool onenter(Agent pAgent)
{
ReferencedBehavior pNode = this.GetNode() as ReferencedBehavior;
Debug.Check(pNode != null);
if (pNode != null)
{
this.m_nextStateId = -1;
string szTreePath = pNode.GetReferencedTree(pAgent);
//to create the task on demand
if (this.m_subTree == null || szTreePath != this.m_subTree.GetName())
{
if (this.m_subTree != null)
{
Workspace.Instance.DestroyBehaviorTreeTask(this.m_subTree, pAgent);
}
this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(szTreePath);
pNode.SetTaskParams(pAgent, this.m_subTree);
}
else if (this.m_subTree != null)
{
this.m_subTree.reset(pAgent);
}
pNode.SetTaskParams(pAgent, this.m_subTree);
return(true);
}
return(false);
}
private void _btsetcurrent(string relativePath, TriggerMode triggerMode, bool bByEvent)
{
if (!string.IsNullOrEmpty(relativePath))
{
if (!Workspace.Load(relativePath))
{
string text = base.GetType().get_FullName();
text += "::";
text += base.name;
}
else
{
Workspace.RecordBTAgentMapping(relativePath, this);
if (this.m_currentBT != null)
{
if (triggerMode == TriggerMode.TM_Return)
{
Agent.BehaviorTreeStackItem_t item = new Agent.BehaviorTreeStackItem_t(this.m_currentBT, triggerMode, bByEvent);
this.BTStack.Add(item);
}
else if (triggerMode == TriggerMode.TM_Transfer)
{
this.m_currentBT.abort(this);
this.m_currentBT.reset(this);
}
}
BehaviorTreeTask behaviorTreeTask = null;
for (int i = 0; i < this.BehaviorTreeTasks.Count; i++)
{
BehaviorTreeTask behaviorTreeTask2 = this.BehaviorTreeTasks[i];
if (behaviorTreeTask2.GetName() == relativePath)
{
behaviorTreeTask = behaviorTreeTask2;
break;
}
}
bool flag = false;
if (behaviorTreeTask != null && this.BTStack.Count > 0)
{
for (int j = 0; j < this.BTStack.Count; j++)
{
Agent.BehaviorTreeStackItem_t behaviorTreeStackItem_t = this.BTStack[j];
if (behaviorTreeStackItem_t.bt.GetName() == relativePath)
{
flag = true;
break;
}
}
}
if (behaviorTreeTask == null || flag)
{
behaviorTreeTask = Workspace.CreateBehaviorTreeTask(relativePath);
this.BehaviorTreeTasks.Add(behaviorTreeTask);
}
this.m_currentBT = behaviorTreeTask;
}
}
}
private void _btsetcurrent(string relativePath, TriggerMode triggerMode, bool bByEvent)
{
if (!string.IsNullOrEmpty(relativePath))
{
if (!Workspace.Load(relativePath))
{
string str = base.GetType().FullName + "::" + base.name;
}
else
{
Workspace.RecordBTAgentMapping(relativePath, this);
if (this.m_currentBT != null)
{
if (triggerMode == TriggerMode.TM_Return)
{
BehaviorTreeStackItem_t _t = new BehaviorTreeStackItem_t(this.m_currentBT, triggerMode, bByEvent);
this.BTStack.Add(_t);
}
else if (triggerMode == TriggerMode.TM_Transfer)
{
this.m_currentBT.abort(this);
this.m_currentBT.reset(this);
}
}
BehaviorTreeTask item = null;
for (int i = 0; i < this.BehaviorTreeTasks.Count; i++)
{
BehaviorTreeTask task2 = this.BehaviorTreeTasks[i];
if (task2.GetName() == relativePath)
{
item = task2;
break;
}
}
bool flag3 = false;
if ((item != null) && (this.BTStack.Count > 0))
{
for (int j = 0; j < this.BTStack.Count; j++)
{
BehaviorTreeStackItem_t _t2 = this.BTStack[j];
if (_t2.bt.GetName() == relativePath)
{
flag3 = true;
break;
}
}
}
if ((item == null) || flag3)
{
item = Workspace.CreateBehaviorTreeTask(relativePath);
this.BehaviorTreeTasks.Add(item);
}
this.m_currentBT = item;
}
}
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
this.m_subTree = null;
#if BEHAVIAC_USE_HTN
Debug.Check(this.currentState != null);
this.currentState.Pop();
#endif//
base.onexit(pAgent, s);
}
public State_t(Agent.State_t c)
{
c.m_vars.CopyTo(null, this.m_vars);
if (c.m_bt != null)
{
BehaviorNode node = c.m_bt.GetNode();
this.m_bt = (BehaviorTreeTask)node.CreateAndInitTask();
c.m_bt.CopyTo(this.m_bt);
}
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
Workspace.Instance.DestroyBehaviorTreeTask(this.m_subTree, pAgent);
this.m_subTree = null;
#if BEHAVIAC_USE_HTN
Debug.Check(this.currentState != null);
this.currentState.Pop();
#endif//
base.onexit(pAgent, s);
}
protected override bool onenter(Agent pAgent)
{
ReferencedBehavior pNode = this.GetNode() as ReferencedBehavior;
Debug.Check(pNode != null);
this.m_nextStateId = -1;
pNode.SetTaskParams(pAgent);
this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(pNode.m_referencedBehaviorPath);
return(true);
}
protected override void onexit(Agent pAgent, EBTStatus status)
{
Debug.Check(this.m_node is ReferencedBehavior);
ReferencedBehavior pNode = this.m_node as ReferencedBehavior;
Debug.Check(pNode != null);
this.m_subTree = null;
#if !BEHAVIAC_RELEASE
pAgent.LogReturnTree(pNode.ReferencedTree);
#endif
Debug.Check(this.currentState != null);
this.currentState.Pop();
}
protected override bool onenter(Agent pAgent)
{
Debug.Check(this.m_node is ReferencedBehavior);
ReferencedBehavior pNode = this.m_node as ReferencedBehavior;
Debug.Check(pNode != null);
#if !BEHAVIAC_RELEASE
_logged = false;
#endif
pNode.SetTaskParams(pAgent);
this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(pNode.ReferencedTree);
return true;
}
public override bool decompose(BehaviorNode node, PlannerTaskComplex seqTask, int depth, Planner planner)
{
ReferencedBehavior taskSubTree = (ReferencedBehavior)node;
bool bOk = false;
Debug.Check(taskSubTree != null);
int depth2 = planner.GetAgent().Variables.Depth;
using (AgentState currentState = planner.GetAgent().Variables.Push(false))
{
Agent pAgent = planner.GetAgent();
string szTreePath = taskSubTree.GetReferencedTree(pAgent);
BehaviorTreeTask subTreeTask = Workspace.Instance.CreateBehaviorTreeTask(szTreePath);
taskSubTree.SetTaskParams(pAgent, subTreeTask);
Task task = taskSubTree.RootTaskNode(planner.GetAgent());
if (task != null)
{
planner.LogPlanReferenceTreeEnter(planner.GetAgent(), taskSubTree);
//task.Parent.InstantiatePars(this.LocalVars);
BehaviorTreeTask oldCurrentTreeTask = pAgent.ExcutingTreeTask;
pAgent.ExcutingTreeTask = subTreeTask;
PlannerTask childTask = planner.decomposeNode(task, depth);
pAgent.ExcutingTreeTask = oldCurrentTreeTask;
if (childTask != null)
{
//taskSubTree.SetTaskParams(planner.GetAgent(), childTask);
PlannerTaskReference subTreeRef = (PlannerTaskReference)seqTask;
subTreeRef.SubTreeTask = subTreeTask;
seqTask.AddChild(childTask);
bOk = true;
}
//task.Parent.UnInstantiatePars(this.LocalVars);
planner.LogPlanReferenceTreeExit(planner.GetAgent(), taskSubTree);
Debug.Check(true);
}
}
Debug.Check(planner.GetAgent().Variables.Depth == depth2);
return(bOk);
}
public static void DestroyBehaviorTreeTask(BehaviorTreeTask behaviorTreeTask, Agent agent)
{
if (behaviorTreeTask != null)
{
if (ms_allBehaviorTreeTasks.ContainsKey(behaviorTreeTask.GetName()))
{
BTItem_t _t = ms_allBehaviorTreeTasks[behaviorTreeTask.GetName()];
_t.bts.Remove(behaviorTreeTask);
if (agent != null)
{
_t.agents.Remove(agent);
}
}
BehaviorTask.DestroyTask(behaviorTreeTask);
}
}
public static void DestroyBehaviorTreeTask(BehaviorTreeTask behaviorTreeTask, Agent agent)
{
if (behaviorTreeTask != null)
{
if (Workspace.ms_allBehaviorTreeTasks.ContainsKey(behaviorTreeTask.GetName()))
{
Workspace.BTItem_t bTItem_t = Workspace.ms_allBehaviorTreeTasks.get_Item(behaviorTreeTask.GetName());
bTItem_t.bts.Remove(behaviorTreeTask);
if (agent != null)
{
bTItem_t.agents.Remove(agent);
}
}
BehaviorTask.DestroyTask(behaviorTreeTask);
}
}
public void btunloadall()
{
ListView <BehaviorTree> listView = new ListView <BehaviorTree>();
using (ListView <BehaviorTreeTask> .Enumerator enumerator = this.BehaviorTreeTasks.GetEnumerator())
{
while (enumerator.MoveNext())
{
BehaviorTreeTask current = enumerator.get_Current();
BehaviorNode node = current.GetNode();
BehaviorTree behaviorTree = (BehaviorTree)node;
bool flag = false;
using (ListView <BehaviorTree> .Enumerator enumerator2 = listView.GetEnumerator())
{
while (enumerator2.MoveNext())
{
BehaviorTree current2 = enumerator2.get_Current();
if (current2 == behaviorTree)
{
flag = true;
break;
}
}
}
if (!flag)
{
listView.Add(behaviorTree);
}
Workspace.DestroyBehaviorTreeTask(current, this);
}
}
using (ListView <BehaviorTree> .Enumerator enumerator3 = listView.GetEnumerator())
{
while (enumerator3.MoveNext())
{
BehaviorTree current3 = enumerator3.get_Current();
this.btunload_pars(current3);
Workspace.UnLoad(current3.GetName());
}
}
this.BehaviorTreeTasks.Clear();
this.m_currentBT = null;
this.BTStack.Clear();
this.Variables.Unload();
}
protected override EBTStatus update(Agent pAgent, EBTStatus childStatus)
{
BehaviorTreeTask rooTask = null;
if (!this.GetEndOutside())
{
rooTask = this.RootTask;
}
else if (pAgent != null)
{
rooTask = pAgent.CurrentTreeTask;
}
if (rooTask != null)
{
rooTask.setEndStatus(this.GetStatus(pAgent));
}
return(EBTStatus.BT_RUNNING);
}
protected override bool onenter(Agent pAgent)
{
Debug.Check(this.m_node is ReferencedBehavior);
ReferencedBehavior pNode = this.m_node as ReferencedBehavior;
Debug.Check(pNode != null);
#if !BEHAVIAC_RELEASE
_logged = false;
#endif
//this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(pNode.GetReferencedTree(pAgent));
Debug.Check(this.m_subTree != null);
pNode.SetTaskParams(pAgent, this.m_subTree);
this.oldTreeTask_ = pAgent.ExcutingTreeTask;
pAgent.ExcutingTreeTask = this.m_subTree;
return(true);
}
public static string GetTickInfo(Agent pAgent, BehaviorTask b, string action)
{
#if !BEHAVIAC_RELEASE
if (Config.IsLoggingOrSocketing)
{
if (pAgent != null && pAgent.IsMasked())
{
//BEHAVIAC_PROFILE("GetTickInfo", true);
string bClassName = b.GetClassNameString();
//filter out intermediate bt, whose class name is empty
if (!string.IsNullOrEmpty(bClassName))
{
int nodeId = b.GetId();
BehaviorTreeTask bt = pAgent != null?pAgent.btgetcurrent() : null;
//TestBehaviorGroup\scratch.xml.EventetTask[0]:enter
string bpstr = "";
if (bt != null)
{
string btName = bt.GetName();
bpstr = string.Format("{0}.xml->", btName);
}
bpstr += string.Format("{0}[{1}]", bClassName, nodeId);
if (!string.IsNullOrEmpty(action))
{
bpstr += string.Format(":{0}", action);
}
return(bpstr);
}
}
}
#endif
return(string.Empty);
}
private EBTStatus btexec_()
{
if (this.m_currentBT == null)
{
return(EBTStatus.BT_INVALID);
}
EBTStatus status = this.m_currentBT.exec(this);
if (this == null)
{
return(EBTStatus.BT_FAILURE);
}
while (status != EBTStatus.BT_RUNNING)
{
this.m_currentBT.reset(this);
if (this.BTStack.Count <= 0)
{
return(status);
}
BehaviorTreeStackItem_t _t = this.BTStack[this.BTStack.Count - 1];
this.m_currentBT = _t.bt;
this.BTStack.RemoveAt(this.BTStack.Count - 1);
if (_t.triggerMode == TriggerMode.TM_Return)
{
string name = this.m_currentBT.GetName();
LogManager.Log(this, name, EActionResult.EAR_none, LogMode.ELM_return);
if (!_t.triggerByEvent)
{
this.m_currentBT.resume(this, status);
status = this.m_currentBT.exec(this);
}
}
else
{
return(this.m_currentBT.exec(this));
}
}
return(status);
}
//profiler
public void Log(Agent pAgent, string btMsg, long time)
{
#if !BEHAVIAC_RELEASE
if (Config.IsLoggingOrSocketing)
{
if (Config.IsProfiling)
{
//BEHAVIAC_PROFILE("LogManager.Instance.LogProfiler");
if (!System.Object.ReferenceEquals(pAgent, null) && pAgent.IsMasked())
{
//string agentClassName = pAgent.GetObjectTypeName();
//string agentInstanceName = pAgent.GetName();
BehaviorTreeTask bt = !System.Object.ReferenceEquals(pAgent, null) ? pAgent.btgetcurrent() : null;
string btName;
if (bt != null)
{
btName = bt.GetName();
}
else
{
btName = "None";
}
//[profiler]Ship.Ship_1 ships\suicide.xml.BehaviorTree[0] 0.031
string buffer;
//buffer = FormatString("[profiler]%s.%s %s.%s %d\n", agentClassName, agentInstanceName, btName, btMsg, time);
buffer = string.Format("[profiler]{0}.xml.{1} {2}\n", btName, btMsg, time);
Output(pAgent, buffer);
}
}
}
#endif
}
protected override EBTStatus update_current(Agent pAgent, EBTStatus childStatus)
{
Debug.Check(this.m_node != null);
Debug.Check(this.m_node is BehaviorTree);
this.m_excutingTreeTask = pAgent.ExcutingTreeTask;
pAgent.ExcutingTreeTask = this;
BehaviorTree tree = (BehaviorTree)this.m_node;
EBTStatus status = EBTStatus.BT_RUNNING;
if (tree.IsFSM)
{
status = this.update(pAgent, childStatus);
}
else
{
status = base.update_current(pAgent, childStatus);
}
return(status);
}
public void SetTaskParams(Agent agent, BehaviorTreeTask treeTask)
{
if (this.m_taskMethod != null)
{
this.m_taskMethod.SetTaskParams(agent, treeTask);
}
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
Workspace.Instance.DestroyBehaviorTreeTask(this.m_subTree, pAgent);
this.m_subTree = null;
#if BEHAVIAC_USE_HTN
Debug.Check(this.currentState != null);
this.currentState.Pop();
#endif//
base.onexit(pAgent, s);
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
this.m_subTree = null;
#if BEHAVIAC_USE_HTN
Debug.Check(this.currentState != null);
this.currentState.Pop();
#endif//
base.onexit(pAgent, s);
}
protected override bool onenter(Agent pAgent)
{
ReferencedBehavior pNode = this.GetNode() as ReferencedBehavior;
Debug.Check(pNode != null);
this.m_nextStateId = -1;
//to create the task on demand
if (this.m_subTree == null)
{
string szTreePath = pNode.GetReferencedTree(pAgent);
this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(szTreePath);
}
else
{
this.m_subTree.reset(pAgent);
}
pNode.SetTaskParams(pAgent, this.m_subTree);
return true;
}
protected override bool onenter(Agent pAgent)
{
ReferencedBehavior pNode = this.GetNode() as ReferencedBehavior;
Debug.Check(pNode != null);
this.m_nextStateId = -1;
pNode.SetTaskParams(pAgent);
this.m_subTree = Workspace.Instance.CreateBehaviorTreeTask(pNode.m_referencedBehaviorPath);
return true;
}
protected override void onexit(Agent pAgent, EBTStatus s)
{
this.m_subTree = null;
Debug.Check(this.currentState != null);
this.currentState.Pop();
base.onexit(pAgent, s);
}
protected override BehaviorTask createTask()
{
BehaviorTreeTask pTask = new BehaviorTreeTask();
return pTask;
}
public void CopyTo(BehaviorTreeTask target)
{
this.copyto(target);
}
public static void DestroyBehaviorTreeTask(BehaviorTreeTask behaviorTreeTask, Agent agent)
{
if (behaviorTreeTask != null)
{
if (ms_allBehaviorTreeTasks.ContainsKey(behaviorTreeTask.GetName()))
{
BTItem_t btItem = ms_allBehaviorTreeTasks[behaviorTreeTask.GetName()];
btItem.bts.Remove(behaviorTreeTask);
if (agent != null)
{
btItem.agents.Remove(agent);
}
}
BehaviorTask.DestroyTask(behaviorTreeTask);
}
}
