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); }
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 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); } }