protected override void GenerateMethod(Node node, StringWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Wait wait = node as Wait;
if (wait == null)
{
return;
}
if (wait.Time != null)
{
string strMethod = "{0}\t\tprotected override " + (Workspace.Current.UseIntValue ? "int GetIntTime(Agent pAgent)" : "double GetTime(Agent pAgent)");
stream.WriteLine(strMethod, indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(node, wait.Time, stream, indent + "\t\t\t", string.Empty, string.Empty, "Time");
if (!wait.Time.IsPublic && (wait.Time.IsMethod || wait.Time.Var != null && wait.Time.Var.IsProperty))
{
retStr = string.Format("Convert.ToDouble({0})", retStr);
}
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateMember(Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMember(attachment, stream, indent);
AttachAction attach = attachment as AttachAction;
if (attach == null)
{
return;
}
RightValueCsExporter.GenerateClassMember(attach.Opl, stream, indent, "opl");
if (!attach.IsAction())
{
if (attach.IsCompute() && attach.Opr1 != null)
{
RightValueCsExporter.GenerateClassMember(attach.Opr1, stream, indent, "opr1");
}
if (attach.Opr2 != null)
{
RightValueCsExporter.GenerateClassMember(attach.Opr2, stream, indent, "opr2");
}
}
}
protected override void GenerateMethod(Node node, StringWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
WaitFrames waitFrames = node as WaitFrames;
if (waitFrames == null)
{
return;
}
if (waitFrames.Frames != null)
{
stream.WriteLine("{0}\t\tprotected override int GetFrames(Agent pAgent)", indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(node, waitFrames.Frames, stream, indent + "\t\t\t", string.Empty, string.Empty, "Frames");
if (!waitFrames.Frames.IsPublic && (waitFrames.Frames.IsMethod || waitFrames.Frames.Var != null && waitFrames.Frames.Var.IsProperty))
{
retStr = string.Format("Convert.ToInt32({0})", retStr);
}
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
Assignment assignment = node as Assignment;
Debug.Check(assignment != null);
if (assignment.Opr != null)
{
RightValueCsExporter.GenerateClassMember(assignment.Opr, stream, indent, "opr");
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
ReferencedBehavior pReferencedBehavior = node as ReferencedBehavior;
if (pReferencedBehavior == null)
{
return;
}
if (pReferencedBehavior.ReferenceBehavior != null)
{
RightValueCsExporter.GenerateClassMember(pReferencedBehavior.ReferenceBehavior, stream, indent, "Behavior");
}
}
protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Wait wait = node as Wait;
if (wait == null)
{
return;
}
if (wait.Time != null)
{
RightValueCsExporter.GenerateClassConstructor(node, wait.Time, stream, indent, "Time");
}
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
WaitFramesState waitFramesState = node as WaitFramesState;
if (waitFramesState == null)
{
return;
}
if (waitFramesState.Frames != null)
{
RightValueCsExporter.GenerateClassConstructor(waitFramesState.Frames, stream, indent, "Frames");
}
}
protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorTime decoratorTime = node as DecoratorTime;
if (decoratorTime == null)
{
return;
}
if (decoratorTime.Time != null)
{
RightValueCsExporter.GenerateClassConstructor(node, decoratorTime.Time, stream, indent, "Time");
}
}
protected override void GenerateMember(Node node, StringWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
WaitFrames waitFrames = node as WaitFrames;
if (waitFrames == null)
{
return;
}
if (waitFrames.Frames != null)
{
RightValueCsExporter.GenerateClassMember(waitFrames.Frames, stream, indent, "Frames");
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
DecoratorTime decoratorTime = node as DecoratorTime;
if (decoratorTime == null)
{
return;
}
if (decoratorTime.Time != null)
{
RightValueCsExporter.GenerateClassMember(decoratorTime.Time, stream, indent, "Time");
}
}
protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Assignment assignment = node as Assignment;
if (assignment == null)
{
return;
}
if (assignment.Opr != null)
{
RightValueCsExporter.GenerateClassConstructor(node, assignment.Opr, stream, indent, "opr");
}
}
protected override void GenerateMember(Node node, StringWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
End end = node as End;
if (end == null)
{
return;
}
if (end.EndStatus != null)
{
RightValueCsExporter.GenerateClassMember(end.EndStatus, stream, indent, "EndStatus");
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
WaitState waitState = node as WaitState;
if (waitState == null)
{
return;
}
if (waitState.Time != null)
{
RightValueCsExporter.GenerateClassMember(waitState.Time, stream, indent, "Time");
}
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
DecoratorFrames decoratorFrames = node as DecoratorFrames;
if (decoratorFrames == null)
{
return;
}
if (decoratorFrames.Frames != null)
{
RightValueCsExporter.GenerateClassConstructor(decoratorFrames.Frames, stream, indent, "Frames");
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
PluginBehaviac.Nodes.Condition condition = node as PluginBehaviac.Nodes.Condition;
Debug.Check(condition != null);
if (condition.Opl != null)
{
RightValueCsExporter.GenerateClassMember(condition.Opl, stream, indent, "opl");
}
if (condition.Opr != null)
{
VariableCsExporter.GenerateClassMember(condition.Opr, stream, indent, "opr");
}
}
protected override void GenerateMember(Node node, StreamWriter stream, string indent)
{
base.GenerateMember(node, stream, indent);
Compute compute = node as Compute;
Debug.Check(compute != null);
if (compute.Opr1 != null)
{
RightValueCsExporter.GenerateClassMember(compute.Opr1, stream, indent, "opr1");
}
if (compute.Opr2 != null)
{
RightValueCsExporter.GenerateClassMember(compute.Opr2, stream, indent, "opr2");
}
}
public static void GenerateOperand(DefaultObject defaultObj, StringWriter stream, string indent, RightValueDef operand, string operandName, string nodeName)
{
if (operand != null)
{
string typeName = DataCsExporter.GetGeneratedNativeType(operand.ValueType);
typeName = typeName.Replace("::", ".");
if (operand.IsMethod) // method
{
RightValueCsExporter.GenerateCode(defaultObj, operand, stream, indent, typeName, operandName, string.Empty);
RightValueCsExporter.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 = PropertyCsExporter.GetProperty(defaultObj, prop, var.ArrayIndexElement, stream, indent, operandName, nodeName);
string propName = prop.BasicName.Replace("[]", "");
if (prop.IsArrayElement && var.ArrayIndexElement != null)
{
ParameterCsExporter.GenerateCode(defaultObj, 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
{
RightValueCsExporter.GenerateCode(defaultObj, operand, stream, indent, typeName, operandName, string.Empty);
}
}
}
}
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Assignment assignment = node as Assignment;
Debug.Check(assignment != null);
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
if (assignment.Opl != null && assignment.Opr != null)
{
if (assignment.Opl.IsPar)
{
ParInfo par = assignment.Opl.Value as ParInfo;
if (par != null)
{
RightValueCsExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", "opr");
uint id = Behaviac.Design.CRC32.CalcCRC(par.Name);
string typename = DataCsExporter.GetGeneratedNativeType(par.NativeType);
stream.WriteLine("{0}\t\t\tDebug.Check(behaviac.Utils.MakeVariableId(\"{1}\") == {2}u);", indent, par.Name, id);
stream.WriteLine("{0}\t\t\tpAgent.SetVariable<{1}>(\"{2}\", opr, {3}u);", indent, typename, par.Name, id);
}
}
else
{
Debug.Check(assignment.Opl.IsProperty);
RightValueCsExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", "opr");
//VariableCsExporter.GenerateCode(assignment.Opl, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl", "opr");
VariableCsExporter.PostGenerateCode(assignment.Opl, stream, indent + "\t\t\t", assignment.Opl.NativeType.Replace("::", "."), "opl", string.Empty, null, "", "opr");
}
if (assignment.Opr.IsMethod)
{
RightValueCsExporter.PostGenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "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);
WaitFrames waitFrames = node as WaitFrames;
Debug.Check(waitFrames != null);
if (waitFrames.Frames != null)
{
stream.WriteLine("{0}\t\tprotected override int GetFrames(Agent pAgent)", indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(waitFrames.Frames, stream, indent + "\t\t\t", string.Empty, string.Empty, string.Empty);
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
End end = node as End;
if (end == null)
{
return;
}
if (end.EndStatus != null)
{
RightValueCsExporter.GenerateClassConstructor(node, end.EndStatus, stream, indent, "EndStatus");
}
if (end.EndOutside)
{
stream.WriteLine("{0}\t\t\tm_endOutside = true;", indent);
}
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
PluginBehaviac.Nodes.Condition condition = node as PluginBehaviac.Nodes.Condition;
if (condition == null)
{
return;
}
if (condition.Opl != null)
{
RightValueCsExporter.GenerateClassConstructor(condition.Opl, stream, indent, "opl");
}
if (condition.Opr != null)
{
RightValueCsExporter.GenerateClassConstructor(condition.Opr, stream, indent, "opr");
}
}
protected override void GenerateMethod(Node node, StringWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
ReferencedBehavior pReferencedBehavior = node as ReferencedBehavior;
if (pReferencedBehavior == null)
{
return;
}
if (pReferencedBehavior.ReferenceBehavior != null)
{
stream.WriteLine("{0}\t\tpublic override string GetReferencedTree(Agent pAgent)", indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(node, pReferencedBehavior.ReferenceBehavior, stream, indent + "\t\t\t", string.Empty, string.Empty, "Behavior");
bool bConst = false;
if (pReferencedBehavior.ReferenceBehavior.Var != null && pReferencedBehavior.ReferenceBehavior.Var.IsConst)
{
bConst = true;
}
if (!bConst)
{
stream.WriteLine("{0}\t\t\tif (pAgent != null) {{", 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 null;", indent);
}
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateMember(Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMember(attachment, stream, indent);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
if (transition.Opl != null)
{
RightValueCsExporter.GenerateClassMember(transition.Opl, stream, indent, "opl");
}
if (transition.Opr2 != null)
{
RightValueCsExporter.GenerateClassMember(transition.Opr2, stream, indent, "opr2");
}
}
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(node, stream, indent, className);
Compute compute = node as Compute;
if (compute == null)
{
return;
}
if (compute.Opr1 != null)
{
RightValueCsExporter.GenerateClassConstructor(compute.Opr1, stream, indent, "opr1");
}
if (compute.Opr2 != null)
{
RightValueCsExporter.GenerateClassConstructor(compute.Opr2, stream, indent, "opr2");
}
}
protected override void GenerateMethod(Node node, StringWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
End end = node as End;
if (end == null)
{
return;
}
if (end.EndStatus != null)
{
stream.WriteLine("{0}\t\tprotected override EBTStatus GetStatus(Agent pAgent)", indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(node, end.EndStatus, stream, indent + "\t\t\t", string.Empty, string.Empty, "EndStatus");
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Wait wait = node as Wait;
if (wait == null)
{
return;
}
if (wait.Time != null)
{
stream.WriteLine("{0}\t\tprotected override double GetTime(Agent pAgent)", indent);
stream.WriteLine("{0}\t\t{{", indent);
string retStr = RightValueCsExporter.GenerateCode(wait.Time, stream, indent + "\t\t\t", string.Empty, string.Empty, "Time");
stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr);
stream.WriteLine("{0}\t\t}}", indent);
}
}
protected override void GenerateConstructor(Attachment attachment, StreamWriter stream, string indent, string className)
{
base.GenerateConstructor(attachment, stream, indent, className);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
stream.WriteLine("{0}\t\t\tthis.TargetStateId = {1};", indent, transition.TargetFSMNodeId);
if (transition.Opl != null)
{
RightValueCsExporter.GenerateClassConstructor(attachment, transition.Opl, stream, indent, "opl");
}
if (transition.Opr2 != null)
{
RightValueCsExporter.GenerateClassConstructor(attachment, transition.Opr2, stream, indent, "opr2");
}
}
protected override void GenerateMethod(Behaviac.Design.Attachments.Attachment attachment, StreamWriter stream, string indent)
{
base.GenerateMethod(attachment, stream, indent);
TransitionCondition transition = attachment as TransitionCondition;
if (transition == null)
{
return;
}
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
{
string typeName = Plugin.GetNativeTypeName(transition.Opl.ValueType);
typeName = typeName.Replace("::", ".");
RightValueCsExporter.GenerateCode(attachment, transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
RightValueCsExporter.GenerateCode(attachment, transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
if (transition.Opl != null && transition.Opl.IsMethod)
{
RightValueCsExporter.PostGenerateCode(transition.Opl, stream, indent + "\t\t\t", typeName, "opl", "");
}
if (transition.Opr2 != null && transition.Opr2.IsMethod)
{
RightValueCsExporter.PostGenerateCode(transition.Opr2, stream, indent + "\t\t\t", typeName, "opr2", "");
}
switch (transition.Operator)
{
case OperatorTypes.Equal:
stream.WriteLine("{0}\t\t\tbool op = (opl == opr2);", indent);
break;
case OperatorTypes.NotEqual:
stream.WriteLine("{0}\t\t\tbool op = (opl != opr2);", indent);
break;
case OperatorTypes.Greater:
stream.WriteLine("{0}\t\t\tbool op = (opl > opr2);", indent);
break;
case OperatorTypes.GreaterEqual:
stream.WriteLine("{0}\t\t\tbool op = (opl >= opr2);", indent);
break;
case OperatorTypes.Less:
stream.WriteLine("{0}\t\t\tbool op = (opl < opr2);", indent);
break;
case OperatorTypes.LessEqual:
stream.WriteLine("{0}\t\t\tbool op = (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 = EBTStatus.BT_FAILURE;", indent);
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);
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(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", "opr");
string property = PropertyCppExporter.GetProperty(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(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(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);
stream.WriteLine("{0}\t\t\tBEHAVIAC_ASSERT(behaviac::MakeVariableId(\"{1}\") == {2}u);", indent, propBasicName, id);
stream.WriteLine("{0}\t\t\tpAgent->SetVariable(\"{1}\", {2}, {3}u);", indent, propBasicName, opr, id);
}
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, StringWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Assignment assignment = node as Assignment;
if (assignment == null)
{
return;
}
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
if (assignment.Opl != null && assignment.Opr != null)
{
PropertyDef prop = assignment.Opl.Property;
if (prop != null)
{
RightValueCsExporter.GenerateCode(node, assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", "opr");
string property = PropertyCsExporter.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)
{
ParameterCsExporter.GenerateCode(node, assignment.Opl.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opl_index", "assignment_opl");
property = string.Format("({0})[opl_index]", property);
}
string oprStr = "opr";
if (!Plugin.IsArrayType(prop.Type))
{
if (assignment.Opr.Var != null && assignment.Opr.Var.ArrayIndexElement != null)
{
ParameterCsExporter.GenerateCode(node, assignment.Opr.Var.ArrayIndexElement, stream, indent + "\t\t\t", "int", "opr_index", "assignment_opr");
oprStr = string.Format("({0})[opr_index]", oprStr);
}
}
if (!prop.IsArrayElement && (!prop.IsPublic || prop.IsPar || prop.IsCustomized))
{
string propBasicName = prop.BasicName.Replace("[]", "");
uint id = Behaviac.Design.CRC32.CalcCRC(propBasicName);
string agentName = PropertyCsExporter.GetGenerateAgentName(prop, "opl", "assignment");
string typename = DataCsExporter.GetGeneratedNativeType(prop.NativeType);
stream.WriteLine("{0}\t\t\t{1}.SetVariable<{2}>(\"{3}\", {4}u, {5});", indent, agentName, typename, propBasicName, id, oprStr);
}
else
{
if (assignment.IsCasting)
{
stream.WriteLine("{0}\t\t\t{1} = ({2}){3};", indent, property, DataCsExporter.GetGeneratedNativeType(assignment.Opl.ValueType), oprStr);
}
else
{
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, property, oprStr);
}
}
}
if (assignment.Opr.IsMethod)
{
RightValueCsExporter.PostGenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
