/** * Begins a node and attaches the coroutine to this object * If you use this method you MUST call the node.OnComplete method * after it yields */ public Coroutine BeginNode(BehaviorNode node) { node.mReturnValue = BehaviorReturn.Running; //process return StartCoroutine(node.Process(this)); }
public override NodeViewData CreateNodeViewData(NodeViewData parent, BehaviorNode rootBehavior) { NodeViewData nvd = base.CreateNodeViewData(parent, rootBehavior); nvd.ChangeShape(this.IsEndState ? NodeShape.RoundedRectangle : NodeShape.Rectangle); return nvd; }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if(_genericChildren.ChildCount <1) result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.DecoratorHasNoChildError) ); base.CheckForErrors(rootBehavior, result); }
public ExporterCpp(BehaviorNode node, string outputFolder, string filename, List<string> includedFilenames = null) : base(node, outputFolder, filename, includedFilenames) { //automatically create an extra level of path _outputFolder = Path.Combine(Path.GetFullPath(_outputFolder), "behaviac_generated"); _filename = "behaviors/generated_behaviors.h"; }
public override NodeViewData CreateNodeViewData(NodeViewData parent, BehaviorNode rootBehavior) { NodeViewData nvd = base.CreateNodeViewData(parent, rootBehavior); nvd.ChangeShape(NodeShape.Ellipse); return nvd; }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if(_genericChildren.ChildCount <2) result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.SelectorOnlyOneChildError) ); else if(_genericChildren.ChildCount <1) result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SelectorNoChildrenError) ); base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (this._signal.ChildCount == 0) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.ImpulseWithoutEventError)); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (this.Children.Count < 2) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "There should be at least 2 condition children.")); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (this._method == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.RandomGeneratorNotSpecified)); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (_do_sequence_error_check) { if (_genericChildren.EnableChildCount < 1) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SequenceNoChildrenError)); } else if (_genericChildren.EnableChildCount < 2) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.SequenceOnlyOneChildError)); } } base.CheckForErrors(rootBehavior, result); }
internal static void SetProperty(BehaviorNode behavior, string agentTypename, string agentName, string valueName, string valueStr) { foreach(ParametersDock dock in _parameterDocks) { if (dock.AgentName == agentName) { dock.setProperty(behavior, valueName, valueStr); break; } } }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { Type valueType = this._time.GetValueType(); if (valueType != typeof(float)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time must be a float type!")); } base.CheckForErrors(rootBehavior, result); }
public BehaviorReturn mReturnValue = BehaviorReturn.Invalid; /**< as process is ran in coroutines returning a BehaviorReturn type is not allowed. So we store it here and check it with ReturnValue property */ #endregion Fields #region Constructors public BehaviorNode(BehaviorNode parent) { Composite compNode = parent as Composite; if (compNode != null) compNode.AddChild(this); else { Decorator decNode = parent as Decorator; if (decNode != null) decNode.AddChild(this); } }
/** * Ctor * @param stack The BehaviorVariable id of stack to push to * @param item The BehaviorVariable id item variable */ public PushToStack(BehaviorNode parent, string stack, string item) : base(parent) { mStack = stack; mItem = item; //make sure input is instantiated if(input == null) { input = new object[1]; } }
public NodeViewDataStyled(NodeViewData parent, BehaviorNode rootBehavior, Node node, Pen borderPen, Brush backgroundBrush, Brush draggedBackgroundBrush, string label, string description, int minWidth = 120, int minHeight = 35) : base(parent, rootBehavior, node, NodeShape.RoundedRectangle, new Style(backgroundBrush, null, Brushes.White), new Style(null, DefaultCurrentBorderPen, null), new Style(null, __defaultSelectedBorderPen, null), new Style(draggedBackgroundBrush, null, null), new Style(null, __highlightedBorderPen, null), new Style(null, __updatedBorderPen, null), new Style(null, __prefabBorderPen, null), label, __defaultLabelFont, __profileLabelFont, __profileLabelBoldFont, minWidth, minHeight, description) { }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { foreach (BaseNode child in _genericChildren.Children) { if (!(child is WithPrecondition)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SelectorLoopChildChildError)); } } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { base.CheckForErrors(rootBehavior, result); if (this._bDoneWithinFrame) { long count = this.GetCount(); if (count == -1) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "when 'DoneWithinFrame' is selected, Count should not be -1 as an endless loop!")); } } }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (_Task.Child == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.NoMethosError)); } if (!(this.Parent is Task)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.MethodParentError)); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { Type valueType = this._time.GetValueType(); string typeName = Plugin.GetNativeTypeName(valueType.FullName); if (Plugin.IsIntergerNumberType(typeName)) { } else { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time should be an integer number type!")); } base.CheckForErrors(rootBehavior, result); }
/** * Coroutine to begin the BehaviorTree * @param node The root node * @return IEnumerator (see Unity Coroutine) */ private IEnumerator Coroutine_Execute(BehaviorNode node) { //set this to true as the behavior tree is running mStatus = BehaviorReturn.Running; mCurrent = node; yield return BeginNode(mCurrent); //the status of this tree will be whatever the value of the first node was mStatus = mCurrent.mReturnValue; Debug.Log("BEHAVIOR COMPLETE " + mStatus); mCurrent = null; }
/// <summary> /// Creates a new XML file manager to load and save behaviours. /// </summary> /// <param name="filename">The file we want to load from or save to.</param> /// <param name="node">The node we want to save. When loading, use null.</param> public DaxImporter(string filename, BehaviorNode node) : base(filename, node) { if (filename.Length > 0) { if (filename.StartsWith ("http://")) { _filename=filename; } else{ _filename = Path.GetFullPath(filename); } } _node = node; }
public override void CheckForErrors(BehaviorNode rootBehavior, List<Node.ErrorCheck> result) { if (this.Opl == null || this.Opr == null) { result.Add(new Node.ErrorCheck(this.Node, this.Label, ErrorCheckLevel.Error, "Operand is not complete!")); } else if (this.Opl.ValueType != typeof(bool) && (this.Operator == OperatorType.And || this.Operator == OperatorType.Or)) { //and and or are only valid for bool result.Add(new Node.ErrorCheck(this.Node, this.Label, ErrorCheckLevel.Error, "And and Or are only valid for bool!")); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { Type valueType = (this._time != null) ? this._time.ValueType : null; if (valueType == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time is not set!")); } else if (!Plugin.IsIntergerType(valueType) && !Plugin.IsFloatType(valueType)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time must be a float type!")); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (this.Attachments.Count == 0) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.ImpulseWithoutEventError)); } else { foreach (Attachment attach in this.Attachments) { attach.CheckForErrors(rootBehavior, result); } } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { if (_Precondition.Child == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.NoPreconditionError)); } if (_Action.Child == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.NoActionError)); } if (!(this.Parent is SelectorLoop)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.WithPreconditionParentError)); } base.CheckForErrors(rootBehavior, result); }
public DaxExporter(BehaviorNode node, string outputFolder, string filename) : base(node, outputFolder, filename + ".btx") { if (filename.Length > 0) { if (filename.StartsWith("http://")) { _filename = filename; } else { _filename = Path.GetFullPath(filename); } } }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { Type valueType = this._count.GetValueType(); string typeName = Plugin.GetNativeTypeName(valueType.FullName); if (Plugin.IsIntergerNumberType(typeName)) { if (this._count.ValueClass == VariableDef.kConst) { string valueString = this._count.Value.ToString(); if (valueType == typeof(long) || valueType == typeof(int) || valueType == typeof(short) || valueType == typeof(sbyte)) { long count = long.Parse(valueString); if (count <= 0) { if (count != -1) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Count should be larger than 0 or -1 for endless loop!")); } } } else if (valueType == typeof(ulong) || valueType == typeof(uint) || valueType == typeof(ushort) || valueType == typeof(byte)) { ulong count = ulong.Parse(valueString); if (count >= 100000000) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, "Count is a huge number it could be wrong!")); } } else { string errMsg = string.Format("Count is a '{0}', it is not a number!", valueType.Name); result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, errMsg)); } } } else { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Count should be an integer number type!")); } base.CheckForErrors(rootBehavior, result); }
public ExportDialog(BehaviorTreeList behaviorTreeList, BehaviorNode node, bool ignoreErrors, TreeNode selectedTreeRoot, int formatIndex) { _initialized = false; InitializeComponent(); _behaviorTreeList = behaviorTreeList; _node = node; _ignoreErrors = ignoreErrors; _selectedTreeRoot = selectedTreeRoot; // add all valid exporters to the format combobox Debug.Check(Workspace.Current != null); int exportIndex = -1; for (int i = 0; i < Plugin.Exporters.Count; ++i) { ExporterInfo info = Plugin.Exporters[i]; if (node != null || info.MayExportAll) { int index = this.exportSettingGridView.Rows.Add(); DataGridViewRow row = this.exportSettingGridView.Rows[index]; bool isExported = Workspace.Current.ShouldBeExported(info.ID); if (info.ID == Plugin.SourceLanguage && this.ExportCustomizedMeta()) { isExported = true; } row.Cells["Enable"].Value = isExported; row.Cells["Format"].Value = info.Description; row.Cells["Format"].ReadOnly = true; row.Cells["Setting"].Value = info.HasSettings ? "..." : ""; row.Cells["Setting"].ReadOnly = true; if (Workspace.Current.ShouldBeExported(info.ID) && (exportIndex == -1 || info.HasSettings)) { exportIndex = i; } } } changeExportFormat(exportIndex); _initialized = true; }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { Type valueType = (this._frames != null) ? this._frames.ValueType : null; if (valueType == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Frames is not set!")); } else { string typeName = Plugin.GetNativeTypeName(valueType.FullName); if (!Plugin.IsIntergerNumberType(typeName)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Frames should be an integer number type!")); } } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { if (this.Domain == string.Empty && this._descriptors.Count == 0) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Invalid query without domain or any descriptors")); } for (int i = 0; i < this._descriptors.Count; ++i) { Descriptor_t dw = this._descriptors[i]; if (dw.Attribute != null && dw.Weight == 0.0f) { string msg = string.Format("Descriptors[{0}]'s Weight is 0.0f!", i); result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, msg)); } } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) { Type valueType = (this._frames != null) ? this._frames.ValueType : null; if (valueType == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Frames is not set!")); } else { string typeName = Plugin.GetNativeTypeName(valueType.FullName); if (!Plugin.IsIntergerNumberType(typeName)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Frames should be an integer number type!")); } } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { Type valueType = this._count.GetValueType(); string typeName = Plugin.GetNativeTypeName(valueType.FullName); if (Plugin.IsIntergerNumberType(typeName)) { if (this._count.ValueClass == VariableDef.kConst) { string valueString = this._count.Value.ToString(); if (valueType == typeof(long) || valueType == typeof(int) || valueType == typeof(short) || valueType == typeof(sbyte)) { long count = long.Parse(valueString); if (count <= 0) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Count should be larger than -1!")); } } else if (valueType == typeof(ulong) || valueType == typeof(uint) || valueType == typeof(ushort) || valueType == typeof(byte)) { ulong count = ulong.Parse(valueString); if (count >= 100000000) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, "Count is a huge number it could be wrong!")); } } else { string errMsg = string.Format("Count is a '{0}', it is not a number!", valueType.Name); result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, errMsg)); } } } else { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Count should be an integer number type!")); } base.CheckForErrors(rootBehavior, result); }
/// <summary> /// Exports a behaviour to the given file. /// </summary> /// <param name="file">The file we want to export to.</param> /// <param name="behavior">The behaviour we want to export.</param> protected void ExportBehavior(BsonSerializer file, BehaviorNode behavior) { file.WriteComment("EXPORTED BY TOOL, DON'T MODIFY IT!"); file.WriteComment("Source File: " + behavior.MakeRelative(behavior.FileManager.Filename)); file.WriteStartElement("behavior"); Behavior b = behavior as Behavior; Debug.Check(b != null); Debug.Check(b.Id == -1); //'\\' ->'/' string behaviorName = b.MakeRelative(b.Filename); behaviorName = behaviorName.Replace('\\', '/'); int pos = behaviorName.IndexOf(".xml"); if (pos != -1) { behaviorName = behaviorName.Remove(pos); } file.WriteString(behaviorName); file.WriteString(b.AgentType.AgentTypeName); file.WriteString(b.Version.ToString()); this.ExportProperties(file, b); this.ExportParameters(file, (Node)behavior); this.ExportAttachments(file, b); // export the children foreach (Node child in ((Node)behavior).Children) { this.ExportNode(file, behavior, (Node)behavior, child); } file.WriteEndElement(); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <Node.ErrorCheck> result) { if (this.Opl == null || this.Opr == null) { result.Add(new Node.ErrorCheck(this.Node, this.Id, this.Label, ErrorCheckLevel.Error, "Precondition Operand is not complete!")); } else if (this.Opl.ValueType != typeof(bool) && (this.Operator == OperatorType.And || this.Operator == OperatorType.Or)) { //and and or are only valid for bool result.Add(new Node.ErrorCheck(this.Node, this.Id, this.Label, ErrorCheckLevel.Error, "And and Or are only valid for bool!")); } if (this._opl != null && this._opl.Method != null && this._opl.Method.AgentType != null && !this._opl.Method.AgentType.IsCustomized && this._opl.Method.IsCustomized) { result.Add(new Node.ErrorCheck(this.Node, this.Id, this.Label, ErrorCheckLevel.Error, Resources.CustomizedMethodError)); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { if (this.Opl == null || this.Opr == null || this.Opl.ToString() == "" || this.Opr.ToString() == "") { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.OperatandIsNotComplete)); } else if (this.Opl.ValueType != typeof(bool) && (this.Operator == OperatorType.And || this.Operator == OperatorType.Or)) { // And and Or are only valid for bool result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.AndOrOnlyValidForBool)); } if (this.Opl != null && this.Opl.IsMethod && this.Opl.Method != null && this.Opl.Method.IsCustomized || this.Opr != null && this.Opr.IsMethod && this.Opr.Method != null && this.Opr.Method.IsCustomized) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.CustomizedMethodError)); } base.CheckForErrors(rootBehavior, result); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <Node.ErrorCheck> result) { { if (this._opl == null) { result.Add(new Node.ErrorCheck(this.Node, ErrorCheckLevel.Error, "Left operand is not specified!")); } if (this._opr2 == null) { result.Add(new Node.ErrorCheck(this.Node, ErrorCheckLevel.Error, "Right operand is not specified!")); } if (this._opl != null && this._opl.Method != null && this._opl.Method.IsCustomized) { result.Add(new Node.ErrorCheck(this.Node, this.Id, this.Label, ErrorCheckLevel.Error, Resources.CustomizedMethodError)); } } base.CheckForErrors(rootBehavior, result); }
public void Restore(BehaviorNode source) { Debug.Check(source is Nodes.Node); Behavior sourceBehavior = (Behavior)source; Behavior targetBehavior = (Behavior)this; // Restore the agent type. targetBehavior.AgentType = sourceBehavior.AgentType; // Restore the child connector. targetBehavior._genericChildren = sourceBehavior._genericChildren; Node sourceNode = (Node)source; Node targetNode = (Node)this; // Restore the hierarchy. targetNode.ReplaceChildren(sourceNode); sourceBehavior.CloneProperties(this); }
protected void ExportBehaviorToServer(StreamWriter file, BehaviorNode behavior) { if (_behaviorServer == null) return; if (_behaviorServer.Length == 0) return; string namspace = GetNamespace(_usedNamespace, _filename); string classname = Path.GetFileNameWithoutExtension(behavior.FileManager.Filename).Replace(" ", string.Empty); string behaviorURL = _behaviorServer + "/behavior/"+classname+".BTX"; HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(behaviorURL); httpRequest.Method = WebRequestMethods.Http.Post; //httpRequest.ContentType = "application/x-www-form-urlencoded"; httpRequest.ContentType = "text/xml"; //httpRequest.ContentLength = 0; StreamWriter requestWriter = new StreamWriter(httpRequest.GetRequestStream(), System.Text.Encoding.ASCII); // requestWriter.Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); // requestWriter.Write("<aiml version=\"1.0\">\r\n"); // requestWriter.Write(" <state name=\"*\">\r\n"); // write comments // requestWriter.Write(string.Format("\t<!-- Exported behavior: {0} --> \r\n", _filename)); // requestWriter.Write(string.Format("\t<!-- Exported file: {0} -->\r\n\r\n", behavior.FileManager.Filename)); // export nodes int nodeID = 0; // export the children foreach (Node child in ((Node)behavior).Children) ExportNode(requestWriter, namspace, behavior, "this", child, 3, ref nodeID); // close constructor // requestWriter.Write(" </state>\r\n"); //requestWriter.Write("</aiml>\r\n"); requestWriter.Close(); WebResponse responseGet = httpRequest.GetResponse(); }
public bool SetProperty(BehaviorNode behavior, string valueName, string valueStr) { DesignerPropertyEditor propertyEditor = getPropertyEditor(valueName); if (propertyEditor == null && behavior != null) { Node root = behavior as Node; foreach (PropertyDef p in root.LocalVars) { if (!p.IsArrayElement && p.BasicName == valueName) { propertyEditor = addRowControl(p); break; } } } if (propertyEditor == null) { return(false); } VariableDef var = propertyEditor.GetVariable(); if (var.Value.ToString().ToLower() != valueStr.ToLower()) { Plugin.InvokeTypeParser(null, var.ValueType, valueStr, (object value) => var.Value = value, null); propertyEditor.ValueWasnotAssigned(); propertyEditor.SetVariable(var, null); propertyEditor.ValueWasAssigned(); return(true); } return(false); }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { if (!this._isVisiting) { this._isVisiting = true; // check if the node has any children if (_genericChildren.ChildCount < 1) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.BehaviorIsEmptyError)); } if (this._agentType == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.NoAgent)); } base.CheckForErrors(rootBehavior, result); this._isVisiting = false; } }
public IEnumerator EvaluateNode() { // If the condition for behavior does not hold up, // stop here. if (!Condition()) { yield break; } // If a behavior has been specified, execute that before // performing any other behaviors. if (Behavior != null) { Behavior(); } for (int i = 0; i < Children.Count; i++) { BehaviorNode node = Children[i]; yield return(node.EvaluateNode()); } }
/// <summary> /// Exports a behaviour to the given file. /// </summary> /// <param name="file">The file we want to export to.</param> /// <param name="behavior">The behaviour we want to export.</param> protected void ExportBehavior(StreamWriter file, BehaviorNode behavior) { string namspace = GetNamespace(_usedNamespace, _filename); string classname = Path.GetFileNameWithoutExtension(behavior.FileManager.Filename).Replace(" ", string.Empty); // write comments file.Write(string.Format("// Exported behavior: {0}\r\n", _filename)); file.Write(string.Format("// Exported file: {0}\r\n\r\n", behavior.FileManager.Filename)); // create namespace and class file.Write(string.Format("namespace {0}\r\n{{\r\n", namspace)); file.Write(string.Format("\tpublic sealed class {0} : {1}\r\n\t{{\r\n", classname, ((Node)behavior).ExportClass)); // create instance and accessors file.Write(string.Format("\t\tprivate static {0} _instance = null;\r\n", classname)); file.Write(string.Format("\t\tpublic static {0} Instance\r\n\t\t{{\r\n", classname)); file.Write("\t\t\tget\r\n\t\t\t{\r\n"); file.Write("\t\t\t\tif(_instance == null)\r\n"); file.Write(string.Format("\t\t\t\t\t_instance = new {0}();\r\n\r\n", classname)); file.Write("\t\t\t\treturn _instance;\r\n\t\t\t}\r\n\t\t}\r\n\r\n"); // create constructor file.Write(string.Format("\t\tprivate {0}()\r\n\t\t{{\r\n", classname)); // export nodes int nodeID = 0; // export the children foreach (Node child in ((Node)behavior).Children) { ExportNode(file, namspace, behavior, "this", child, 3, ref nodeID); } // close constructor file.Write("\t\t}\r\n"); // close namespace and class file.Write("\t}\r\n}\r\n"); }
/// <summary> /// Exports a node to the given file. /// </summary> /// <param name="file">The file we want to export to.</param> /// <param name="behavior">The behaviour we are currently exporting.</param> /// <param name="node">The node we want to export.</param> protected void ExportNode(BsonSerializer file, BehaviorNode behavior, Node node) { if (!node.Enable) { return; } file.WriteStartElement("node"); file.WriteString(node.ExportClass); file.WriteString(node.Id.ToString()); { // export the properties this.ExportProperties(file, node); this.ExportAttachments(file, node); if (!node.IsFSM && !(node is ReferencedBehavior)) { // export the child nodes foreach (Node child in node.Children) { if (!node.GetConnector(child).IsAsChild) { file.WriteStartElement("custom"); this.ExportNode(file, behavior, child); file.WriteEndElement(); } else { this.ExportNode(file, behavior, child); } } } } file.WriteEndElement(); }
protected void ExportBehavior(StreamWriter file, BehaviorNode behavior) { string filename = behavior.FileManager.Filename; string nameSpace = _usedNamespace; string classname = Path.GetFileNameWithoutExtension(behavior.FileManager.Filename).Replace(" ", string.Empty); if (filename.StartsWith("http://")) { _filename = Path.GetFileName(filename); ExportBehaviorToServer(file, behavior); } else { _filename = Path.GetFullPath(filename); nameSpace = GetNamespace(_usedNamespace, _filename); classname = Path.GetFileNameWithoutExtension(behavior.FileManager.Filename).Replace(" ", string.Empty); file.Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); file.Write("<aiml version=\"1.0\">\r\n"); file.Write(" <state name=\"*\">\r\n"); // write comments file.Write(string.Format("\t<!-- Exported behavior: {0} --> \r\n", _filename)); file.Write(string.Format("\t<!-- Exported file: {0} -->\r\n\r\n", behavior.FileManager.Filename)); // export nodes int nodeID = 0; // export the children foreach (Node child in ((Node)behavior).Children) { ExportNode(file, nameSpace, behavior, "this", child, 3, ref nodeID); } // close constructor file.Write(" </state>\r\n"); file.Write("</aiml>\r\n"); } }
/// <summary> /// Creates a new referenced behaviour. /// </summary> /// <param name="rootBehavior">The behaviour this node belongs not. NOT the one is references.</param> /// <param name="referencedBehavior">The behaviour you want to reference.</param> public ReferencedBehavior(BehaviorNode rootBehavior, BehaviorNode referencedBehavior) : base(((Node)referencedBehavior).Label, Resources.ReferencedBehaviorDesc) { // when this node is saved, the children won't as they belong to another behaviour _saveChildren = false; _referencedBehavior = referencedBehavior; ((Node)_referencedBehavior).WasModified += new WasModifiedEventDelegate(referencedBehavior_WasModified); _referencedBehavior.WasRenamed += new Behavior.WasRenamedEventDelegate(referencedBehavior_WasRenamed); // assign the connector of the behaviour _genericChildren = _referencedBehavior.GenericChildren; _children.SetConnector(_genericChildren); List <ParInfo> pars = ((Node)_referencedBehavior).Pars; foreach (ParInfo p in pars) { _pars.Add(p.Clone()); } }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { if (_referencedBehavior == null) { LoadReferencedBehavior(); } // if we have a circular reference we must stop here if (_referencedBehavior == null || _referencedBehavior == rootBehavior) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.ReferencedBehaviorCircularReferenceError)); return; } // if our referenced behaviour could be loaded, check it as well for errors if (_referencedBehavior != null) { foreach (Node child in ((Node)_referencedBehavior).Children) { child.CheckForErrors(rootBehavior, result); } } }
/// <summary> /// Returns if any of the node's parents is a given behaviour. /// </summary> /// <param name="behavior">The behavior we want to check if it is an ancestor of this node.</param> /// <returns>Returns true if this node is a descendant of the given behavior.</returns> public override bool HasParentBehavior(BehaviorNode behavior) { if (behavior == null) { return(false); } ReferencedBehaviorNode refb = (ReferencedBehaviorNode)_node; Debug.Check(refb.Reference != null); if (refb.Reference == behavior) { return(true); } if (_parent == null) { return(false); } return(_parent.HasParentBehavior(behavior)); }
public ExportDialog(BehaviorTreeList behaviorTreeList, BehaviorNode node, bool ignoreErrors, TreeNode selectedTreeRoot, int formatIndex) { InitializeComponent(); _behaviorTreeList = behaviorTreeList; _node = node; _ignoreErrors = ignoreErrors; _selectedTreeRoot = selectedTreeRoot; // add all valid exporters to the format combobox Debug.Check(Workspace.Current != null); int exportIndex = -1; for (int i = 0; i < Plugin.Exporters.Count; ++i) { ExporterInfo info = Plugin.Exporters[i]; if (node != null || info.MayExportAll) { int index = this.exportSettingGridView.Rows.Add(); DataGridViewRow row = this.exportSettingGridView.Rows[index]; row.Cells["Enable"].Value = Workspace.Current.ShouldBeExported(info.ID); row.Cells["Format"].Value = info.Description; row.Cells["Format"].ReadOnly = true; row.Cells["Setting"].Value = info.ExportToUniqueFile ? "..." : ""; row.Cells["Setting"].ReadOnly = true; if (Workspace.Current.ShouldBeExported(info.ID) && (exportIndex == -1 || info.ExportToUniqueFile)) { exportIndex = i; } } } changeExportFormat(exportIndex); }
public BehaviorNodeTraceTag(BehaviorNode node, RequestLog log) : base("li") { var description = Description.For(node); AddClass("node-trace").Data("node-id", node.UniqueId.ToString()); var container = Add("div").AddClass("node-trace-container"); container.Text(description.Title); var start = log.FindStep <BehaviorStart>(x => x.Correlation.Node == node); var finish = log.FindStep <BehaviorFinish>(x => x.Correlation.Node == node); if (start == null) { AddClass("gray"); return; } // TODO -- What *should* happen here? if (finish == null) { return; } var exception = log.FindStep <ExceptionReport>(x => node.UniqueId.Equals(x.CorrelationId)); if (exception != null || !finish.Log.Succeeded) { AddClass("exception"); } var duration = finish.RequestTimeInMilliseconds - start.RequestTimeInMilliseconds; container.Add("span").Text(duration.ToString() + " ms").AddClass("node-trace-duration"); }
private void updateParameters(AgentType agentType, string agentName, int frame) { if (string.IsNullOrEmpty(agentName)) { return; } string typeName = (agentType == null) ? agentName : agentType.ToString(); string agentFullname = (agentType == null) ? agentName : agentType.ToString() + "#" + agentName; string behaviorFilename = FrameStatePool.GetBehaviorFilename(agentFullname, frame); BehaviorNode behavior = null; if (agentFullname == Plugin.DebugAgentInstance) { behavior = UIUtilities.ShowBehavior(behaviorFilename); } List <AgentDataPool.ValueMark> values = AgentDataPool.GetValidValues(agentType, agentFullname, frame); foreach (AgentDataPool.ValueMark value in values) { ParametersDock.SetProperty(behavior, typeName, agentName, value.Name, value.Value); } }
private void SetTask(string referencedBehaviorFileName) { string fullPath = FileManagers.FileManager.GetFullPath(referencedBehaviorFileName); BehaviorNode referencedBehavior = BehaviorManager.Instance.GetBehavior(fullPath); if (referencedBehavior != null) { //when expand planning process, don't update _task, as it will be set wrongly if (Plugin.EditMode == EditModes.Design) { Behavior refTree_ = referencedBehavior as Behavior; if (refTree_.Children.Count > 0 && refTree_.Children[0] is Task) { Task rootTask = refTree_.Children[0] as Task; if (rootTask.Prototype != null) { this._task = (MethodDef)rootTask.Prototype.Clone(); } } } } }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { if (_Precondition.Child == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.NoPreconditionError)); } if (_Action.Child == null) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.NoActionError)); } //if (_Effector.Child == null) //{ // result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.NoEffectorError)); //} if (!(this.Parent is Task)) { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.MethodParentError)); } base.CheckForErrors(rootBehavior, result); }
public override void PostLoad(BehaviorNode behavior) { if (this.LocalVars != null && this.Children.Count > 0) { BaseNode child = this.Children[0]; if (child is Task) { Task task = child as Task; List <ParInfo> pars = new List <ParInfo>(); task.CollectTaskPars(ref pars); foreach (ParInfo par in pars) { if (this.LocalVars.Find((p) => p.Name == par.Name) == null) { this.LocalVars.Add(par); } } } } base.PostLoad(behavior); }
private void ExportNodeClass(StreamWriter file, string btClassName, string agentType, BehaviorNode behavior, Node node) { string nodeName = string.Format("node{0}", node.Id); NodeCsExporter nodeExporter = NodeCsExporter.CreateInstance(node); nodeExporter.GenerateClass(node, file, "", nodeName, agentType, btClassName); ExportAttachmentClass(file, btClassName, node); if (!(node is ReferencedBehavior)) { foreach (Node child in node.Children) { ExportNodeClass(file, btClassName, agentType, behavior, child); } } }
public ExporterCs(BehaviorNode node, string outputFolder, string filename, List <string> includedFilenames = null) : base(node, outputFolder, filename, includedFilenames) { _outputFolder = Path.GetFullPath(_outputFolder); _filename = _filename.Replace('\\', '/'); }
private void ExportBody(StreamWriter file, BehaviorNode behavior) { string filename = Path.ChangeExtension(behavior.RelativePath, "").Replace(".", ""); filename = filename.Replace('\\', '/'); // write comments file.WriteLine("\t// Source file: {0}\r\n", filename); string btClassName = string.Format("bt_{0}", filename.Replace('/', '_')); string agentType = behavior.AgentType.AgentTypeName; // create the class definition of its attachments ExportAttachmentClass(file, btClassName, (Node)behavior); // create the class definition of its children foreach (Node child in ((Node)behavior).Children) { ExportNodeClass(file, btClassName, agentType, behavior, child); } // create the bt class file.WriteLine("\tpublic static class {0}\r\n\t{{", btClassName); // export the build function file.WriteLine("\t\tpublic static bool build_behavior_tree(BehaviorTree bt)\r\n\t\t{"); file.WriteLine("\t\t\tbt.SetClassNameString(\"BehaviorTree\");"); file.WriteLine("\t\t\tbt.SetId(-1);"); file.WriteLine("\t\t\tbt.SetName(\"{0}\");", filename); file.WriteLine("#if !BEHAVIAC_RELEASE"); file.WriteLine("\t\t\tbt.SetAgentType(\"{0}\");", agentType.Replace("::", ".")); file.WriteLine("#endif"); if (!string.IsNullOrEmpty(((Behavior)behavior).Domains)) { file.WriteLine("\t\t\tbt.SetDomains(\"{0}\");", ((Behavior)behavior).Domains); } if (((Behavior)behavior).DescriptorRefs.Count > 0) { file.WriteLine("\t\t\tbt.SetDescriptors(\"{0}\");", DesignerPropertyUtility.RetrieveExportValue(((Behavior)behavior).DescriptorRefs)); } ExportPars(file, "bt", (Node)behavior, "\t\t"); // export its attachments ExportAttachment(file, btClassName, agentType, "bt", (Node)behavior, "\t\t\t"); file.WriteLine("\t\t\t// children"); // export its children foreach (Node child in ((Node)behavior).Children) { ExportNode(file, btClassName, agentType, "bt", child, 3); } file.WriteLine("\t\t\treturn true;"); // close the build function file.WriteLine("\t\t}"); // close class file.WriteLine("\t}\r\n"); }
public ExporterCs(BehaviorNode node, string outputFolder, string filename, List <string> includedFilenames = null) : base(node, outputFolder, filename + ".cs", includedFilenames) { _outputFolder = Path.Combine(Path.GetFullPath(_outputFolder), "behaviac_generated"); }
/// <summary> /// Check the tree nodes according to the behaviors which are ought to be exported. /// </summary> /// <param name="pool">The pool we are checking.</param> /// <param name="node">The behavior we want to export. Use null if all behaviors may be exported.</param> public void CheckExportTreeNodes(TreeView tv, TreeNodeCollection pool, BehaviorNode node, bool ignoreErrors, TreeNode subTreeRoot, List <string> referencedFiles) { foreach (TreeNode tnode in pool) { NodeTag nodetag = (NodeTag)tnode.Tag; bool shouldDoubleCheck = false; // if no behavior is given enable all behaviors to be exported. if (node == null) { tnode.Checked = (subTreeRoot != null) ? isChildOf(tnode, subTreeRoot) : true; shouldDoubleCheck = tnode.Checked; } else { // if the behavior is new one compare the label if (node.FileManager == null) { tnode.Checked = (tnode.Text == ((Node)node).Label); } // otherwise compare the filename else { bool shouldCheck = (nodetag.Filename == node.Filename); if (!shouldCheck && referencedFiles.Count > 0) { string relativeFile = FileManagers.FileManager.GetRelativePath(nodetag.Filename); shouldCheck = referencedFiles.Contains(relativeFile); } tnode.Checked = shouldCheck; shouldDoubleCheck = true; } } if (tnode.Checked && (node != null || subTreeRoot != null)) { tv.SelectedNode = tnode; } if (nodetag.Type == NodeTagType.Behavior) { if (shouldDoubleCheck) { if (!ignoreErrors && (node == null || tnode.Text == ((Node)node).Label)) { // Get or load the behavior. BehaviorNode behavior = _behaviorTreeList.GetBehavior(nodetag, tnode.Text); if (behavior != null && behavior is Behavior) { // Check errors for this behavior. List <Node.ErrorCheck> result = new List <Node.ErrorCheck>(); ((Behavior)behavior).CheckForErrors(behavior, result); // If there is any error, this node should be disabled. if (Plugin.GetErrorChecks(result).Count > 0) { tnode.Checked = false; tnode.ForeColor = SystemColors.GrayText; } } } } else { tnode.Checked = false; } } else { tnode.Checked = false; } // check the child nodes CheckExportTreeNodes(tv, tnode.Nodes, node, ignoreErrors, subTreeRoot, referencedFiles); if (!tnode.Checked && tnode.Nodes.Count > 0) { int checkedChildCount = 0; foreach (TreeNode childNode in tnode.Nodes) { NodeTag childTag = (NodeTag)childNode.Tag; if (childNode.Checked || childTag.Type != NodeTagType.Behavior && childNode.Nodes.Count == 0) { checkedChildCount++; } } if (checkedChildCount == tnode.Nodes.Count) { tnode.Checked = true; } } } }
public override void CheckForErrors(BehaviorNode rootBehavior, List <ErrorCheck> result) { base.CheckForErrors(rootBehavior, result); }
private void changeExportFormat(int exportIndex) { if (exportIndex < 0) { return; } _isCheckingByTypeChanged = true; this.treeView.Hide(); this.treeView.Nodes.Clear(); TreeNode root = _behaviorTreeList.GetBehaviorGroup(); TreeNode newRoot = new TreeNode(root.Text, 0, 0); newRoot.Tag = root.Tag; this.treeView.Nodes.Add(newRoot); CopyTreeNodes(root.Nodes, newRoot.Nodes); TreeNode subTreeRoot = (_selectedTreeRoot != null) ? getNodeByTag(this.treeView.Nodes, _selectedTreeRoot.Tag) : null; ExporterInfo exporter = Plugin.Exporters[exportIndex]; //BehaviorNode node = exporter.HasSettings ? null : _node; BehaviorNode node = _node; bool ignoreErrors = exporter.HasSettings ? false : _ignoreErrors; List <string> referencedFiles = new List <string>(); if (node != null && node is Node) { ((Node)node).GetReferencedFiles(ref referencedFiles); } CheckExportTreeNodes(this.treeView, this.treeView.Nodes, node, ignoreErrors, subTreeRoot, referencedFiles); this.treeView.ExpandAll(); if (node != null) { TreeNode treeNode = getNodeByFilename(this.treeView.Nodes, node.Filename); if (treeNode != null) { treeNode.EnsureVisible(); } } else if (this.treeView.Nodes.Count > 0) { this.treeView.Nodes[0].EnsureVisible(); } this.treeView.Select(); int errorsFilesCount = SetFileCountLabel(); bool showFaultBehaviors = _initialized ? onlyShowErrorsCheckBox.Checked : (errorsFilesCount > 0); exportBehaviorsLabel.Text = showFaultBehaviors ? Resources.FaultBehaviors : Resources.ExportBehaviors; if (!_initialized && showFaultBehaviors) { onlyShowErrorsCheckBox.Checked = true; } ShowNodes(this.treeView.Nodes, showFaultBehaviors); RemoveEmptyNodes(this.treeView.Nodes); this.treeView.Show(); _isCheckingByTypeChanged = false; }