protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorIterator iterator = node as DecoratorIterator;
if (iterator == null)
return;
if (iterator.Opl != null || iterator.Opr != null)
{
if (iterator.Opl != null)
{
stream.WriteLine("{0}\t\t\tthis.m_opl = Condition.LoadLeft(\"{1}\");", indent, iterator.Opl.GetExportValue());
stream.WriteLine("{0}\t\t\tDebug.Check(this.m_opl != null);", indent);
}
stream.WriteLine("{0}\t\t\tstring typeName = null;", indent);
if (iterator.Opr != null)
{
stream.WriteLine("{0}\t\t\tthis.m_opr = Condition.LoadRight(\"{1}\", ref typeName);", indent, iterator.Opr.GetExportValue());
stream.WriteLine("{0}\t\t\tDebug.Check(this.m_opr != null);", indent);
}
}
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorIterator iterator = node as DecoratorIterator;
if (iterator == null)
return;
if (iterator.Opl != null || iterator.Opr != null)
{
if (iterator.Opl != null)
{
stream.WriteLine("{0}\t\t\tthis->m_opl = Condition::LoadLeft(\"{1}\");", indent, iterator.Opl.GetExportValue());
stream.WriteLine("{0}\t\t\tBEHAVIAC_ASSERT(this->m_opl != NULL);", indent);
}
stream.WriteLine("{0}\t\t\tbehaviac::string typeName;", indent);
if (iterator.Opr != null)
{
stream.WriteLine("{0}\t\t\tthis->m_opr = Condition::LoadRight(\"{1}\", typeName);", indent, iterator.Opr.GetExportValue());
stream.WriteLine("{0}\t\t\tBEHAVIAC_ASSERT(this->m_opr != NULL);", indent);
}
}
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
DecoratorLoopUntil node = (DecoratorLoopUntil)newnode;
node._until = this._until;
}
private void ExportAttachment(StreamWriter file, string btClassName, string agentType, string parentName, Node node, string indent)
{
if (node.Attachments.Count > 0)
{
file.WriteLine("{0}// attachments", indent);
foreach (Behaviac.Design.Attachments.Attachment attach in node.Attachments)
{
file.WriteLine("{0}{{", indent);
string nodeName = string.Format("attach{0}", attach.Id);
// export its instance and the properties
AttachmentCsExporter attachmentExporter = AttachmentCsExporter.CreateInstance(attach);
attachmentExporter.GenerateInstance(attach, file, indent, nodeName, agentType, btClassName);
ExportPars(file, nodeName, attach, indent);
file.WriteLine("{0}\t{1}.Attach({2});", indent, parentName, nodeName);
if (attach is Behaviac.Design.Attachments.Event)
{
file.WriteLine("{0}\t{1}.SetHasEvents({1}.HasEvents() | ({2} is Event));", indent, parentName, nodeName);
}
file.WriteLine("{0}}}", indent);
}
}
}
public void SetPar(ParInfo par, Nodes.Node rootNode, bool isNewPar)
{
Debug.Check(par != null && rootNode != null);
_isNewPar = isNewPar;
_initialized = false;
this.Text = isNewPar ? Resources.NewPar : Resources.EditPar;
_par = par;
_parTemp = par.Clone();
_rootNode = rootNode;
setParTypes();
if (par != null) {
_isArray = Plugin.IsArrayType(par.Type);
Type type = _isArray ? par.Type.GetGenericArguments()[0] : par.Type;
nameTextBox.Text = par.Name;
arrayCheckBox.Checked = _isArray;
typeComboBox.Text = Plugin.GetMemberValueTypeName(type);
descTextBox.Text = par.BasicDescription;
setValue(type);
}
enableOkButton();
_initialized = true;
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
ReferencedBehavior referencedBehavior = node as ReferencedBehavior;
if (referencedBehavior == null)
return;
stream.WriteLine("{0}\t\tvirtual const char* GetReferencedTree(const Agent* pAgent) const", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
string retStr = RightValueCppExporter.GenerateCode(referencedBehavior.ReferenceBehavior, stream, indent + "\t\t\t", "const char*", string.Empty, "_referencedBehavior");
bool bConst = false;
if (referencedBehavior.ReferenceBehavior.Var != null && referencedBehavior.ReferenceBehavior.Var.IsConst)
{
bConst = true;
}
if (!bConst)
{
stream.WriteLine("{0}\t\t\tif (pAgent) {{", indent);
}
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
if (!bConst)
{
stream.WriteLine("{0}\t\t\t}}", indent);
stream.WriteLine("{0}\t\t\treturn 0;", indent);
}
stream.WriteLine("{0}\t\t}}", indent);
}
/// <summary>
/// Creates a new subitem which can show a property on the node.
/// </summary>
/// <param name="owner">The node whose property we want to show. MUST be the same as the one the subitem belongs to.</param>
/// <param name="property">The property we want to show.</param>
/// <param name="att">The attribute associated with the property.</param>
public SubItemProperty(Node owner, PropertyInfo property, DesignerProperty att)
: base(null, null, __font, Brushes.White, Alignment.Center, false)
{
_owner = owner;
_property = property;
_attribute = att;
}
public static NodeCppExporter CreateInstance(Node node)
{
if (node != null)
{
string nodeExporter = "PluginBehaviac.NodeExporters." + node.ExportClass + "CppExporter";
Type exporterType = Type.GetType(nodeExporter);
if (exporterType == null)
{
foreach (Assembly assembly in Plugin.GetLoadedPlugins())
{
string filename = Path.GetFileNameWithoutExtension(assembly.Location);
nodeExporter = filename + ".NodeExporters." + node.ExportClass + "CppExporter";
exporterType = assembly.GetType(nodeExporter);
if (exporterType != null)
{
break;
}
}
}
if (exporterType != null)
{
return (NodeCppExporter)Activator.CreateInstance(exporterType);
}
}
return new NodeCppExporter();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
DecoratorLog dec = (DecoratorLog)newnode;
dec._logMessage = _logMessage;
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
State state = (State)newnode;
state._method = this._method;
}
/// <summary>
/// Branches the list for a node.
/// </summary>
/// <param name="node">The node we are branching for.</param>
/// <returns>A new list which contains the previously processed behaviours for referenced behaviours. For other nodes it returns the same list.</returns>
public ProcessedBehaviors Branch(Node node)
{
ReferencedBehaviorNode refnode= node as ReferencedBehaviorNode;
if(refnode !=null)
return new ProcessedBehaviors(this);
return this;
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
WaitFrames dec = (WaitFrames)newnode;
if (_frames != null)
dec._frames = (RightValueDef)_frames.Clone();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
DecoratorTime dec = (DecoratorTime)newnode;
if (_time != null)
dec._time = (VariableDef)_time.Clone();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
Wait dec = (Wait)newnode;
if (_time != null)
dec._time = (RightValueDef)_time.Clone();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
ExampleNode dec = (ExampleNode)newnode;
if (_time != null)
dec._time = (VariableDef)_time.Clone();
}
/// <summary>
/// Checks if a node may be processed without running into circular references. The node is not added to the list.
/// </summary>
/// <param name="node">The node we want to process.</param>
/// <returns>Returns true when the node may be processed, if not the calling function has to stop.</returns>
public bool MayProcessCheckOnly(Node node) {
ReferencedBehavior refnode = node as ReferencedBehavior;
if (refnode != null)
{ return !_processedBehaviors.Contains(refnode); }
return true;
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
DecoratorCount dec = (DecoratorCount)newnode;
if (_count != null)
dec._count = (VariableDef)_count.Clone();
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorLoopUntil decoratorLoopUntil = node as DecoratorLoopUntil;
Debug.Check(decoratorLoopUntil != null);
stream.WriteLine("{0}\t\t\tm_until = {1};", indent, decoratorLoopUntil.Until ? "true" : "false");
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorLog decoratorLog = node as DecoratorLog;
Debug.Check(decoratorLog != null);
stream.WriteLine("{0}\t\t\tm_message = \"{1}\";", indent, decoratorLog.Log);
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Decorator decorator = node as Decorator;
Debug.Check(decorator != null);
stream.WriteLine("{0}\t\t\tm_bDecorateWhenChildEnds = {1};", indent, decorator.DecorateWhenChildEnds ? "true" : "false");
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Wait wait = node as Wait;
Debug.Check(wait != null);
stream.WriteLine("{0}\t\t\tm_ignoreTimeScale = {1};", indent, wait.IgnoreTimeScale ? "true" : "false");
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Query query = node as Query;
Debug.Check(query != null);
stream.WriteLine("{0}\t\t\tthis->Initialize(\"{1}\", \"{2}\");",
indent, query.Domain, DesignerPropertyUtility.RetrieveExportValue(query.Descriptors));
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
WaitState waitState = node as WaitState;
if (waitState == null)
return;
stream.WriteLine("{0}\t\t\tm_ignoreTimeScale = {1};", indent, waitState.IgnoreTimeScale ? "true" : "false");
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
SequenceStochastic sequenceStochastic = node as SequenceStochastic;
Debug.Check(sequenceStochastic != null);
stream.WriteLine("{0}\t\tpublic void Initialize(string method)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tthis.m_method = Action.LoadMethod(method);", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorLoop decoratorLoop = node as DecoratorLoop;
if (decoratorLoop == null)
return;
stream.WriteLine("{0}\t\t\tm_bDoneWithinFrame = {1};", indent, decoratorLoop.DoneWithinFrame ? "true" : "false");
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
if (_weight != null)
{
DecoratorWeight dec = (DecoratorWeight)newnode;
dec._weight = (VariableDef)_weight.Clone();
}
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
Wait dec = (Wait)newnode;
if (_time != null)
dec._time = (VariableDef)_time.Clone();
dec._ignoreTimeScale = this._ignoreTimeScale;
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
SelectorProbability selectorProbability = node as SelectorProbability;
Debug.Check(selectorProbability != null);
stream.WriteLine("{0}\t\tpublic void Initialize(string method)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tthis.m_method = Action.LoadMethod(method);", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
public static NodeCsExporter CreateInstance(Node node)
{
if (node != null)
{
Type exporterType = getExporterType(node.GetType());
if (exporterType != null)
return (NodeCsExporter)Activator.CreateInstance(exporterType);
}
return new NodeCsExporter();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
SelectorProbability prec = (SelectorProbability)newnode;
if (_method != null)
{
prec._method = (MethodDef)_method.Clone();
}
}
protected override void CloneProperties(Behaviac.Design.Nodes.Node newattach)
{
base.CloneProperties(newattach);
DecoratorIterator prec = (DecoratorIterator)newattach;
if (_opl != null)
{
prec._opl = (VariableDef)_opl.Clone();
}
if (_opr != null)
{
prec._opr = (RightValueDef)_opr.Clone();
}
}
private static void AddAfterConditions(Node node, Behaviac.Design.Attachments.BinaryOperator binaryOpr, Behaviac.Design.Nodes.Node newNode, Behaviac.Design.Nodes.Node.Connector connector, Node oldOne)
{
node.RemoveChild(connector, oldOne);
Type seqType = Plugin.GetType("PluginBehaviac.Nodes.And");
if (binaryOpr == Behaviac.Design.Attachments.BinaryOperator.Or)
{
seqType = Plugin.GetType("PluginBehaviac.Nodes.Or");
}
Behaviac.Design.Nodes.Node seq = Behaviac.Design.Nodes.Node.Create(seqType);
seq.AddChild(BaseNode.Connector.kGeneric, newNode);
seq.AddChild(BaseNode.Connector.kGeneric, oldOne);
node.AddChild(BaseNode.Connector.kInterupt, seq);
}
public Event(Behaviac.Design.Nodes.Node node)
: base(node, Resources.Event, Resources.EventDesc)
{
}
protected override void CloneProperties(Behaviac.Design.Nodes.Node newnode)
{
base.CloneProperties(newnode);
}
public override void PostCreate(List <Node.ErrorCheck> result, int version, Behaviac.Design.Nodes.Node node, System.Xml.XmlNode xmlNode)
{
AutoRestruct(result, version, this, node);
}
//if there is a 'Predicate' attachment, convert it to a Condition node and attach it to the '_custom_condition' connector.
private void AutoRestruct(List <Node.ErrorCheck> result, int version, Behaviac.Design.Attachments.Attachment a, Node node)
{
if (version <= 1)
{
string attachClass = a.GetType().FullName;
if (attachClass.IndexOf("PluginBehaviac.Events.Predicate") >= 0)
{
DesignerPropertyInfo propInfo = DesignerProperty.GetDesignerProperty(a.GetType(), "Opl");
RightValueDef opl = propInfo.GetValue(a) as RightValueDef;
propInfo = DesignerProperty.GetDesignerProperty(a.GetType(), "Opr");
RightValueDef opr = propInfo.GetValue(a) as RightValueDef;
propInfo = DesignerProperty.GetDesignerProperty(a.GetType(), "Operator");
OperatorType oprr = (OperatorType)propInfo.GetValue(a);
OperatorTypes oprType = (OperatorTypes)((int)OperatorTypes.Equal - (int)OperatorType.Equal + (int)oprr);
propInfo = DesignerProperty.GetDesignerProperty(a.GetType(), "BinaryOperator");
Behaviac.Design.Attachments.BinaryOperator binaryOpr = (Behaviac.Design.Attachments.BinaryOperator)propInfo.GetValue(a);
string clss = node.GetType().FullName;
bool bIsSeqSel = (node.GetType().IsSubclassOf(typeof(Sequence)) ||
node.GetType().IsSubclassOf(typeof(Selector)));
bool bCare = (bIsSeqSel ||
node.GetType().IsSubclassOf(typeof(Impulse))
);
if (bCare ||
clss == "PluginBehaviac.Nodes.Query" ||
clss == "PluginBehaviac.Nodes.DecoratorCountLimit")
{
node.RemoveAttachment(a);
node.Behavior.TriggerWasModified(node);
Type newType = Plugin.GetType("PluginBehaviac.Nodes.Condition");
Behaviac.Design.Nodes.Node newNode = Behaviac.Design.Nodes.Node.Create(newType);
Behaviac.Design.Nodes.Node.Connector connector = node.GetConnector(Node.Connector.kInterupt);
if (connector != null && connector.Identifier == Node.Connector.kInterupt && connector.ChildCount > 0)
{
//it has multiple Predicates, so insert all of them to a newly created Sequence
Node oldOne = (Node)connector.GetChild(0);
if (oldOne.GetType().IsSubclassOf(typeof(Condition)))
{
AddAfterConditions(node, binaryOpr, newNode, connector, oldOne);
}
else
{
if (bIsSeqSel)
{
Debug.Check(oldOne.GetType().IsSubclassOf(typeof(Decorator)));
Decorator d = oldOne as Decorator;
node = oldOne;
connector = node.GetConnector(BaseNode.Connector.kGeneric);
oldOne = (Node)d.Children[0];
}
if (oldOne.GetType() == typeof(PluginBehaviac.Nodes.And))
{
if (binaryOpr == Behaviac.Design.Attachments.BinaryOperator.Or)
{
node.RemoveChild(connector, oldOne);
Type selType1 = Plugin.GetType("PluginBehaviac.Nodes.Or");
Behaviac.Design.Nodes.Node sel = Behaviac.Design.Nodes.Node.Create(selType1);
sel.AddChild(BaseNode.Connector.kGeneric, oldOne);
sel.AddChild(BaseNode.Connector.kGeneric, newNode);
node.AddChild(BaseNode.Connector.kInterupt, sel);
}
else
{
oldOne.AddChild(BaseNode.Connector.kGeneric, newNode);
}
}
else if (oldOne.GetType() == typeof(PluginBehaviac.Nodes.Or))
{
if (binaryOpr == Behaviac.Design.Attachments.BinaryOperator.And)
{
node.RemoveChild(connector, oldOne);
Type selType1 = Plugin.GetType("PluginBehaviac.Nodes.And");
Behaviac.Design.Nodes.Node sel = Behaviac.Design.Nodes.Node.Create(selType1);
sel.AddChild(BaseNode.Connector.kGeneric, oldOne);
sel.AddChild(BaseNode.Connector.kGeneric, newNode);
node.AddChild(BaseNode.Connector.kInterupt, sel);
}
else
{
oldOne.AddChild(BaseNode.Connector.kGeneric, newNode);
}
}
else if (oldOne.GetType().IsSubclassOf(typeof(Condition)))
{
AddAfterConditions(node, binaryOpr, newNode, connector, oldOne);
}
else
{
Debug.Check(false);
}
}
}
else
{
//the first condition
Behaviac.Design.Nodes.Node notNode = null;
if (bIsSeqSel)
{
//for sequence/selector, it is reverted
Type notType = Plugin.GetType("PluginBehaviac.Nodes.DecoratorNot");
notNode = Behaviac.Design.Nodes.Node.Create(notType);
node.AddChild(BaseNode.Connector.kInterupt, notNode);
notNode.AddChild(BaseNode.Connector.kGeneric, newNode);
}
else
{
node.AddChild(BaseNode.Connector.kInterupt, newNode);
}
}
// initialise the attachments properties
IList <DesignerPropertyInfo> lp = newNode.GetDesignerProperties();
for (int p = 0; p < lp.Count; ++p)
{
if (lp[p].Property.Name == "Opl")
{
lp[p].Property.SetValue(newNode, opl, null);
}
else if (lp[p].Property.Name == "Opr")
{
lp[p].Property.SetValue(newNode, opr, null);
}
else if (lp[p].Property.Name == "Operator")
{
lp[p].Property.SetValue(newNode, oprr, null);
}
}
// update attacheent with attributes
newNode.OnPropertyValueChanged(false);
}
else if (clss == "PluginBehaviac.Nodes.Action")
{
Type newType = Plugin.GetType("PluginBehaviac.Events.Precondition");
Behaviac.Design.Attachments.Attachment newNode = Behaviac.Design.Attachments.Attachment.Create(newType, node);
node.AddAttachment(newNode);
node.RemoveAttachment(a);
node.Behavior.TriggerWasModified(node);
// initialise the attachments properties
IList <DesignerPropertyInfo> lp = newNode.GetDesignerProperties();
for (int p = 0; p < lp.Count; ++p)
{
if (lp[p].Property.Name == "BinaryOperator")
{
lp[p].Property.SetValue(newNode, binaryOpr, null);
}
else if (lp[p].Property.Name == "Opl")
{
lp[p].Property.SetValue(newNode, opl, null);
}
else if (lp[p].Property.Name == "Opr2")
{
lp[p].Property.SetValue(newNode, opr, null);
}
else if (lp[p].Property.Name == "Operator")
{
lp[p].Property.SetValue(newNode, oprType, null);
}
else if (lp[p].Property.Name == "IsAlive")
{
lp[p].SetValueFromString(result, newNode, "true");
}
}
// update attacheent with attributes
newNode.OnPropertyValueChanged(false);
}
else
{
Debug.Check(false);
}
}
} // if (version <= 1)
}
