/// <summary> /// Return true if the root node is not a good type for being a root /// </summary> /// <param name="i"></param> /// <returns>The number of children <paramref name="paramNode"/> has</returns> public bool BadRootCheck(BehaviourNode paramNode = null) { BehaviourNode node; if (paramNode) { node = paramNode; } else { node = (BehaviourNode)nodes.Where(n => ((BehaviourNode)n).isRoot).FirstOrDefault(); if (!node) { return(false); } } if (node.type == behaviourType.Leaf) { return(true); } if (node.type < behaviourType.Leaf) { return(false); } foreach (TransitionGUI transition in transitions.FindAll(t => !t.isExit && node.Equals(t.fromNode))) { return(BadRootCheck((BehaviourNode)transition.toNode)); } return(false); }
/// <summary> /// Deletes the <paramref name="node"/> and its children /// </summary> /// <param name="node"></param> public void DeleteNode(BehaviourNode node, bool deleteTransitions = true) { if (nodes.Remove(node)) { if (deleteTransitions) { foreach (TransitionGUI transition in transitions.FindAll(t => node.Equals(t.fromNode))) { DeleteConnection(transition); DeleteNode((BehaviourNode)transition.toNode); } foreach (TransitionGUI transition in transitions.FindAll(t => node.Equals(t.toNode))) { DeleteConnection(transition); } } if (node.subElem == null) { elementNamer.RemoveName(node.identificator); } else { elementNamer.RemoveName(node.subElem.identificator); } } }
private string GetNodePath(BossBehaviour behaviour, BehaviourNode node) { var arrayName = node is ActionBehaviourNode ? "_actionBehaviours" : "_compoundBehaviours"; var arrayField = behaviour.GetType().GetField(arrayName, BindingFlags.NonPublic | BindingFlags.Instance); if (arrayField == null) { throw new ApplicationException(string.Format("Cannot find field {0} in class {1}", arrayName, behaviour.GetType())); } var dict = arrayField.GetValue(behaviour); var keysField = FindFieldInHierarchy(dict.GetType(), "_keys"); if (keysField == null) { throw new ApplicationException(string.Format("Cannot find field {0} in class {1}", "_keys", dict.GetType())); } var list = (IList)keysField.GetValue(dict); var index = list.IndexOf(node.Guid); if (index < 0) { throw new ArgumentException(string.Format("Cannot find node {0}", node)); } var path = string.Format("{0}._values.Array.data[{1}]", arrayName, index); return(path); }
public virtual void SetChild(BehaviourNode node) { if (child != null) { child = node; } }
/// <summary> /// Creates a copy of this <see cref="BehaviourNode"/> /// </summary> /// <param name="args"></param> /// <returns></returns> public override GUIElement CopyElement(params object[] args) { BehaviourTree parent = (BehaviourTree)args[0]; BehaviourNode result = CreateInstance <BehaviourNode>(); result.identificator = this.identificator; result.nodeName = this.nodeName; result.parent = parent; result.type = this.type; result.windowRect = new Rect(this.windowRect); result.isRoot = this.isRoot; result.isRandom = this.isRandom; result.isInfinite = this.isInfinite; result.delayTime = this.delayTime; result.Nloops = this.Nloops; result.index = this.index; if (this.subElem) { result.subElem = (ClickableElement)this.subElem.CopyElement(parent); } return(result); }
private static Vector2 GetNodeSize_Horz(BehaviourNode node) { string label = node.Title; if (node != null) { if (node is NodeGroup) { return(m_nodeGroupStyle.GetSize_Horz(label)); } else if (node is Composite) { return(m_compositeStyle.GetSize_Horz(label)); } else if (node is Decorator || node is NodeGroup) { return(m_decoratorStyle.GetSize_Horz(label)); } else if (node is BevTree.Action) { return(m_actionStyle.GetSize_Horz(label)); } } return(new Vector2(180, 40)); }
/// <summary> /// Inverts the child node result. /// </summary> /// <param name="child">The child node</param> public BehaviourInverter(BehaviourNode child) : base("Inverter", NodeType.DECORATOR) { AddChild(child); OnStarted.AddListener(OnStarted_Listener); OnStopping.AddListener(OnStopping_Listener); OnChildNodeStopped.AddListener(OnChildNodeStopped_Listener); }
public static GenericMenu CreateServiceContextMenu(BehaviourNode targetNode, int serviceIndex) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Move Up"), false, () => { if (serviceIndex > 0) { var temp = targetNode.Services[serviceIndex]; targetNode.Services[serviceIndex] = targetNode.Services[serviceIndex - 1]; targetNode.Services[serviceIndex - 1] = temp; } }); menu.AddItem(new GUIContent("Move Down"), false, () => { if (serviceIndex < targetNode.Services.Count - 1) { var temp = targetNode.Services[serviceIndex]; targetNode.Services[serviceIndex] = targetNode.Services[serviceIndex + 1]; targetNode.Services[serviceIndex + 1] = temp; } }); menu.AddSeparator(""); menu.AddItem(new GUIContent("Remove"), false, () => { targetNode.Services.RemoveAt(serviceIndex); }); return(menu); }
//ramped half-and-half: grow method public BehaviourNode innerGrowTree(int maxDepth, List <System.Type> Functions, List <System.Type> terminals, bool isTerminal) { if (maxDepth < 0) { return(null); } if (maxDepth == 0) { isTerminal = true; } int nextNode = UnityEngine.Random.Range(0, (isTerminal == true? terminals.Count : Functions.Count)); List <BehaviourNode> l = new List <BehaviourNode>(); BehaviourNode rootNode = (BehaviourNode)System.Activator.CreateInstance(isTerminal == true? terminals[nextNode] : Functions[nextNode]); if (!isTerminal) { int numberOfBranches = ((IFunction)rootNode).parameters; for (int i = 0; i < Mathf.Max(numberOfBranches, 2); i++) { bool isTerm = UnityEngine.Random.Range(0, 100) > depthIncreaseProb; l.Add(innerGrowTree(maxDepth - 1, Functions, terminals, isTerm)); } } rootNode.setNextNodes(l); return(rootNode); }
private void onNodeSelectedForLinking(BehaviourNode node) { serializedObject.Update(); var refInter = node as Interruptable; bool bAlreadyLinked = _interruptor.linkedInterruptables.Contains(refInter); // Works as a toggle, if already linked then unlink. if (bAlreadyLinked) { _interruptor.linkedInterruptables.Remove(refInter); } // If unlinked, then link. else { _interruptor.linkedInterruptables.Add(refInter); } serializedObject.ApplyModifiedProperties(); // Update the referenced nodes in the editor. var refs = _interruptor.GetReferencedNodes(); parentWindow.editor.SetReferencedNodes(refs); }
public void EvaluateTree() { if (companion == null) { companion = GetComponent <Companion>(); } BehaviourNode currentNode = rootNode.childNode; while (currentNode is ControlNode) { ControlNode c = currentNode as ControlNode; MethodInfo method = this.GetType().GetMethod(c.methodName); bool result = (bool)method.Invoke(this, null); if (result) { currentNode = c.positive; } else { currentNode = c.negative; } } if (currentNode is ExecutionNode) { ExecutionNode e = currentNode as ExecutionNode; if (e.methodName != current) { Invoke(e.methodName, 0); current = e.methodName; } } }
private void OnClickAddNode(Vector2 mousePosition) { var behaviourNode = BehaviourNode.CreateActionBehaviourNode(); _target.AddBehaviour(behaviourNode); CreateNode(mousePosition, behaviourNode); }
public BTEditorGraphNode OnInsertChild(int index, BehaviourNode node) { if (node != null && ((m_node is Composite) || (m_node is Decorator))) { BTEditorGraphNode graphNode = null; if (m_node is Composite) { Composite composite = m_node as Composite; composite.InsertChild(index, node); graphNode = BTEditorGraphNode.CreateExistingNode(this, node); m_children.Insert(index, graphNode); } else if (m_node is Decorator) { Decorator decorator = m_node as Decorator; DestroyChildren(); decorator.SetChild(node); graphNode = BTEditorGraphNode.CreateExistingNode(this, node); m_children.Add(graphNode); } BTEditorCanvas.Current.RecalculateSize(node.Position); return(graphNode); } return(null); }
private void OnClickAddCoumpoudNode(Vector2 mousePosition) { var behaviourNode = BehaviourNode.CreateCompoundBehaviourNode(); _target.AddBehaviour(behaviourNode); CreateCompoundNode(mousePosition, behaviourNode); }
private void OnChildNodeStopped_Listener(BehaviourNode child, bool success) { OnChildNodeStopped_Common(child, success); // OnStopped.Invoke(success); //StopNode(success); StopNodeOnNextTick(success); }
// double crossoverRate = 0.9; public override List <BotBehavior> crossOver(List <BotBehavior> individuals, int populationGoalSize) { int numberOfCrossovers = populationGoalSize; //(int)Mathf.Floor(individuals.Count * (float)crossoverRate); List <BotBehavior> children = new List <BotBehavior> (); for (int i = numberOfCrossovers / 2; i > 0; i--) { int parentx = UnityEngine.Random.Range(0, individuals.Count); int parenty = UnityEngine.Random.Range(0, individuals.Count); BotBehavior p1 = BotBehavior.deepClone <BotBehavior>(individuals[parentx]); BotBehavior p2 = BotBehavior.deepClone <BotBehavior>(individuals[parenty]); Tuple <BehaviourNode, int> firstPoint = selectNodeOf(p1); Tuple <BehaviourNode, int> secPoint = selectNodeOf(p2); //doing the crossover //preventing swapping of root nodes --> pointless and undefined if (firstPoint.First != null && secPoint.First != null) { BehaviourNode temp = firstPoint.First.getNextNodes()[firstPoint.Second]; firstPoint.First.getNextNodes()[firstPoint.Second] = secPoint.First.getNextNodes()[secPoint.Second]; secPoint.First.getNextNodes()[secPoint.Second] = temp; } children.Add(p1); children.Add(p2); } return(children); }
public static Vector2 GetNodeSize(BehaviourNode node) { string label = string.IsNullOrEmpty(node.Name) ? node.Title : node.Name; if (node != null) { if (node is NodeGroup) { return(m_nodeGroupStyle.GetSize(label, TreeLayout)); } else if (node is Composite) { return(m_compositeStyle.GetSize(label, TreeLayout)); } else if (node is Decorator || node is NodeGroup) { return(m_decoratorStyle.GetSize(label, TreeLayout)); } else if (node is Brainiac.Action) { return(m_actionStyle.GetSize(label, TreeLayout)); } } return(new Vector2(180, 40)); }
// Use this for initialization public override void Start () { base.Start (); if (NV != null&& NV.node is BehaviourNode) { BNode = (BehaviourNode)NV.node; } }
private void SetExistingNode(BehaviourNode node) { DestroyChildren(); m_node = node; m_isSelected = false; if (node is Composite) { Composite composite = node as Composite; for (int i = 0; i < composite.ChildCount; i++) { BehaviourNode childNode = composite.GetChild(i); BTEditorGraphNode graphNode = BTEditorGraphNode.CreateExistingNode(this, childNode); m_children.Add(graphNode); } } else if (node is Decorator) { Decorator decorator = node as Decorator; BehaviourNode childNode = decorator.GetChild(); if (childNode != null) { BTEditorGraphNode graphNode = BTEditorGraphNode.CreateExistingNode(this, childNode); m_children.Add(graphNode); } } }
public static Vector2 GetNodeSize(BehaviourNode node) { return(GetNodeSize_Horz(node)); /*string label = node.Title; * * if(node != null) * { * if(node is NodeGroup) * { * return m_nodeGroupStyle.GetSize(label, TreeLayout); * } * else if(node is Composite) * { * return m_compositeStyle.GetSize(label, TreeLayout); * } * else if(node is Decorator || node is NodeGroup) * { * return m_decoratorStyle.GetSize(label, TreeLayout); * } * else if(node is BevTree.Action) * { * return m_actionStyle.GetSize(label, TreeLayout); * } * } * * return new Vector2(180, 40);*/ }
/// <summary> /// Create a node from an existing behaviour. /// </summary> /// <param name="behaviour"></param> /// <returns></returns> public BonsaiNode CreateNode(BehaviourNode behaviour) { var node = CreateEditorNode(behaviour.GetType()); node.Behaviour = behaviour; return(node); }
void Start() { // Create a copy of the behaviour tree so we can indivudually set values behaviourTree = (BehaviourTree)behaviourTree.Copy(); XNode.Node entry = ((BehaviourTree)behaviourTree.Copy()).FindEntryNode(); behaviourTreeRoot = (BehaviourNode)entry.GetOutputPort("child").GetConnection(0).node; behaviourTreeRoot.Reset(); }
/// <summary> /// Restarts the AI /// </summary> public void Restart() { Pause(); currentNode = null; Resume(); }
private void OnChildNodeStoppedSilent_Listener(BehaviourNode child, bool success) { if (success && !(State == NodeState.STOPPING || !m_isConditionMetFunc())) { m_restartChildTimer = StartFirstChildNodeOnNextTick(); } }
public Node(NodeBasedEditor editor, BehaviourNode behaviourNode, Vector2 position) { Editor = editor; BehaviourNode = behaviourNode; Rect = new Rect(position.x - defaultWidth / 2f, position.y, defaultWidth, defaultHeight); InPoint = new ConnectionPoint(this, ConnectionPointType.In, Editor.InPointStyle, Editor.OnClickInPoint, null, null); }
private void OnChildNodeStoppedSilent_Listener(BehaviourNode child, bool success) { if (success && !(State == NodeState.STOPPING || (TotalLoops >= 0 && ++LoopCount >= TotalLoops))) { _restartChildTimer = AddTimer(0, 0, 0, RestartChild); } }
/* * public override bool RequestStopNode(bool silent = false){ * if(base.RequestStopNode(silent)){ * if(!silent){ * Children[0].StartNode(); * } * return true; * } * return false; * } */ private void OnChildNodeStopped_Common(BehaviourNode child, bool success) { if ((Parent.Type == NodeType.COMPOSITE && Parent.State != NodeState.ACTIVE) || m_abortRule == AbortRule.NONE || m_abortRule == AbortRule.SELF) { StopActivelyObserving(); } }
private BonsaiNode ReconstructEditorNode(BehaviourNode behaviour) { BonsaiNode node = CreateNode(behaviour); node.Behaviour = behaviour; node.Position = behaviour.bonsaiNodePosition; return(node); }
private void AddNodeCallback(object type, Vector2 mousePosition) { BehaviourNode node = (BehaviourNode)AddNode((Type)type); node.Position = (mousePosition - dragging_Position) - (node.GetDiamentions() * 0.5f); Repaint(); }
public static GenericMenu CreateNodeInspectorContextMenu(BehaviourNode targetNode) { GenericMenu menu = new GenericMenu(); BTConstraintFactory.AddConstraint(menu, targetNode); BTServiceFactory.AddService(menu, targetNode); return(menu); }
public void SetReferenced(BehaviourNode node) { referencedNodes.Clear(); BehaviourNode[] refs = node.GetReferencedNodes(); if (refs != null && refs.Length != 0) { referencedNodes.AddRange(refs); } }
private void loaded(LevelLoader obj){ //obj.DontDelete = true; /*foreach(EmptyObjectIdentifier eoi in obj.rootObject.GetAllComponentsInChildren<EmptyObjectIdentifier>()){ GameObject.Destroy(eoi); }*/ GameObject go = (GameObject)GameObject.Instantiate (obj.rootObject); //obj.rootObject.SetActive (false); TreeRoot = go.GetComponent<BehaviourNode> (); TreeRoot.Tree = this; TreeRoot.ReCaptureChildsAndParents (); }
// Update is called once per frame public override void Update () { base.Update (); if (Node == null) { if (NV != null&& NV.node is BehaviourNode) { BNode = (BehaviourNode)NV.node; } } if (addTestClass) { addTestClass = false; AddNode(ClassName); } }
public bool AddChildNode(BehaviourNode childNode) { if(childNode == null) { return false; } if(!this.IsLegalChildNodeIndex(this.numChildren)) { return false; } this.children[this.numChildren] = childNode; ++this.numChildren; return true; }
public virtual void LoadTree(string FileName){ if (FileName.Length == 0) return; if (TreeRoot != null) { GameObject.DestroyImmediate (TreeRoot.gameObject); TreeRoot=null; } LevelSerializer.LoadObjectTreeFromFile(FileName,loaded); lastLoadedTree = FileName; TreeSaveManager.getTreeSaveManager ().AddObserver (FileName, this); //LevelSerializer.Collect (); //LevelSerializer.LoadObjectTreeFromFile("Pah.dat"); }
public void onChange(string value){ if(!isEnabled) return; if(value.Equals("None")){ EnableStuff(); if(oldTree != null){ oldTree.ReCaptureChildsAndParents(); bteh.VisTree(oldTree); oldTree = null; } if(bteh.TreeRoot == null && TreeVis.getTreeVis().TreeRoot != null){ TreeVis.getTreeVis().DestroyTree(); TreeVis.getTreeVis().TreeRoot = null; } }else{ DisableStuff(); oldTree = bteh.TreeRoot; GameObject go = GameObject.Find(value); bool failed = false; if(go != null){ BehaviourTree tree = go.GetComponent<BehaviourTree>(); if(tree != null && tree.TreeRoot != null){ bteh.VisTree(tree.TreeRoot); } else { failed = true;} }else { failed = true;} if(failed){ oldTree = null; EnableStuff(); } } }
public void VisTree(BehaviourNode treeRoot){ TreeVis.getTreeVis ().DestroyTree (); TreeVis.getTreeVis ().TreeRoot = treeRoot; TreeVis.getTreeVis ().LoadTree (); }