public BehaviourTreeInstance(BehaviourTreeNode rootNode, Actor actor, int numberOfLoops) { this.rootNode = rootNode; this.currentNode = rootNode; this.Actor = actor; this.numberOfLoops = numberOfLoops; }
private BehaviourTree.Status SequenceTick() { foreach (BehaviourTreeNode child in children) { if (this.startFromFirstNodeEachTick || this.currentTickedNode == null || this.currentTickedNode == child) { BehaviourTree.Status childStatus = child.Tick(); if (childStatus == BehaviourTree.Status.RUNNING) { this.currentTickedNode = child; return(childStatus); } if (childStatus == BehaviourTree.Status.FAILURE) { this.currentTickedNode = null; return(childStatus); } } } this.currentTickedNode = null; return(BehaviourTree.Status.SUCCESS); }
void RootWindowFunction(int windowID) { Event current = Event.current; if (current.type == EventType.MouseDown && current.button == 1) { this.selectedNode = FindNodeByID(BehaviourTreeEditorWindow.behaviourTree, windowID); GenericMenu menu = new GenericMenu(); AddNewChildOption(menu, BehaviourTreeEditorWindow.behaviourTree.child == null); menu.ShowAsContext(); current.Use(); } else if (current.type == EventType.MouseDown && current.button == 0) { this.selectedNode = FindNodeByID(BehaviourTreeEditorWindow.behaviourTree, windowID); if (Selection.activeObject != BehaviourTreeEditorWindow.behaviourTree) { SelectNodeButDontChangeProjectView(); } current.Use(); } }
public override void AddChild(BehaviourTreeNode child) { if (this.child == null) { this.child = child; } }
void SetColor(BehaviourTreeNode node) { GUI.color = colorDefault; if (node is BehaviourTreeControlNode) { BehaviourTreeControlNode controlNode = (BehaviourTreeControlNode)node; switch (controlNode.type) { case BehaviourTreeControlNode.Type.SELECTOR: GUI.color = colorControlSelectorNode; break; case BehaviourTreeControlNode.Type.SEQUENCE: GUI.color = colorControlSequenceNode; break; case BehaviourTreeControlNode.Type.PARALLEL: GUI.color = colorControlParallelNode; break; default: GUI.color = colorDefault; break; } } else if (node is BehaviourTreeExecutionNode) { GUI.color = colorExecutionNode; } else if (node is BehaviourTreeDecoratorNode) { GUI.color = colorDecoratorNode; } else if (node is BehaviourTreeSubTreeNode) { GUI.color = colorBehaviourTreeNode; } }
public ExecutionResult Execute(BehaviourTreeInstance behaviourTreeInstance) { var state = behaviourTreeInstance.NodeAndState[this]; if (state == BehaviourTreeInstance.NodeState.STATE_EXECUTING) { return(new ExecutionResult(true)); } if (state == BehaviourTreeInstance.NodeState.STATE_COMPUTE_RESULT) { BehaviourTreeNode picked = ChooseByRandom(actionArrayAndLikelihood); behaviourTreeInstance.NodeAndState[this] = BehaviourTreeInstance.NodeState.STATE_WAITING; behaviourTreeInstance.NodeAndState[picked] = BehaviourTreeInstance.NodeState.STATE_TO_BE_STARTED; foreach (var item in actionArrayAndLikelihood) { if (item.Key != picked) { behaviourTreeInstance.NodeAndState[item.Key] = BehaviourTreeInstance.NodeState.STATE_DISCARDED; } } } return(new ExecutionResult(true)); }
void DrawChildrenRecursively(BehaviourTreeNode node) { List <BehaviourTreeNode> children = node.GetChildren(); for (int i = 0; i < node.ChildrenCount(); i++) { CreateNodeRect(children[i], node); Handles.BeginGUI(); Vector2 begin = new Vector2(node.rect.center.x, node.rect.yMax); Vector2 end = new Vector2(children[i].rect.center.x, children[i].rect.yMin + 2.0f); float xAverage = (node.rect.center.x + children[i].rect.center.x) / 2.0f; Vector2 beginTangente = new Vector2(xAverage, children[i].rect.yMin); Vector2 endTangente = new Vector2(xAverage, node.rect.yMax); Handles.DrawBezier(begin, end, beginTangente, endTangente, colorLine, null, 5f); Handles.EndGUI(); } for (int i = 0; i < node.ChildrenCount(); i++) { DrawChildrenRecursively(children[i]); } }
public SelectorNode(Func <BehaviourTreeInstance, ExecutionResult> conditionFunction, BehaviourTreeNode actionIfTrue, BehaviourTreeNode actionIfFalse) { this.conditionFunction = conditionFunction; this.actionIfTrue = actionIfTrue; this.actionIfFalse = actionIfFalse; }
public ExecutionResult ExecuteBehaviourTree() { if (Completed) { return(new ExecutionResult(true)); } //find current node to be executed, or a running one, or root to launch, or root completed currentNode = FindCurrentNode(rootNode); if (currentNode == null) { numberOfRuns++; if (numberOfLoops == 0 || numberOfRuns < numberOfLoops) { NodeAndState = new Dictionary <BehaviourTreeNode, NodeState>(); currentNode = FindCurrentNode(rootNode); } else { Completed = true; return(new ExecutionResult(true)); } } bool toBeStarted = false; if (NodeAndState.ContainsKey(currentNode)) { toBeStarted = NodeAndState[currentNode] == BehaviourTreeInstance.NodeState.STATE_TO_BE_STARTED; } else { toBeStarted = true; } if (toBeStarted) { ExecutionResult result = currentNode.Execute(this); var afterState = NodeAndState[currentNode]; if (afterState == BehaviourTreeInstance.NodeState.STATE_TO_BE_STARTED) { NodeAndState[currentNode] = BehaviourTreeInstance.NodeState.STATE_COMPLETED; } return(result); } NodeState state = NodeAndState[currentNode]; if (state == BehaviourTreeInstance.NodeState.STATE_COMPUTE_RESULT) { ExecutionResult result = currentNode.Execute(this); NodeAndState[currentNode] = BehaviourTreeInstance.NodeState.STATE_COMPLETED; return(result); } return(null); }
internal GraphNode OnNodeAdded(BehaviourTree asset, BehaviourTreeNode node) { var newNode = new BehaviourTreeEditorNode(asset, node, Presenter); Nodes.AddNode(newNode); return(newNode); }
private GraphNode AddNewNode(BehaviourTreeNode node) { AddToAsset(node); TreeAsset.Nodes.Add(node); return(View.OnNodeAdded(TreeAsset, node)); }
public override void Init(BehaviourTreeAgent agent) { this.currentTickedNode = null; foreach (BehaviourTreeNode child in children) { child.Init(agent); } }
void DeleteRecursivelyBranchAssets(BehaviourTreeNode node) { DeleteNodeAsset(node); foreach (BehaviourTreeNode child in node.GetChildren()) { DeleteRecursivelyBranchAssets(child); } }
// Start is called before the first frame update void Start() { Blackboard = new Dictionary <string, object>(); Blackboard.Add("enemy1", new Rect(25, 85, 10, 10)); //initial behaviour is stopped startedBehaviour = false; mRoot = new Repeater(this, new Sequencer(this, new BehaviourTreeNode[] { new BTEnemyMove(this, 25, 85) })); }
public void Schedule(BehaviourTreeExecutionData <TBlackboard> data, BehaviourTreeNode <TBlackboard> node, ICompletionObserver <TBlackboard> observer = null) { if (observer != null) { node.Observer = observer; } data.Stack.AddBack(node); }
private static void RemoveNode(BehaviourTreeExecutionData <TBlackboard> data, BehaviourTreeNode <TBlackboard> node) { var index = data.Stack.IndexOf(node); if (index >= 0) { data.Stack.RemoveAt(index); } }
void SubTreeCallback() { BehaviourTreeSubTreeNode newNode = (BehaviourTreeSubTreeNode)ScriptableObject.CreateInstance("BehaviourTreeSubTreeNode"); newNode.ID = GetNextWindowID(); this.selectedNode.AddChild(newNode); newNode.displayedName = "SUB TREE"; AddNodeToAssets(newNode); SaveBehaviourTree(); this.selectedNode = newNode; }
public override void ReplaceChild(BehaviourTreeNode oldChild, BehaviourTreeNode newChild) { for (int i = 0; i < this.children.Count; i++) { if (this.children[i] == oldChild) { this.children[i] = newChild; return; } } }
void ExecutionCallback() { BehaviourTreeExecutionNode newNode = (BehaviourTreeExecutionNode)ScriptableObject.CreateInstance("BehaviourTreeExecutionNode"); newNode.ID = GetNextWindowID(); this.selectedNode.AddChild(newNode); newNode.displayedName = "EXECUTION"; AddNodeToAssets(newNode); SaveBehaviourTree(); this.selectedNode = newNode; }
void NewChildDecorator(BehaviourTreeDecoratorNode.Type type) { BehaviourTreeDecoratorNode newNode = (BehaviourTreeDecoratorNode)ScriptableObject.CreateInstance("BehaviourTreeDecoratorNode"); newNode.type = type; newNode.ID = GetNextWindowID(); newNode.displayedName = newNode.type.ToString(); this.selectedNode.AddChild(newNode); AddNodeToAssets(newNode); SaveBehaviourTree(); this.selectedNode = newNode; }
public void Stop(BehaviourTreeExecutionData <TBlackboard> data, BehaviourTreeNode <TBlackboard> node, BehaviourTreeStatus status) { RemoveNode(data, node); data.Statuses[node.Id] = status; if (node.Observer != null) { node.Observer.OnComplete(this, data, status); } }
public BehaviourTreeEditorNode(BehaviourTree tree, BehaviourTreeNode node, BehaviourTreeEditorPresenter presenter) { TreeAsset = tree; TreeNode = node; Presenter = presenter; Position = TreeNode.EditorPosition; Size = new Vector3(NodeWidth, NodeHeight); WindowTitle = GUIContent.none; WindowStyle = SpaceEditorStyles.GraphNodeBackground; }
public void OnConnectNodes(BehaviourTreeNode parent, BehaviourTreeNode child) { if (_duringRecreate) { return; } var data = OnConnectNodesQueue.Post(); data.Parent = parent; data.Child = child; }
void DeleteNodeAsset(BehaviourTreeNode node) { if (node is BehaviourTreeExecutionNode) { BehaviourTreeExecutionNode execNode = (BehaviourTreeExecutionNode)node; if (execNode.task != null) { DestroyImmediate(execNode.task, true); } } DestroyImmediate(node, true); AssetDatabase.ImportAsset(behaviourTreeAssetFilesPath); }
void NewParentDecorator(BehaviourTreeDecoratorNode.Type type) { BehaviourTreeDecoratorNode newNode = (BehaviourTreeDecoratorNode)ScriptableObject.CreateInstance("BehaviourTreeDecoratorNode"); newNode.type = type; newNode.ID = GetNextWindowID(); newNode.displayedName = newNode.type.ToString().Replace('_', ' '); BehaviourTreeNode parent = FindParentOfNodeByID(BehaviourTreeEditorWindow.behaviourTree, this.selectedNode.ID); parent.ReplaceChild(this.selectedNode, newNode); newNode.AddChild(this.selectedNode); AddNodeToAssets(newNode); SaveBehaviourTree(); this.selectedNode = newNode; }
private void ShowMainContextMenu(System.Action <Type> callback) { GenericMenu menu = new GenericMenu(); foreach (Type type in Reflection.GetSubclasses <BehaviourTreeNode>()) { string title = string.Format("{0}/{1}", BehaviourTreeNode.GetNodeTypeName(type), type.Name); menu.AddItem(new GUIContent(title), false, CreateNewNodeCallback(callback, type)); } menu.AddSeparator(string.Empty); menu.AddItem(new GUIContent("Refresh"), false, RecreateNodes); menu.ShowAsContext(); }
void MoveLastCallback() { BehaviourTreeNode parent = FindParentOfNodeByID(BehaviourTreeEditorWindow.behaviourTree, this.selectedNode.ID); int selectedNodeIndice = parent.GetChildren().IndexOf(this.selectedNode); if (selectedNodeIndice < parent.ChildrenCount() - 1) { BehaviourTreeNode node = parent.GetChildren()[selectedNodeIndice]; parent.GetChildren().Remove(node); parent.GetChildren().Insert(parent.ChildrenCount(), node); } SaveBehaviourTree(); }
void DeleteBranchCallback() { if (!EditorUtility.DisplayDialog("Delete branch ?", "Are you sure you want to delete the node " + this.selectedNode.displayedName + " and his children ?", "Yes, delete this branch", "No")) { return; } BehaviourTreeNode parent = FindParentOfNodeByID(BehaviourTreeEditorWindow.behaviourTree, this.selectedNode.ID); parent.RemoveChild(selectedNode); DeleteRecursivelyBranchAssets(selectedNode); AssetDatabase.Refresh(); SaveBehaviourTree(); }
protected BehaviourTreeNode <T>[] BuildChildren <T>(ref int index) { var childrenNodes = new BehaviourTreeNode <T> [childrenCount]; for (var i = 0; i < childrenCount; i++) { var port = GetOutputPort(string.Format(ChildrenPortNameFormat, i)); var connectedNode = port.Connection.node as BehaviourTreeGraphNode; if (connectedNode != null) { childrenNodes[i] = connectedNode.Build <T>(ref index); } } return(childrenNodes); }
void ControlWindowFunction(int windowID) { BehaviourTreeControlNode node = (BehaviourTreeControlNode)FindNodeByID(BehaviourTreeEditorWindow.behaviourTree, windowID); Event current = Event.current; if (current.type == EventType.MouseDown && current.button == 1) { this.selectedNode = node; if (Selection.activeObject != BehaviourTreeEditorWindow.behaviourTree) { SelectNodeButDontChangeProjectView(); } GenericMenu menu = new GenericMenu(); AddNewChildOption(menu, true); AddInsertNewParentOptions(menu); AddMoveOption(menu); if (this.selectedNode.ChildrenCount() <= 1) { menu.AddItem(new GUIContent("Delete Node"), false, DeleteNodeCallback); menu.AddDisabledItem(new GUIContent("Delete Branch")); } else { menu.AddDisabledItem(new GUIContent("Delete Node")); menu.AddItem(new GUIContent("Delete Branch"), false, DeleteBranchCallback); } menu.ShowAsContext(); current.Use(); } else if (current.type == EventType.MouseDown && current.button == 0) { this.selectedNode = node; if (Selection.activeObject != BehaviourTreeEditorWindow.behaviourTree) { SelectNodeButDontChangeProjectView(); } current.Use(); } }