public static void GenerateOperand(DefaultObject defaltObj, StringWriter stream, string indent, RightValueDef operand, string operandName, string nodeName)
{
if (operand != null)
{
string typeName = DataCppExporter.GetGeneratedNativeType(operand.ValueType);
if (operand.IsMethod) // method
{
RightValueCppExporter.GenerateCode(defaltObj, operand, stream, indent, typeName, operandName, string.Empty);
RightValueCppExporter.PostGenerateCode(operand, stream, indent, typeName, operandName, string.Empty);
}
else
{
VariableDef var = operand.Var;
if (var != null)
{
if (var.IsProperty) // property
{
PropertyDef prop = var.Property;
if (prop != null)
{
string property = PropertyCppExporter.GetProperty(defaltObj, prop, var.ArrayIndexElement, stream, indent, operandName, nodeName);
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && var.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(defaltObj, var.ArrayIndexElement, stream, indent, "int", operandName + "_index", nodeName + "_opl");
property = string.Format("({0})[{1}_index]", property, operandName);
}
stream.WriteLine("{0}{1}& {2} = {3};", indent, typeName, operandName, property);
}
}
else if (var.IsConst) // const
{
RightValueCppExporter.GenerateCode(defaltObj, operand, stream, indent, typeName, operandName, string.Empty);
}
}
}
}
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Compute compute = node as Compute;
if (compute == null)
{
return;
}
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
if (compute.Opl != null && compute.Opr1 != null && compute.Opr2 != null)
{
string typeName = DataCppExporter.GetGeneratedNativeType(compute.Opr1.ValueType);
RightValueCppExporter.GenerateCode(node, compute.Opr1, stream, indent + "\t\t\t", typeName, "opr1", "opr1");
RightValueCppExporter.GenerateCode(node, compute.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "opr2");
string oprStr = string.Empty;
switch (compute.Operator)
{
case ComputeOperator.Add:
oprStr = "opr1 + opr2";
break;
case ComputeOperator.Sub:
oprStr = "opr1 - opr2";
break;
case ComputeOperator.Mul:
oprStr = "opr1 * opr2";
break;
case ComputeOperator.Div:
oprStr = "opr1 / opr2";
break;
default:
Debug.Check(false, "The operator is wrong!");
break;
}
oprStr = string.Format("({0})({1})", typeName, oprStr);
PropertyDef prop = compute.Opl.Property;
if (prop != null)
{
string property = PropertyCppExporter.GetProperty(node, prop, compute.Opl.ArrayIndexElement, stream, indent + "\t\t\t", "opl", "compute");
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && compute.Opl.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(node, compute.Opl.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opl_index", "compute_opl");
property = string.Format("({0})[opl_index]", property);
}
if (!prop.IsArrayElement && (prop.IsPar || prop.IsCustomized))
{
string propBasicName = prop.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string agentName = PropertyCppExporter.GetGenerateAgentName(prop, "opl", "compute");
stream.WriteLine("{0}\t\t\t{1}->SetVariable(\"{2}\", {3}, {4}u);", indent, agentName, propBasicName, oprStr, id);
}
else
{
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, property, oprStr);
}
}
if (compute.Opr1.IsMethod)
{
RightValueCppExporter.PostGenerateCode(compute.Opr1, stream, indent + "\t\t\t", compute.Opr1.NativeType, "opr1", string.Empty);
}
if (compute.Opr2.IsMethod)
{
RightValueCppExporter.PostGenerateCode(compute.Opr2, stream, indent + "\t\t\t", compute.Opr2.NativeType, "opr2", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
protected override void GenerateMethod(Attachment attachment, StringWriter stream, string indent)
{
base.GenerateMethod(attachment, stream, indent);
AttachAction attach = attachment as AttachAction;
if (attach == null)
{
return;
}
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
if (attach.IsAction())
{
string method = MethodCppExporter.GenerateCode(attachment, attach.Opl.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl");
stream.WriteLine("{0}\t\t\t{1};", indent, method);
MethodCppExporter.PostGenerateCode(attach.Opl.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl");
}
else if (attach.IsAssign())
{
if (attach.Opl != null && !attach.Opl.IsMethod && attach.Opl.Var != null && attach.Opr2 != null)
{
PropertyDef prop = attach.Opl.Var.Property;
if (prop != null)
{
RightValueCppExporter.GenerateCode(attachment, attach.Opr2, stream, indent + "\t\t\t", attach.Opr2.NativeType, "opr2", "opr2");
string property = PropertyCppExporter.GetProperty(attachment, prop, attach.Opl.Var.ArrayIndexElement, stream, indent + "\t\t\t", "opl", "attach");
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && attach.Opl.Var.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(attachment, attach.Opl.Var.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opl_index", "attach_opl");
property = string.Format("({0})[opl_index]", property);
}
if (!prop.IsArrayElement && (prop.IsPar || prop.IsCustomized))
{
string propBasicName = prop.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string agentName = PropertyCppExporter.GetGenerateAgentName(prop, "opl", "attach");
stream.WriteLine("{0}\t\t\t{1}->SetVariable(\"{2}\", {3}u, opr2);", indent, agentName, propBasicName, id);
}
else
{
stream.WriteLine("{0}\t\t\t{1} = opr2;", indent, property);
}
if (attach.Opr2.IsMethod)
{
RightValueCppExporter.PostGenerateCode(attach.Opr2, stream, indent + "\t\t\t", attach.Opr2.NativeType, "opr2", string.Empty);
}
}
}
}
else if (attach.IsCompare())
{
ConditionCppExporter.GenerateOperand(attachment, stream, indent + "\t\t\t", attach.Opl, "opl", "");
ConditionCppExporter.GenerateOperand(attachment, stream, indent + "\t\t\t", attach.Opr2, "opr2", "");
switch (attach.Operator)
{
case OperatorTypes.Equal:
stream.WriteLine("{0}\t\t\tbool op = PrivateDetails::Equal(opl, opr2);", indent);
break;
case OperatorTypes.NotEqual:
stream.WriteLine("{0}\t\t\tbool op = !PrivateDetails::Equal(opl, opr2);", indent);
break;
case OperatorTypes.Greater:
stream.WriteLine("{0}\t\t\tbool op = PrivateDetails::Greater(opl, opr2);", indent);
break;
case OperatorTypes.GreaterEqual:
stream.WriteLine("{0}\t\t\tbool op = PrivateDetails::GreaterEqual(opl, opr2);", indent);
break;
case OperatorTypes.Less:
stream.WriteLine("{0}\t\t\tbool op = PrivateDetails::Less(opl, opr2);", indent);
break;
case OperatorTypes.LessEqual:
stream.WriteLine("{0}\t\t\tbool op = PrivateDetails::LessEqual(opl, opr2);", indent);
break;
default:
stream.WriteLine("{0}\t\t\tbool op = false;", indent);
break;
}
stream.WriteLine("{0}\t\t\tif (!op)", indent);
stream.WriteLine("{0}\t\t\t\tresult = BT_FAILURE;", indent);
}
else if (attach.IsCompute())
{
if (attach.Opl != null && !attach.Opl.IsMethod && attach.Opl.Var != null && attach.Opr1 != null && attach.Opr2 != null)
{
PropertyDef prop = attach.Opl.Var.Property;
if (prop != null)
{
string typeName = DataCppExporter.GetGeneratedNativeType(attach.Opr1.ValueType);
RightValueCppExporter.GenerateCode(attachment, attach.Opr1, stream, indent + "\t\t\t", typeName, "opr1", "opr1");
RightValueCppExporter.GenerateCode(attachment, attach.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "opr2");
string oprStr = string.Empty;
switch (attach.Operator)
{
case OperatorTypes.Add:
oprStr = "opr1 + opr2";
break;
case OperatorTypes.Sub:
oprStr = "opr1 - opr2";
break;
case OperatorTypes.Mul:
oprStr = "opr1 * opr2";
break;
case OperatorTypes.Div:
oprStr = "opr1 / opr2";
break;
default:
Debug.Check(false, "The operator is wrong!");
break;
}
oprStr = string.Format("({0})({1})", typeName, oprStr);
string property = PropertyCppExporter.GetProperty(attachment, prop, attach.Opl.Var.ArrayIndexElement, stream, indent + "\t\t\t", "opl", "attach");
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && attach.Opl.Var.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(attachment, attach.Opl.Var.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opl_index", "attach_opl");
property = string.Format("({0})[opl_index]", property);
}
string propBasicName = prop.BasicName.Replace("[]", "");
if (!prop.IsArrayElement && (prop.IsPar || prop.IsCustomized))
{
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string agentName = PropertyCppExporter.GetGenerateAgentName(prop, "opl", "attach");
stream.WriteLine("{0}\t\t\t{1}->SetVariable(\"{2}\", {3}u, {4});", indent, agentName, propBasicName, id, oprStr);
}
else
{
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, property, oprStr);
}
if (attach.Opr1.IsMethod)
{
RightValueCppExporter.PostGenerateCode(attach.Opr1, stream, indent + "\t\t\t", typeName, "opr1", string.Empty);
}
if (attach.Opr2.IsMethod)
{
RightValueCppExporter.PostGenerateCode(attach.Opr2, stream, indent + "\t\t\t", typeName, "opr2", string.Empty);
}
}
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
PluginBehaviac.Nodes.Condition condition = node as PluginBehaviac.Nodes.Condition;
Debug.Check(condition != null);
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
string typeName = DataCppExporter.GetGeneratedNativeType(condition.Opl.ValueType);
// opl
RightValueCppExporter.GenerateCode(condition.Opl, stream, indent + "\t\t\t", typeName, "opl", string.Empty);
if (condition.Opl.IsMethod)
{
RightValueCppExporter.PostGenerateCode(condition.Opl, stream, indent + "\t\t\t", typeName, "opl", string.Empty);
}
// opr
VariableCppExporter.GenerateCode(condition.Opr, stream, indent + "\t\t\t", typeName, "opr", string.Empty);
// Operator
switch (condition.Operator)
{
case OperatorType.Equal:
stream.WriteLine("{0}\t\t\tbool op = Details::Equal(opl, opr);", indent);
break;
case OperatorType.NotEqual:
stream.WriteLine("{0}\t\t\tbool op = !Details::Equal(opl, opr);", indent);
break;
case OperatorType.Greater:
stream.WriteLine("{0}\t\t\tbool op = Details::Greater(opl, opr);", indent);
break;
case OperatorType.GreaterEqual:
stream.WriteLine("{0}\t\t\tbool op = Details::GreaterEqual(opl, opr);", indent);
break;
case OperatorType.Less:
stream.WriteLine("{0}\t\t\tbool op = Details::Less(opl, opr);", indent);
break;
case OperatorType.LessEqual:
stream.WriteLine("{0}\t\t\tbool op = Details::LessEqual(opl, opr);", indent);
break;
case OperatorType.And:
stream.WriteLine("{0}\t\t\tbool op = opl && opr;", indent);
break;
case OperatorType.Or:
stream.WriteLine("{0}\t\t\tbool op = opl || opr;", indent);
break;
default:
stream.WriteLine("{0}\t\t\tbool op = false;", indent);
break;
}
stream.WriteLine("{0}\t\t\treturn op ? BT_SUCCESS : BT_FAILURE;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Assignment assignment = node as Assignment;
if (assignment == null)
{
return;
}
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
if (assignment.Opl != null && assignment.Opr != null)
{
PropertyDef prop = assignment.Opl.Property;
if (prop != null)
{
RightValueCppExporter.GenerateCode(node, assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", "opr");
string property = PropertyCppExporter.GetProperty(node, prop, assignment.Opl.ArrayIndexElement, stream, indent + "\t\t\t", "opl", "assignment");
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && assignment.Opl.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(node, assignment.Opl.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opl_index", "assignment_opl");
property = string.Format("({0})[opl_index]", property);
}
string opr = "opr";
if (!Plugin.IsArrayType(prop.Type))
{
if (assignment.Opr.Var != null && assignment.Opr.Var.ArrayIndexElement != null)
{
ParameterCppExporter.GenerateCode(node, assignment.Opr.Var.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opr_index", "assignment_opr");
opr = string.Format("({0})[opr_index]", opr);
}
}
if (!prop.IsArrayElement && (prop.IsPar || prop.IsCustomized))
{
string propBasicName = prop.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string agentName = PropertyCppExporter.GetGenerateAgentName(prop, "opl", "assignment");
stream.WriteLine("{0}\t\t\t{1}->SetVariable(\"{2}\", {3}, {4}u);", indent, agentName, propBasicName, opr, id);
}
else
{
if (assignment.IsCasting)
{
stream.WriteLine("{0}\t\t\t{1} = ({2}){3};", indent, property, DataCppExporter.GetGeneratedNativeType(assignment.Opl.ValueType), opr);
}
else
{
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, property, opr);
}
}
}
if (assignment.Opr.IsMethod)
{
RightValueCsExporter.PostGenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Compute compute = node as Compute;
Debug.Check(compute != null);
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
if (compute.Opl != null && compute.Opr1 != null && compute.Opr2 != null)
{
RightValueCppExporter.GenerateCode(compute.Opr1, stream, indent + "\t\t\t", compute.Opr1.NativeType, "opr1", "opr1");
RightValueCppExporter.GenerateCode(compute.Opr2, stream, indent + "\t\t\t", compute.Opr2.NativeType, "opr2", "opr2");
string oprStr = string.Empty;
switch (compute.Operator)
{
case ComputeOperator.Add:
oprStr = "opr1 + opr2";
break;
case ComputeOperator.Sub:
oprStr = "opr1 - opr2";
break;
case ComputeOperator.Mul:
oprStr = "opr1 * opr2";
break;
case ComputeOperator.Div:
oprStr = "opr1 / opr2";
break;
default:
Debug.Check(false, "The operator is wrong!");
break;
}
string basicType = DataCppExporter.GetBasicGeneratedNativeType(compute.Opl.NativeType);
stream.WriteLine("{0}\t\t\t{1} opr = ({1})({2});", indent, basicType, oprStr);
if (compute.Opl.IsPar)
{
ParInfo par = compute.Opl.Value as ParInfo;
if (par != null)
{
uint id = Behaviac.Design.CRC32.CalcCRC(par.Name);
stream.WriteLine("{0}\t\t\tBEHAVIAC_ASSERT(behaviac::MakeVariableId(\"{1}\") == {2}u);", indent, par.Name, id);
stream.WriteLine("{0}\t\t\tpAgent->SetVariable(\"{1}\", opr, {2}u);", indent, par.Name, id);
}
}
else
{
string opl = VariableCppExporter.GenerateCode(compute.Opl, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl");
stream.WriteLine("{0}\t\t\t{1} = opr;", indent, opl);
VariableCppExporter.PostGenerateCode(compute.Opl, stream, indent + "\t\t\t", compute.Opl.NativeType, "opl", string.Empty, null, "", "opr");
}
if (compute.Opr1.IsMethod)
{
RightValueCppExporter.PostGenerateCode(compute.Opr1, stream, indent + "\t\t\t", compute.Opr1.NativeType, "opr1", string.Empty);
}
if (compute.Opr2.IsMethod)
{
RightValueCppExporter.PostGenerateCode(compute.Opr2, stream, indent + "\t\t\t", compute.Opr2.NativeType, "opr2", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
private void ExportHead(StreamWriter file, string exportFilename)
{
string wsfolder = Path.GetDirectoryName(Workspace.Current.FileName);
exportFilename = Behaviac.Design.FileManagers.FileManager.MakeRelative(wsfolder, exportFilename);
exportFilename = exportFilename.Replace("\\", "/");
// write comments
file.WriteLine("// ---------------------------------------------------------------------");
file.WriteLine("/* This file is auto-generated, so please don't modify it by yourself!");
file.WriteLine("Usage: include it in a certain cpp accordingly(RELATIVE_PATH is the path where it is generated):\n");
file.WriteLine(" #include \"RELATIVE_PATH/generated_behaviors.cpp\"\n*/\n");
file.WriteLine("// Export file: {0}", exportFilename);
file.WriteLine("// ---------------------------------------------------------------------\r\n");
// write included behaviac files
file.WriteLine("// You should set the include path of the behaviac lib in your project\r\n// for using the following header files :");
file.WriteLine("#include \"behaviac/behaviortree/behaviortree.h\"\r\n");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/action.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/assignment.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/compute.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/noop.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/wait.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/waitforsignal.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/actions/waitframes.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/compositestochastic.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/ifelse.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/parallel.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/query.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/referencebehavior.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/selector.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/selectorloop.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/selectorprobability.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/selectorstochastic.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/sequence.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/sequencestochastic.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/composites/withprecondition.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/and.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/conditionbase.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/condition.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/false.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/or.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/conditions/true.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratoralwaysfailure.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratoralwaysrunning.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratoralwayssuccess.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorcount.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorcountlimit.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorfailureuntil.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorframes.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorlog.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorloop.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorloopuntil.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratornot.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorsuccessuntil.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratortime.h\"");
file.WriteLine("#include \"behaviac/behaviortree/nodes/decorators/decoratorweight.h\"");
file.WriteLine("#include \"behaviac/behaviortree/attachments/event.h\"");
file.WriteLine("#include \"behaviac/behaviortree/attachments/predicate.h\"\r\n");
// write included files for the game agents
if (this.IncludedFilenames != null)
{
file.WriteLine("// You should set the agent header files of your game\r\n// when exporting cpp files in the behaviac editor:");
foreach (string filename in this.IncludedFilenames)
{
file.WriteLine("#include \"{0}\"", filename);
}
file.WriteLine("");
}
// write the namespaces for the game agents
file.WriteLine("using namespace behaviac;\r\n");
// write property and method handlers
file.WriteLine("// Agent property and method handlers\r\n");
foreach (AgentType agenType in Plugin.AgentTypes)
{
List <string> namespaces = new List <string>();
string ns = agenType.Namespace;
if (!string.IsNullOrEmpty(ns))
{
foreach (PropertyDef property in agenType.GetProperties())
{
if (property.ClassName == agenType.AgentTypeName)
{
namespaces = GetNamespaces(ns);
break;
}
}
}
if (namespaces.Count == 0 && !string.IsNullOrEmpty(ns))
{
foreach (MethodDef method in agenType.GetMethods())
{
if (method.ClassName == agenType.AgentTypeName)
{
namespaces = GetNamespaces(ns);
break;
}
}
}
string indent = WriteNamespacesHead(file, namespaces);
foreach (PropertyDef property in agenType.GetProperties())
{
if (property.ClassName == agenType.AgentTypeName)
{
string propName = property.Name.Replace("::", "_");
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(property.NativeType);
file.WriteLine("{0}struct PROPERTY_TYPE_{1} {{ }};", indent, propName);
file.WriteLine("{0}template<> BEHAVIAC_FORCEINLINE {1}& {2}::_Get_Property_<PROPERTY_TYPE_{3}>()", indent, nativeType, agenType.BasicClassName, propName);
file.WriteLine("{0}{{", indent);
if (property.IsStatic)
{
file.WriteLine("{0}\tunsigned char* pc = (unsigned char*)(&{1});", indent, property.Name);
}
else
{
file.WriteLine("{0}\tunsigned char* pc = (unsigned char*)this;", indent);
file.WriteLine("{0}\tpc += (int)offsetof({1}, {2});", indent, property.ClassName, property.Name);
}
file.WriteLine("{0}\treturn *(reinterpret_cast<{1}*>(pc));", indent, nativeType);
file.WriteLine("{0}}}\r\n", indent);
}
}
foreach (MethodDef method in agenType.GetMethods())
{
if (method.ClassName == agenType.AgentTypeName)
{
string paramStrDef = string.Empty;
string paramStr = string.Empty;
for (int i = 0; i < method.Params.Count; ++i)
{
string basicNativeType = DataCppExporter.GetBasicGeneratedNativeType(method.Params[i].NativeType, false);
string refStr = string.Empty;
if (basicNativeType != "char*" && basicNativeType != "char *")
{
if (basicNativeType.EndsWith("*"))
{
refStr = "&";
basicNativeType = basicNativeType.Remove(basicNativeType.Length - 1);
}
basicNativeType = basicNativeType.Trim();
}
if (i > 0)
{
paramStrDef += ", ";
paramStr += ", ";
}
string refConstStr = "&";
if (basicNativeType.EndsWith("&"))
{
refConstStr = string.Empty;
}
paramStrDef += string.Format("{0}{1} p{2}", basicNativeType, refConstStr, i);
paramStr += string.Format("{0}p{1}", refStr, i);
}
string methodName = method.Name.Replace("::", "_");
string nativeReturnType = DataCppExporter.GetGeneratedNativeType(method.NativeReturnType);
file.WriteLine("{0}struct METHOD_TYPE_{1} {{ }};", indent, methodName);
file.WriteLine("{0}template<> BEHAVIAC_FORCEINLINE {1} {2}::_Execute_Method_<METHOD_TYPE_{3}>({4})", indent, nativeReturnType, agenType.BasicClassName, methodName, paramStrDef);
file.WriteLine("{0}{{", indent);
string ret = (method.NativeReturnType == "void") ? string.Empty : "return ";
file.WriteLine("{0}\t{1}this->{2}({3});", indent, ret, method.Name, paramStr);
file.WriteLine("{0}}}\r\n", indent);
}
}
WriteNamespacesTail(file, namespaces);
}
// create namespace
file.WriteLine("namespace behaviac\r\n{");
}
