// Token: 0x060041D2 RID: 16850 RVA: 0x0014E7E0 File Offset: 0x0014CBE0
public void Inverse()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
CSG.CSG csg = new CSG.CSG();
csg.Construct(this.A.GetComponent <MeshFilter>().sharedMesh, this.A.transform, 0);
CSG.CSG csg2 = csg.Inverse();
Mesh sharedMesh = csg2.ToMesh();
this.Result = new GameObject("Inverse");
DefaultObject defaultObject = this.Result.AddComponent <DefaultObject>();
MeshFilter meshFilter = this.Result.AddComponent <MeshFilter>();
meshFilter.sharedMesh = sharedMesh;
MeshRenderer meshRenderer = this.Result.AddComponent <MeshRenderer>();
meshRenderer.sharedMaterial = new Material(this.A.GetComponent <MeshRenderer>().sharedMaterial);
if (this.DeleteOriginal)
{
UnityEngine.Object.DestroyImmediate(this.A);
}
stopwatch.Stop();
defaultObject.GenerationTimeMS = (float)stopwatch.ElapsedMilliseconds;
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type.GetGenericTypeDefinition() != typeof(List <>))
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
Type itemType = type.GetGenericArguments()[0];
if (!itemType.IsEnum)
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
System.Collections.IList enumArray = (System.Collections.IList)Plugin.CreateInstance(type);
if (!string.IsNullOrEmpty(str))
{
int index = str.IndexOf(':');
if (index >= 0)
{
str = str.Substring(index + 1);
}
string[] tokens = str.Split('|');
foreach (string s in tokens)
{
enumArray.Add(Enum.Parse(itemType, s, true));
}
}
return(enumArray);
}
public static string GetProperty(DefaultObject defaultObj, Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement, StreamWriter stream, string indent, string var, string caller)
{
string agentName = GetGenerateAgentName(property, var, caller);
if (property.Owner != Behaviac.Design.VariableDef.kSelf)
{
bool isGlobal = Plugin.IsInstanceName(property.Owner, null);
PropertyDef ownerProperty = null;
if (!isGlobal)
{
Debug.Check(defaultObj != null && defaultObj.Behavior != null && defaultObj.Behavior.AgentType != null);
ownerProperty = defaultObj.Behavior.AgentType.GetPropertyByName(property.Owner);
}
if (isGlobal || ownerProperty == null || ownerProperty.IsCustomized) // global or customized instance
{
stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(pAgent, \"{2}\");", indent, agentName, property.Owner);
}
else // member instance
{
string propName = ownerProperty.Name.Replace("::", "_");
string nativeType = DataCppExporter.GetGeneratedNativeType(ownerProperty.NativeType);
string prop = string.Format("(({0}*)pAgent)->_Get_Property_<{1}PROPERTY_TYPE_{2}, {3} >()", ownerProperty.ClassName, getNamespace(ownerProperty.ClassName), propName, nativeType);
stream.WriteLine("{0}Agent* {1} = {2};", indent, agentName, prop);
}
stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
}
return(getProperty(property, arrayIndexElement, agentName, stream, indent));
}
public static void GenerateClassConstructor(DefaultObject defaultObj, Behaviac.Design.VariableDef variable, StreamWriter stream, string indent, string var)
{
if (variable.ValueClass == Behaviac.Design.VariableDef.kConst)
{
Type type = variable.Value.GetType();
if (Plugin.IsRefType(type))
{
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(variable.NativeType);
stream.WriteLine("{0}\t\t\t{1} = NULL;", indent, var);
}
else if (Plugin.IsArrayType(type) || Plugin.IsCustomClassType(type) || (Plugin.IsStringType(type) && !variable.IsConst))
{
if (Plugin.IsArrayType(type))
{
string nativeType = DataCppExporter.GetGeneratedNativeType(variable.NativeType);
int startIndex = nativeType.IndexOf('<');
int endIndex = nativeType.LastIndexOf('>');
string itemType = nativeType.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(variable.Value, defaultObj, stream, indent + "\t\t\t", itemType, var);
}
else if (Plugin.IsCustomClassType(type))
{
StructCppExporter.GenerateCode(variable.Value, defaultObj, stream, indent + "\t\t\t", var, null, "");
}
else if ((Plugin.IsStringType(type) && !variable.IsConst))
{
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(variable.NativeType);
string retStr = DataCppExporter.GenerateCode(variable.Value, defaultObj, stream, indent + "\t\t\t", nativeType, string.Empty, string.Empty);
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, var, retStr);
}
}
}
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
foreach (Plugin.InstanceName_t t in Plugin.InstanceNames)
{
if (str == t.AgentType.Name
#if BEHAVIAC_NAMESPACE_FIX
|| t.AgentType.Name.EndsWith(str)
#endif
)
{
return(t.AgentType);
}
}
foreach (AgentType t in Plugin.AgentTypes)
{
if (str == t.Name || str == t.OldName
#if BEHAVIAC_NAMESPACE_FIX
|| t.Name.EndsWith(str) || t.OldName.EndsWith(str)
#endif
)
{
return(t);
}
}
return(null);
}
public static string GenerateCode(DefaultObject defaultObj, PropertyDef property, MethodDef.Param arrayIndexElement, bool isRefParam, StringWriter stream, string indent, string typename, string var, string caller, string setValue = null)
{
if (property.IsPar || property.IsCustomized)
{
return(ParInfoCsExporter.GenerateCode(property, isRefParam, stream, indent, typename, var, caller));
}
string agentName = GetGenerateAgentName(property, var, caller);
string prop = GetProperty(defaultObj, property, arrayIndexElement, stream, indent, var, caller);
if (setValue == null)
{
if (!string.IsNullOrEmpty(var))
{
if (string.IsNullOrEmpty(typename))
{
stream.WriteLine("{0}{1} = {2};", indent, var, prop);
}
else
{
string nativeType = DataCsExporter.GetPropertyNativeType(property, arrayIndexElement);
stream.WriteLine("{0}{1} {2} = {3};", indent, nativeType, var, prop);
}
}
}
else
{
string propBasicName = property.BasicName.Replace("[]", "");
stream.WriteLine("{0}AgentMetaVisitor.SetProperty({1}, \"{2}\", {3});", indent, agentName, propBasicName, setValue);
}
return(prop);
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type.GetGenericTypeDefinition() != typeof(List<>))
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
Type itemType = type.GetGenericArguments()[0];
if (!itemType.IsEnum)
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
System.Collections.IList enumArray = (System.Collections.IList)Plugin.CreateInstance(type);
if (!string.IsNullOrEmpty(str)) {
int index = str.IndexOf(':');
if (index >= 0)
{ str = str.Substring(index + 1); }
string[] tokens = str.Split('|');
foreach(string s in tokens) {
enumArray.Add(Enum.Parse(itemType, s, true));
}
}
return enumArray;
}
public static string GenerateCode(DefaultObject defaultObj, Behaviac.Design.VariableDef variable, bool isRefParam, StreamWriter stream, string indent, string typename, string var, string caller)
{
string retStr = string.Empty;
if (variable.ValueClass == Behaviac.Design.VariableDef.kConst)
{
bool shouldGenerate = true;
Type type = variable.Value.GetType();
if (Plugin.IsArrayType(type) || Plugin.IsCustomClassType(type) || (Plugin.IsStringType(type) && !variable.IsConst))
{
shouldGenerate = false;
}
if (shouldGenerate)
{
retStr = DataCppExporter.GenerateCode(variable.Value, defaultObj, stream, indent, typename, var, caller);
}
}
else if (variable.Property != null)
{
retStr = PropertyCppExporter.GenerateCode(defaultObj, variable.Property, variable.ArrayIndexElement, isRefParam, stream, indent, typename, var, caller);
}
return(retStr);
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (Plugin.IsCustomClassType(type))
{ return ParseStringValue(result, type, null, str, node); }
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
/// <summary>
/// Used to replace the default object with a behaviour once loaded.
/// </summary>
/// <param name="behavior">The behaviour we have loaded.</param>
public void AssignLoadedBehavior(BehaviorNode behavior)
{
Debug.Check(_type == NodeTagType.Behavior);
Debug.Check(_filename == behavior.FileManager.Filename);
_defaults = (DefaultObject)behavior;
}
public new static object ParseStringValue(List<Nodes.Node.ErrorCheck> result, Type type, string str, DefaultObject node)
{
Debug.Check(type != null && Plugin.IsArrayType(type));
object obj = Plugin.CreateInstance(type);
Debug.Check(obj != null);
if (!string.IsNullOrEmpty(str)) {
System.Collections.IList list = (System.Collections.IList)obj;
Type itemType = type.GetGenericArguments()[0];
int index = str.IndexOf(':');
if (index >= 0)
{ str = str.Substring(index + 1); }
if (!string.IsNullOrEmpty(str)) {
System.Collections.IList structArray = (System.Collections.IList)Plugin.CreateInstance(type);
parseStringValue(result, node, structArray, itemType, str, 0, str.Length - 1);
return structArray;
}
}
return obj;
}
/// <summary>
/// Creates a new NodeTag and an instance of the node for the defaults.
/// </summary>
/// <param name="type">The type of the node in the node explorer.</param>
/// <param name="nodetype">The type of the node which will be added to the behaviour tree.</param>
/// <param name="filename">The filename of the behaviour we want to load. Use string.Empty if the node is not a behaviour.</param>
public NodeTag(NodeTagType type, Type nodetype, string filename)
{
if ((type == NodeTagType.BehaviorFolder || type == NodeTagType.NodeFolder) && nodetype != null)
{
throw new Exception(Resources.ExceptionWrongNodeTagType);
}
_type = type;
_nodetype = nodetype;
_filename = filename;
if (nodetype == null)
{
_defaults = null;
}
else
{
//if(!nodetype.IsSubclassOf(typeof(DefaultObject)))
// throw new Exception(Resources.ExceptionNotImplementDefaultObject);
if (nodetype.IsSubclassOf(typeof(Events.Event)) && type != NodeTagType.Event)
{
throw new Exception(Resources.ExceptionWrongNodeTagType);
}
if (nodetype.IsSubclassOf(typeof(Nodes.Node)) && type != NodeTagType.Node && type != NodeTagType.Behavior)
{
throw new Exception(Resources.ExceptionWrongNodeTagType);
}
_defaults = type == NodeTagType.Event ? (DefaultObject)Brainiac.Design.Events.Event.Create(nodetype, null) : (DefaultObject)Nodes.Node.Create(nodetype);
}
}
public static void GenerateCode(object obj, DefaultObject defaultObj, StringWriter stream, string indent, string itemTypename, string var)
{
if (obj != null)
{
Type type = obj.GetType();
if (Plugin.IsArrayType(type))
{
System.Collections.IList list = (System.Collections.IList)obj;
if (list.Count > 0)
{
stream.WriteLine("{0}{1}.reserve({2});", indent, var, list.Count);
for (int i = 0; i < list.Count; ++i)
{
string itemName = string.Format("{0}_item{1}", var.Replace(".", "_"), i);
DataCppExporter.GenerateCode(list[i], defaultObj, stream, indent, itemTypename, itemName, string.Empty);
stream.WriteLine("{0}{1}.push_back({2});", indent, var, itemName);
}
}
}
}
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(float) && type != typeof(double))
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
if (type == typeof(float))
{
float resultValue;
if (float.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out resultValue))
{
return(resultValue);
}
}
else if (type == typeof(double))
{
double resultValue;
if (double.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out resultValue))
{
return(resultValue);
}
}
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalFloatValue, str));
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(RightValueDef))
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
if (str.Length == 0 ||
str.Length == 2 && str == "\"\"")
{
return(null);
}
if (!str.StartsWith("const"))
{
int pos = str.IndexOf('(');
if (pos < 0)
{
VariableDef var = DesignerPropertyEnum.parsePropertyVar(result, node, str);
return(new RightValueDef(var));
}
else
{
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
AgentType agentType = (behavior != null) ? behavior.AgentType : null;
string valueClass = VariableDef.kSelfMethod;
MethodDef method = DesignerMethodEnum.parseMethodString(result, node, agentType, this.MethodType, str);
if (method == null)
{
string className = Plugin.GetClassName(str);
method = DesignerMethodEnum.parseMethodString(result, node, Plugin.GetInstanceAgentType(className, behavior, null), this.MethodType, str);
valueClass = className + VariableDef.kMethod;
}
string instanceName = Plugin.GetInstanceName(str);
if (!string.IsNullOrEmpty(instanceName))
{
valueClass = instanceName + VariableDef.kMethod;
}
return(new RightValueDef(method, valueClass));
}
}
else
{
VariableDef var = this.parseConstVar(result, node, parentObject, str);
if (var != null)
{
return(new RightValueDef(var));
}
}
return(null);
}
public static void GenerateCode(object obj, DefaultObject defaultObj, StreamWriter stream, string indent, string var, object parent, string paramName)
{
Debug.Check(obj != null);
Type type = obj.GetType();
Debug.Check(Plugin.IsCustomClassType(type));
MethodDef method = parent as MethodDef;
IList <DesignerPropertyInfo> properties = DesignerProperty.GetDesignerProperties(type);
foreach (DesignerPropertyInfo property in properties)
{
if (!property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
object member = property.GetValue(obj);
Type memberType = member.GetType();
if (Plugin.IsArrayType(memberType))
{
string memberNativeType = Plugin.GetNativeTypeName(memberType);
string nativeTypeStr = DataCppExporter.GetGeneratedNativeType(memberNativeType);
int startIndex = nativeTypeStr.IndexOf('<');
int endIndex = nativeTypeStr.LastIndexOf('>');
string itemType = nativeTypeStr.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(member, defaultObj, stream, indent, itemType, var + "." + property.Property.Name);
}
else
{
if (property.Attribute is DesignerStruct)
{
GenerateCode(member, defaultObj, stream, indent, var + "." + property.Property.Name, parent, paramName);
}
else
{
bool bStructProperty = false;
if (method != null)
{
MethodDef.Param param = method.GetParam(paramName, property);
if (param != null)
{
bStructProperty = true;
ParameterCppExporter.GenerateCode(defaultObj, param, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
if (!bStructProperty)
{
DataCppExporter.GenerateCode(member, defaultObj, stream, indent, string.Empty, var + "." + property.Property.Name, string.Empty);
}
}
}
}
}
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (Plugin.IsCustomClassType(type))
{
return(ParseStringValue(result, type, null, str, node));
}
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
public override bool AcceptsAttachment(DefaultObject obj)
{
Type type = (obj != null) ? obj.GetType() : null;
return(type != null && ((this.IsFSM && Plugin.IsClassDerived(type, typeof(Behaviac.Design.Attachments.AttachAction))) || //if fsm, only accept effectors
(!Plugin.IsClassDerived(type, typeof(Behaviac.Design.Attachments.AttachAction)) &&
!Plugin.IsClassDerived(type, typeof(Behaviac.Design.Attachments.Event)) &&
!Plugin.IsClassDerived(type, typeof(Behaviac.Design.Nodes.Behavior)))));
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(string))
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
return(str);
}
public static void GenerateClassConstructor(DefaultObject defaultObj, RightValueDef rightValue, StringWriter stream, string indent, string var)
{
if (rightValue.IsMethod)
{
MethodCsExporter.GenerateClassConstructor(defaultObj, rightValue.Method, stream, indent, var);
}
else
{
VariableCsExporter.GenerateClassConstructor(defaultObj, rightValue.Var, stream, indent, var);
}
}
public static string GetProperty(DefaultObject defaultObj, Behaviac.Design.PropertyDef property, MethodDef.Param arrayIndexElement, StringWriter stream, string indent, string var, string caller)
{
string agentName = GetGenerateAgentName(property, var, caller);
if (property.Owner != Behaviac.Design.VariableDef.kSelf)
{
string instanceName = property.Owner.Replace("::", ".");
bool isGlobal = Plugin.IsInstanceName(instanceName, null);
PropertyDef ownerProperty = null;
if (!isGlobal)
{
Debug.Check(defaultObj != null && defaultObj.Behavior != null && defaultObj.Behavior.AgentType != null);
if (defaultObj != null && defaultObj.Behavior != null)
{
ownerProperty = defaultObj.Behavior.AgentType.GetPropertyByName(instanceName);
}
}
if (isGlobal || ownerProperty == null || ownerProperty.IsCustomized || ownerProperty.IsPar) // global or customized instance
{
stream.WriteLine("{0}behaviac.Agent {1} = behaviac.Utils.GetParentAgent(pAgent, \"{2}\");", indent, agentName, instanceName);
}
else // member instance
{
string prop = "";
if (ownerProperty.IsPublic)
{
string className = ownerProperty.ClassName.Replace("::", ".");
if (ownerProperty.IsStatic)
{
prop = string.Format("{0}.{1}", className, instanceName);
}
else
{
prop = string.Format("(({0})pAgent).{1}", className, instanceName);
}
}
else
{
string nativeType = DataCsExporter.GetGeneratedNativeType(ownerProperty.NativeType);
prop = string.Format("({0})AgentMetaVisitor.GetProperty(pAgent, \"{1}\")", nativeType, instanceName);
}
stream.WriteLine("{0}behaviac.Agent {1} = {2};", indent, agentName, prop);
}
//stream.WriteLine("{0}Debug.Check(!System.Object.ReferenceEquals({1}, null) || Utils.IsStaticClass(\"{2}\"));", indent, agentName, instanceName);
}
return(getProperty(property, arrayIndexElement, agentName, stream, indent));
}
public static VariableDef setParameter(List <Nodes.Node.ErrorCheck> result, DefaultObject node, string propertyName)
{
Behaviac.Design.Nodes.Behavior behavior = node.Behavior as Behaviac.Design.Nodes.Behavior;
// Convert the Par to the Property
if (!propertyName.Contains(".") && !propertyName.Contains(":"))
{
propertyName = "Self." + behavior.AgentType.AgentTypeName + "::" + propertyName;
}
VariableDef var = null;
string instance = Plugin.GetInstanceName(propertyName);
if (!string.IsNullOrEmpty(instance))
{
propertyName = propertyName.Substring(instance.Length + 1, propertyName.Length - instance.Length - 1);
var = createVariable(result, node, behavior.AgentType, instance, propertyName);
if (var != null)
{
return(var);
}
}
// Try to find the Agent property with the name.
if (behavior != null && behavior.AgentType != null)
{
instance = "Self";
var = createVariable(result, node, behavior.AgentType, instance, propertyName);
if (var != null)
{
return(var);
}
}
// Try to find the global property with the name.
string instacneName = Plugin.GetClassName(propertyName);
if (!string.IsNullOrEmpty(instacneName) && Plugin.GetInstanceAgentType(instacneName) != null)
{
var = createVariable(result, node, behavior.AgentType, instacneName, propertyName);
if (var != null)
{
return(var);
}
}
return(null);
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (!Plugin.IsIntergerNumberType(type))
{
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
int resultValue = 0;
if (int.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out resultValue))
{
if (type == typeof(uint))
{
return((uint)resultValue);
}
if (type == typeof(short))
{
return((short)resultValue);
}
if (type == typeof(ushort))
{
return((ushort)resultValue);
}
if (type == typeof(sbyte))
{
return((sbyte)resultValue);
}
if (type == typeof(byte))
{
return((byte)resultValue);
}
if (type == typeof(long))
{
return((long)resultValue);
}
if (type == typeof(ulong))
{
return((ulong)resultValue);
}
return(resultValue);
}
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalIntegerValue, str));
}
public static bool parseParam(List <Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
{
string propName = null;
if (param[0] == '\"')
{
param = param.Substring(1, param.Length - 2);
}
else if (param[0] == '{') //struct
{
//to set it as action.Method is used in the following parsing
Nodes.Action action = node as Nodes.Action;
if (action != null && action.Method == null)
{
action.Method = method;
}
}
else
{
string noStaticParam = param.Replace("static ", "");
int index = noStaticParam.IndexOf(" ");
if (index >= 0)
{
propName = noStaticParam.Substring(index + 1);
}
}
bool bOk = false;
if (propName != null)
{
VariableDef var = setParameter(result, node, propName);
if (var != null)
{
par.Value = var;
bOk = true;
}
}
else
{
bOk = Plugin.InvokeTypeParser(result, par.Type, param,
(object value) => par.Value = value,
node, par.Name);
}
return(bOk);
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(RightValueDef))
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
if (str.Length == 0 ||
str.Length == 2 && str == "\"\"") {
return null;
}
if (!str.StartsWith("const")) {
int pos = str.IndexOf('(');
if (pos < 0) {
VariableDef var = DesignerPropertyEnum.parsePropertyVar(result, node, str);
return new RightValueDef(var);
} else {
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
AgentType agentType = (behavior != null) ? behavior.AgentType : null;
string valueClass = VariableDef.kSelfMethod;
MethodDef method = DesignerMethodEnum.parseMethodString(result, node, agentType, this.MethodType, str);
if (method == null) {
string className = Plugin.GetClassName(str);
method = DesignerMethodEnum.parseMethodString(result, node, Plugin.GetInstanceAgentType(className, behavior, null), this.MethodType, str);
valueClass = className + VariableDef.kMethod;
}
string instanceName = Plugin.GetInstanceName(str);
if (!string.IsNullOrEmpty(instanceName)) {
valueClass = instanceName + VariableDef.kMethod;
}
return new RightValueDef(method, valueClass);
}
} else {
VariableDef var = this.parseConstVar(result, node, parentObject, str);
if (var != null) {
return new RightValueDef(var);
}
}
return null;
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(bool))
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
str = str.ToLowerInvariant();
if (str == "true")
{ return true; }
if (str == "false")
{ return false; }
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalBooleanValue, str));
}
public static string GenerateCode(DefaultObject defaultObj, RightValueDef rightValue, StringWriter stream, string indent, string typename, string var, string caller)
{
string retStr = string.Empty;
if (rightValue.IsMethod)
{
retStr = MethodCsExporter.GenerateCode(defaultObj, rightValue.Method, stream, indent, rightValue.Method.NativeReturnType, var, caller);
}
else
{
retStr = VariableCsExporter.GenerateCode(defaultObj, rightValue.Var, false, stream, indent, typename, var, caller);
}
return(retStr);
}
private static void parseStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, System.Collections.IList structArray, Type itemType, string str, int startIndex, int endIndex)
{
string propertyName = string.Empty;
string propertyValue = string.Empty;
int nextIndex = getItemStr(str, startIndex, endIndex, out propertyName, out propertyValue);
if (nextIndex > 0)
{
object item = DesignerStruct.ParseStringValue(result, itemType, null, propertyValue, node);
structArray.Add(item);
parseStringValue(result, node, structArray, itemType, str, nextIndex, endIndex);
}
}
public static string GenerateCode(DefaultObject defaultObj, Behaviac.Design.MethodDef.Param param, StreamWriter stream, string indent, string typename, string var, string caller)
{
Behaviac.Design.ParInfo par = param.Value as Behaviac.Design.ParInfo;
if (par != null)
{
return(ParInfoCppExporter.GenerateCode(par, param.IsRef, stream, indent, typename, var, caller));
}
Behaviac.Design.VariableDef v = param.Value as Behaviac.Design.VariableDef;
if (v != null)
{
return(VariableCppExporter.GenerateCode(defaultObj, v, param.IsRef, stream, indent, typename, var, caller));
}
return(DataCppExporter.GenerateCode(param.Value, defaultObj, stream, indent, typename, var, caller));
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (!type.IsEnum)
{
//throw new Exception(string.Format(Resources.ExceptionDesignerAttributeExpectedEnum, type));
Debug.Check(false);
return(null);
}
string[] parts = str.Split(':');
if (parts.Length != 2)
{
// keep compatibility with version 1
//throw new Exception( string.Format(Resources.ExceptionDesignerAttributeEnumCouldNotReadValue, str) );
parts = new string[] { str, "-1" };
}
string enumname = parts[0];
int enumval;
try
{
// try to get the enum value by name
enumval = (int)Enum.Parse(type, enumname, true);
}
catch
{
// try to read the stored enum value index
if (!int.TryParse(parts[1], NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out enumval))
{
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeEnumCouldNotParseValue, str));
}
// try to get the enum value by index
if (Enum.ToObject(type, enumval) == null)
{
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeEnumIllegalEnumIndex, enumval));
}
enumval = (int)Plugin.DefaultValue(type);
}
return(enumval);
}
public static bool parseParam(List <Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
{
string[] tokens = null;
if (param[0] == '\"')
{
param = param.Substring(1, param.Length - 2);
}
else if (param[0] == '{')
{
//struct
//to set it as action.Method is used in the following parsing
Nodes.Action action = node as Nodes.Action;
if (action != null)
{
action.Method = method;
}
}
else
{
tokens = param.Split(' ');
}
bool bOk = false;
if (tokens != null && tokens.Length > 1)
{
//par
VariableDef var = setParameter(result, node, tokens[tokens.Length - 1]);
if (var != null)
{
par.Value = var;
bOk = true;
}
}
else
{
bOk = Plugin.InvokeTypeParser(result, par.Type, param, (object value) => par.Value = value, node, par.Name);
}
return(bOk);
}
public static void GenerateClassConstructor(DefaultObject defaultObj, Behaviac.Design.MethodDef method, StringWriter stream, string indent, string var)
{
for (int i = 0; i < method.Params.Count; ++i)
{
// const value
if (!method.Params[i].IsProperty && !method.Params[i].IsLocalVar)
{
object obj = method.Params[i].Value;
if (obj != null)
{
string param = var + "_p" + i;
Type type = obj.GetType();
if (Plugin.IsArrayType(type))
{
string nativeType = DataCppExporter.GetGeneratedNativeType(method.Params[i].NativeType);
int startIndex = nativeType.IndexOf('<');
int endIndex = nativeType.LastIndexOf('>');
string itemType = nativeType.Substring(startIndex + 1, endIndex - startIndex - 1);
ArrayCppExporter.GenerateCode(obj, defaultObj, stream, indent + "\t\t\t", itemType, param);
}
else if (Plugin.IsCustomClassType(type))
{
if (Plugin.IsRefType(type))
{
stream.WriteLine("{0}\t\t\t{1} = NULL;", indent, param);
}
else if (DesignerStruct.IsPureConstDatum(obj, method, method.Params[i].Name))
{
StructCppExporter.GenerateCode(obj, defaultObj, stream, indent + "\t\t\t", param, null, "");
}
}
else
{
string nativeType = DataCppExporter.GetBasicGeneratedNativeType(method.Params[i].NativeType);
string retStr = DataCppExporter.GenerateCode(obj, defaultObj, stream, string.Empty, nativeType, string.Empty, string.Empty);
stream.WriteLine("{0}\t\t\t{1} = {2};", indent, param, retStr);
}
}
}
}
}
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);
}
}
}
}
}
public void ResetId()
{
bool bReset = (this.Id < 0);
if (!bReset)
{
DefaultObject obj = Plugin.GetObjectById((Nodes.Node)Node.Behavior, this.Id);
if (obj != null && obj != this)
{
bReset = true;
}
}
if (bReset)
{
this.Id = Plugin.NewNodeId((Nodes.Node)Node.Behavior);
}
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(MethodDef))
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
if (behavior != null && behavior.AgentType != null) {
MethodDef method = parseMethodString(result, node, behavior.AgentType, this.MethodType, str);
if (method == null) {
string className = Plugin.GetClassName(str);
method = parseMethodString(result, node, Plugin.GetInstanceAgentType(className, behavior, null), this.MethodType, str);
}
return method;
}
return null;
}
public override object FromStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type == typeof(string))
{
return(trimQuotes(str));
}
else if (Plugin.IsCharType(type))
{
if (str.Length >= 1)
{
char r = str[0];
return(r);
}
//return "";
return('A');
}
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
foreach(Plugin.InstanceName_t t in Plugin.InstanceNames) {
if (str == t.agentType_.AgentTypeName
#if BEHAVIAC_NAMESPACE_FIX
|| t.agentType_.AgentTypeName.EndsWith(str)
#endif
) {
return t.agentType_;
}
}
foreach(AgentType t in Plugin.AgentTypes) {
if (str == t.ToString()
#if BEHAVIAC_NAMESPACE_FIX
|| t.AgentTypeName.EndsWith(str)
#endif
) {
return t;
}
}
return null;
}
public static bool parseParam(List<Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
{
string[] tokens = null;
if (param[0] == '\"') {
param = param.Substring(1, param.Length - 2);
} else if (param[0] == '{') {
//struct
//to set it as action.Method is used in the following parsing
Nodes.Action action = node as Nodes.Action;
if (action != null) {
action.Method = method;
}
} else {
tokens = param.Split(' ');
}
bool bOk = false;
if (tokens != null && tokens.Length > 1) {
//par
VariableDef var = setParameter(result, node, tokens[tokens.Length - 1]);
if (var != null) {
par.Value = var;
bOk = true;
}
} else {
bOk = Plugin.InvokeTypeParser(result, par.Type, param, (object value) => par.Value = value, node, par.Name);
}
return bOk;
}
private static VariableDef createVariable(List<Nodes.Node.ErrorCheck> result, DefaultObject node, AgentType agentType, string instacneName, string propertyName)
{
List<string> tokens = DesignerPropertyEnum.SplitTokens(propertyName);
Debug.Check(tokens.Count > 0);
string arrayIndexStr = null;
if (tokens.Count > 1) {
propertyName = tokens[0] + "[]";
arrayIndexStr = tokens[1];
}
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
agentType = Plugin.GetInstanceAgentType(instacneName, behavior, agentType);
if (agentType != null) {
IList<PropertyDef> properties = agentType.GetProperties();
foreach(PropertyDef p in properties) {
if (p.Name == propertyName
#if BEHAVIAC_NAMESPACE_FIX
|| p.Name.EndsWith(propertyName)
#endif
) {
VariableDef v = new VariableDef(p, instacneName);
if (v != null && !string.IsNullOrEmpty(arrayIndexStr)) {
v.ArrayIndexElement = new MethodDef.Param("ArrayIndex", typeof(int), "int", "ArrayIndex", "ArrayIndex");
v.ArrayIndexElement.IsArrayIndex = true;
DesignerMethodEnum.parseParam(result, node, null, v.ArrayIndexElement, arrayIndexStr);
}
return v;
}
}
}
return null;
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
return ParseStringValue(result, type, str, node);
}
/// <summary>
/// Determines if an attachment of a certain type is aceepted by this node or not.
/// </summary>
/// <param name="type">The type of the attachment we want to add.</param>
/// <returns>Returns if the attachment may be added or not</returns>
public virtual bool AcceptsAttachment(DefaultObject obj) {
return (obj != null) && !obj.IsFSM && obj.CanBeAttached;
}
public override bool AcceptsAttachment(DefaultObject obj)
{
return (obj != null) && (obj is WaitTransition);
}
protected VariableDef parseConstVar(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, string str)
{
Debug.Check(str.StartsWith("const"));
//const Int32 1
object propertyMemberDepended = null;
Type objType = node.GetType();
if (this.DependedProperty != "") {
System.Reflection.PropertyInfo pi = objType.GetProperty(this.DependedProperty);
if (pi != null) {
propertyMemberDepended = pi.GetValue(node, null);
} else if (pi == null && parentObject != null) {
Type parentType = parentObject.GetType();
pi = parentType.GetProperty(this.DependedProperty);
propertyMemberDepended = pi.GetValue(parentObject, null);
}
}
Type valueType = null;
VariableDef variableDepended = propertyMemberDepended as VariableDef;
if (variableDepended != null) {
valueType = variableDepended.GetValueType();
} else if (propertyMemberDepended != null) {
MethodDef methodDepended = propertyMemberDepended as MethodDef;
if (methodDepended != null) {
valueType = methodDepended.ReturnType;
} else {
RightValueDef varRV = propertyMemberDepended as RightValueDef;
if (varRV != null) {
valueType = varRV.ValueType;
}
}
} else {
string[] tokens = str.Split(' ');
Debug.Check(tokens.Length >= 3);
valueType = Plugin.GetTypeFromName(tokens[1]);
}
if (valueType != null) {
VariableDef variable = new VariableDef(null);
//string[] tokens = str.Split(' ');
//Debug.Check(tokens.Length == 3);
Debug.Check(str.StartsWith("const"));
//skip 'const '
int pos = str.IndexOf(' ');
Debug.Check(pos != -1);
pos = str.IndexOf(' ', pos + 1);
string token = str.Substring(pos + 1);
Plugin.InvokeTypeParser(result, valueType, token,
(object value) => variable.Value = value,
node);
return variable;
}
return null;
}
/// <summary>
/// Handles when a key is pressed.
/// </summary>
protected override void OnKeyDown(KeyEventArgs e) {
switch (e.KeyCode) {
// store when the control key is pressed
case (Keys.ControlKey):
if (_copiedNode == null && _movedNode == null) {
Cursor = Cursors.Default;
}
break;
// store when the shift key is pressed
case (Keys.ShiftKey):
// update the drawn graph for dragging and duplicating
if (_movedNodeGraph != null) {
_movedNodeGraph.RenderDepth = int.MaxValue;
Invalidate();
}
break;
// cut to clipboard
case (Keys.X):
if (KeyCtrlIsDown) {
CutSelectedNode(KeyShiftIsDown);
}
break;
// copy to clipboard
case (Keys.C):
if (KeyCtrlIsDown) {
CopySelectedNode(KeyShiftIsDown);
}
break;
// paste from clipboard
case (Keys.V):
if (!_clipboardPasteMode) {
_clipboardPasteMode = KeyCtrlIsDown && _clipboardNode != null;
if (_clipboardPasteMode) {
// create the layout manager used to draw the graph
_movedNodeGraph = new NodeLayoutManager(_clipboardNode.CloneBranch().CreateNodeViewData(null, _rootNodeView.RootBehavior), _nodeLayoutManager.EdgePen, _nodeLayoutManager.EdgePenSelected, _nodeLayoutManager.EdgePenHighlighted, _nodeLayoutManager.EdgePenUpdate, _nodeLayoutManager.EdgePenReadOnly, true);
_movedNodeGraph.Scale = 0.3f;
//_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
_movedNodeGraph.RenderDepth = int.MaxValue;
// use the existing node as the node defaults
_dragNodeDefaults = _clipboardNode;
Invalidate();
}
}
break;
// handle when the delete key is pressed
case (Keys.Delete):
DeleteSelectedNode(KeyShiftIsDown);
break;
case (Keys.E):
if (e.Control) {
CenterNode(_rootNodeView);
}
break;
case (Keys.Oemplus):
if (e.Control) {
scaleGraph(0.1f * _nodeLayoutManager.Scale, false);
}
break;
case (Keys.OemMinus):
if (e.Control) {
scaleGraph(-0.1f * _nodeLayoutManager.Scale, false);
}
break;
case (Keys.K):
if (e.Control) {
CheckErrors(_rootNodeView.RootBehavior, false);
}
break;
case (Keys.F9):
if (SelectedNode != null) {
if (e.Shift) {
SelectedNode.SetBreakpoint(HighlightBreakPoint.kExit);
} else if (e.Control) {
SelectedNode.SetBreakpoint(HighlightBreakPoint.kPlanning);
} else {
SelectedNode.SetBreakpoint(HighlightBreakPoint.kEnter);
}
LayoutChanged();
}
break;
case (Keys.F8):
toggleEnableNode();
break;
case (Keys.F1):
openDoc();
break;
case (Keys.Left):
case (Keys.Right):
case (Keys.Up):
case (Keys.Down):
if (e.Control)
{
switch (e.KeyCode)
{
case (Keys.Left):
_nodeLayoutManager.Offset = new PointF(_nodeLayoutManager.Offset.X - 10, _nodeLayoutManager.Offset.Y);
Invalidate();
break;
case (Keys.Right):
_nodeLayoutManager.Offset = new PointF(_nodeLayoutManager.Offset.X + 10, _nodeLayoutManager.Offset.Y);
Invalidate();
break;
case (Keys.Up):
_nodeLayoutManager.Offset = new PointF(_nodeLayoutManager.Offset.X, _nodeLayoutManager.Offset.Y - 10);
Invalidate();
break;
case (Keys.Down):
_nodeLayoutManager.Offset = new PointF(_nodeLayoutManager.Offset.X, _nodeLayoutManager.Offset.Y + 10);
Invalidate();
break;
}
break;
}
break;
default:
base.OnKeyDown(e);
break;
}
}
public static MethodDef parseMethodString(List<Nodes.Node.ErrorCheck> result, DefaultObject node, AgentType agentType, MethodType methodType, string str)
{
try {
if (agentType != null) {
int pos = str.IndexOf('(');
if (pos < 0)
{ return null; }
string ownerName = agentType.ToString();
int pointIndex = str.IndexOf('.');
if (pointIndex > -1 && pointIndex < pos) {
ownerName = str.Substring(0, pointIndex);
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
if (ownerName != VariableDef.kSelf && !Plugin.IsInstanceName(ownerName, behavior))
{
throw new Exception("The instance does not exist.");
}
str = str.Substring(pointIndex + 1, str.Length - pointIndex - 1);
agentType = Plugin.GetInstanceAgentType(ownerName, behavior, agentType);
//if (agentType == node.Behavior.AgentType)
// ownerName = VariableDef.kSelf;
pos = str.IndexOf('(');
}
IList<MethodDef> actions = agentType.GetMethods(methodType);
string actionName = str.Substring(0, pos);
foreach(MethodDef actionTypeIt in actions) {
if (actionTypeIt.Name == actionName
#if BEHAVIAC_NAMESPACE_FIX
|| actionTypeIt.Name.EndsWith(actionName)
#endif
) {
MethodDef method = new MethodDef(actionTypeIt);
method.Owner = ownerName;
List<string> paras = parseParams(str.Substring(pos + 1, str.Length - pos - 2));
//Debug.Check((paras.Count == actionTypeIt.Params.Count));
//if (paras.Count == actionTypeIt.Params.Count)
{
for (int i = 0; i < paras.Count; ++i) {
if (i >= method.Params.Count) {
break;
}
string param = paras[i];
MethodDef.Param par = method.Params[i];
bool bOk = parseParam(result, node, method, par, param);
if (!bOk) {
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalFloatValue, str));
}
}
}
return method;
}
}
}
} catch (Exception) {
//System.Windows.Forms.MessageBox.Show(str, Resources.LoadError, System.Windows.Forms.MessageBoxButtons.OK);
if (result != null)
{
Nodes.Node n = node as Nodes.Node;
string label = "";
if (n == null)
{
Attachments.Attachment a = node as Attachments.Attachment;
if (a != null)
{
n = a.Node;
label = a.Label;
}
}
else
{
label = n.Label;
}
Nodes.Node.ErrorCheck error = new Nodes.Node.ErrorCheck(n, node.Id, label, Nodes.ErrorCheckLevel.Error, str);
result.Add(error);
}
}
return null;
}
/// <summary>
/// Handles when a mouse button is let go of.
/// </summary>
protected override void OnMouseUp(MouseEventArgs e)
{
_movedSubItem = null;
// check if we were dragging a transition for the FSM.
if (e.Button == MouseButtons.Left && _currentNode != null && ((_objectDragType == ObjectDragTypes.kNode) && _currentNode.IsFSM || _fsmSubItem != null && _fsmDragMode != FSMDragModes.kNone)) {
if (Plugin.EditMode == EditModes.Design && _startMousePosition != e.Location) {
// drag and move the fsm node
if ((_objectDragType == ObjectDragTypes.kNode) && _currentNode.IsFSM) {
UndoManager.Save(this.RootNode);
LayoutChanged();
}
// drag and connector the target node
else {
NodeViewData targetNvd = _rootNodeView.GetInsideNode(e.Location);
if (targetNvd != null && targetNvd.IsFSM && (targetNvd.Parent != null) && _fsmSubItem is NodeViewData.SubItemAttachment) {
NodeViewData.SubItemAttachment subItemAttachment = _fsmSubItem as NodeViewData.SubItemAttachment;
if (subItemAttachment.Attachment != null && subItemAttachment.Attachment.TargetFSMNodeId != targetNvd.Node.Id) {
subItemAttachment.Attachment.TargetFSMNodeId = targetNvd.Node.Id;
UndoManager.Save(this.RootNode);
LayoutChanged();
}
}
}
}
}
// check if we were dragging an existing sub item.
else if (e.Button == MouseButtons.Left && _currentNode != null && _dragTargetNode != null && _dragAttachment != null) {
NodeViewData.SubItem targetSubItem = _dragTargetNode.GetSubItem(_dragTargetNode, _nodeLayoutManager.ViewToGraph(e.Location));
if (KeyCtrlIsDown || targetSubItem != _dragAttachment) {
NodeViewData.SubItemAttachment targetAttachment = targetSubItem as NodeViewData.SubItemAttachment;
if ((_currentNode != _dragTargetNode || targetAttachment != null) &&
this.MoveSubItem(_currentNode, _dragTargetNode, _dragAttachment, targetAttachment, _dragAttachMode == NodeAttachMode.Top, KeyCtrlIsDown)) {
_currentNode.ClickEvent(_currentNode, _nodeLayoutManager.ViewToGraph(e.Location));
LayoutChanged();
}
}
_dragAttachment = null;
_dragTargetAttachment = null;
_dragAttachMode = NodeAttachMode.None;
}
// check if we were dragging or copying an existing node.
else if (e.Button == MouseButtons.Left && (_movedNode != null || _copiedNode != null || _clipboardPasteMode)) {
// if we have a valid target node continue
if (_dragTargetNode != null) {
Node sourceNode = null;
if (_copiedNode != null) {
bool cloneBranch = !(_copiedNode is ReferencedBehavior);
sourceNode = (KeyShiftIsDown && cloneBranch) ? (Nodes.Node)_copiedNode.CloneBranch() : (Nodes.Node)_copiedNode.Clone();
} else if (_clipboardPasteMode) {
bool cloneBranch = !(_clipboardNode is ReferencedBehavior);
sourceNode = (/*KeyShiftIsDown && */cloneBranch) ? (Nodes.Node)_clipboardNode.CloneBranch() : (Nodes.Node)_clipboardNode.Clone();
} else if (_movedNode != null) {
sourceNode = _movedNode;
}
Debug.Check(sourceNode != null);
Node sourceParent = (Node)sourceNode.Parent;
BehaviorNode sourceBehavior = sourceNode.Behavior;
if (_dragTargetNode.Node == sourceNode) {
_dragAttachMode = NodeAttachMode.None;
}
if (_dragAttachMode == NodeAttachMode.Top ||
_dragAttachMode == NodeAttachMode.Bottom ||
_dragAttachMode == NodeAttachMode.Left ||
_dragAttachMode == NodeAttachMode.Right ||
_dragAttachMode == NodeAttachMode.Center) {
// set the prefab dirty for its previous parent
if (sourceParent != null && !string.IsNullOrEmpty(sourceParent.PrefabName)) {
sourceParent.HasOwnPrefabData = true;
}
if (KeyShiftIsDown) {
if (sourceParent != null) {
sourceParent.RemoveChild(sourceNode.ParentConnector, sourceNode);
}
} else {
sourceNode.ExtractNode();
}
}
// move the dragged node to the target node, according to the attach mode
switch (_dragAttachMode) {
// the node will be placed above the target node
case (NodeAttachMode.Top):
int n = _dragTargetNode.Node.ParentConnector.GetChildIndex(_dragTargetNode.Node);
((Node)_dragTargetNode.Node.Parent).AddChild(_dragTargetNode.Node.ParentConnector, sourceNode, n);
_selectedNodePending = sourceNode;
_selectedNodePendingParent = _dragTargetNode.Parent;
LayoutChanged();
break;
// the node will be placed below the target node
case (NodeAttachMode.Bottom):
int m = _dragTargetNode.Node.ParentConnector.GetChildIndex(_dragTargetNode.Node);
((Node)_dragTargetNode.Node.Parent).AddChild(_dragTargetNode.Node.ParentConnector, sourceNode, m + 1);
_selectedNodePending = sourceNode;
_selectedNodePendingParent = _dragTargetNode.Parent;
LayoutChanged();
break;
// the node will be placed in front of the target node
case (NodeAttachMode.Left):
Node parent = (Node)_dragTargetNode.Node.Parent;
Node.Connector conn = _dragTargetNode.Node.ParentConnector;
int o = conn.GetChildIndex(_dragTargetNode.Node);
parent.RemoveChild(conn, _dragTargetNode.Node);
parent.AddChild(conn, sourceNode, o);
BaseNode.Connector sourceConn = sourceNode.GetConnector(conn.Identifier);
Debug.Check(sourceConn != null);
sourceNode.AddChild(sourceConn, _dragTargetNode.Node);
_selectedNodePending = sourceNode;
_selectedNodePendingParent = _dragTargetNode.Parent;
LayoutChanged();
break;
// the node will simply attached to the target node
case (NodeAttachMode.Right):
_dragTargetNode.Node.AddChild(_dragTargetConnector, sourceNode);
_selectedNodePending = sourceNode;
_selectedNodePendingParent = _dragTargetNode;
LayoutChanged();
break;
// the node will replace the target node
case (NodeAttachMode.Center):
if (replaceNode(_dragTargetNode.Node, sourceNode)) {
LayoutChanged();
}
break;
}
if (_dragAttachMode != NodeAttachMode.None) {
// If cloning a node, its Id should be reset.
if (_copiedNode != null || _clipboardPasteMode) {
// Cross two different behavior files
if (_clipboardPasteMode && _clipboardRootNode != this.RootNodeView) {
try {
// Copy the used Pars from the current behavior to the new one.
if (_clipboardNode != null && _clipboardRootNode != null && _clipboardRootNode.Node is Behavior) {
foreach(ParInfo par in((Behavior)(_clipboardRootNode.Node)).LocalVars) {
List<Node.ErrorCheck> result = new List<Node.ErrorCheck>();
Plugin.CheckPar(_clipboardNode, par, ref result);
if (result.Count > 0) {
bool bExist = false;
foreach(ParInfo p in((Behavior)this.RootNode).LocalVars) {
if (p.Name == par.Name) {
bExist = true;
break;
}
}
if (!bExist) {
((Behavior)this.RootNode).LocalVars.Add(par);
}
}
}
}
// reset its properties and methods
sourceNode.ResetMembers(false, this.RootNode.AgentType, true);
} catch {
}
}
// reset its Id
sourceNode.ResetId(true);
}
// update the node's label
sourceNode.OnPropertyValueChanged(false);
// set the prefab dirty for its current parent
if (sourceNode.Parent != null) {
Node parent = (Node)sourceNode.Parent;
if (!string.IsNullOrEmpty(parent.PrefabName)) {
parent.HasOwnPrefabData = true;
sourceNode.SetPrefab(parent.PrefabName, true);
}
}
UndoManager.Save(this.RootNode);
}
}
// reset all the drag data
if (!_clipboardPasteMode) {
_copiedNode = null;
_movedNode = null;
_dragTargetNode = null;
_dragNodeDefaults = null;
_movedNodeGraph = null;
}
// redraw the graph
Invalidate();
}
// popup the menu for the current hit node
else if (e.Button == MouseButtons.Right && !KeyAltIsDown && !KeyCtrlIsDown && !KeyShiftIsDown) {
bool itemEnabled = (SelectedNode != null && SelectedNode.Node.Parent != null);
itemEnabled &= (Plugin.EditMode == EditModes.Design);
deleteMenuItem.ShortcutKeys = Keys.Delete;
deleteTreeMenuItem.ShortcutKeys = Keys.Shift | Keys.Delete;
cutMenuItem.Enabled = SelectedNodeCanBeCut();
cutTreeMenuItem.Enabled = (SelectedNode != null) && !SelectedNode.IsFSM && SelectedTreeCanBeCut();
copyMenuItem.Enabled = itemEnabled;
copySubtreeMenuItem.Enabled = (SelectedNode != null) && !SelectedNode.IsFSM;
pasteMenuItem.Enabled = SelectedNodeCanBePasted();
deleteMenuItem.Enabled = SelectedNodeCanBeDeleted();
deleteTreeMenuItem.Enabled = (SelectedNode != null) && !SelectedNode.IsFSM && SelectedTreeCanBeDeleted();
bool isReferencedBehavior = SelectedNode != null && SelectedNode.Node is ReferencedBehavior;
bool isEvent = SelectedNode != null && SelectedNode.SelectedSubItem != null && SelectedNode.SelectedSubItem.SelectableObject is Attachments.Event;
referenceMenuItem.Enabled = itemEnabled || isReferencedBehavior || isEvent;
referenceMenuItem.Text = (isReferencedBehavior || isEvent) ? Resources.OpenReference : Resources.SaveReference;
disableMenuItem.Enabled = false;
if (itemEnabled)
{
if (SelectedNode.SelectedSubItem != null && SelectedNode.SelectedSubItem.SelectableObject is Attachments.Attachment)
{
Attachments.Attachment attach = SelectedNode.SelectedSubItem.SelectableObject as Attachments.Attachment;
disableMenuItem.Enabled = attach.CanBeDisabled();
disableMenuItem.Text = attach.Enable ? Resources.DisableNode : Resources.EnableNode;
}
else
{
disableMenuItem.Enabled = SelectedNode.Node.CanBeDisabled();
disableMenuItem.Text = SelectedNode.Node.Enable ? Resources.DisableNode : Resources.EnableNode;
}
}
expandMenuItem.Enabled = (SelectedNode != null && SelectedNode.CanBeExpanded());
collapseMenuItem.Enabled = expandMenuItem.Enabled;
expandAllMenuItem.Enabled = expandMenuItem.Enabled;
collapseAllMenuItem.Enabled = expandMenuItem.Enabled;
bool isPrefabInstance = SelectedNode != null && !string.IsNullOrEmpty(SelectedNode.Node.PrefabName);
breakPrefabMenuItem.Enabled = itemEnabled && isPrefabInstance;
if (isPrefabInstance) {
string fullpath = FileManagers.FileManager.GetFullPath(SelectedNode.Node.PrefabName);
isPrefabInstance = File.Exists(fullpath);
}
savePrefabMenuItem.Enabled = itemEnabled;
savePrefabMenuItem.Text = isPrefabInstance ? Resources.OpenPrefab : Resources.SavePrefab;
if (SelectedNode != null) {
Node prefabRoot = SelectedNode.Node.GetPrefabRoot();
string relativeFilename = FileManagers.FileManager.GetRelativePath(this.RootNode.Filename);
applyMenuItem.Enabled = itemEnabled && isPrefabInstance && SelectedNode.Node.PrefabName != relativeFilename && prefabRoot.IsPrefabDataDirty();
}
breakpointMenuItem.Enabled = SelectedNode != null && SelectedNode.Parent != null;
if (SelectedNode != null) {
enterBreakpointMenuItem.Text = SelectedNode.GetBreakpointOperation(HighlightBreakPoint.kEnter);
exitBreakpointMenuItem.Text = SelectedNode.GetBreakpointOperation(HighlightBreakPoint.kExit);
this.beakpointPlanning.Visible = false;
if (SelectedNode.Node is Task) {
this.beakpointPlanning.Visible = true;
beakpointPlanning.Text = SelectedNode.GetBreakpointOperation(HighlightBreakPoint.kPlanning);
}
}
contextMenu.Show(this, new Point(e.X, e.Y));
}
Cursor = Cursors.Default;
_fsmDragMode = FSMDragModes.kNone;
// redraw the graph
Invalidate();
base.OnMouseUp(e);
}
/// <summary>
/// Handles when a key is released.
/// </summary>
protected override void OnKeyUp(KeyEventArgs e) {
switch (e.KeyCode) {
case (Keys.Enter):
if (SelectedNode != null) {
if (KeyCtrlIsDown) {
SelectedNode.ExpandAll(!SelectedNode.IsExpanded);
}
else {
SelectedNode.IsExpanded = !SelectedNode.IsExpanded;
}
LayoutChanged();
e.Handled = true;
}
break;
// store when the shift key is released
case (Keys.ShiftKey):
// update the drawn graph for dragging and duplicating
if (_movedNodeGraph != null) {
_movedNodeGraph.RenderDepth = 0;
Invalidate();
}
break;
// paste from clipboard
case (Keys.V):
PasteSelectedNode();
_clipboardPasteMode = false;
// reset all the drag data
_copiedNode = null;
_movedNode = null;
_dragTargetNode = null;
_dragNodeDefaults = null;
_movedNodeGraph = null;
// redraw the graph
Invalidate();
break;
case (Keys.Left):
case (Keys.Right):
case (Keys.Up):
case (Keys.Down):
if (e.Control)
{
break;
}
if (SelectedNode == null) {
SelectedNode = this.RootNodeView;
if (ClickNode != null) {
ClickNode(SelectedNode);
}
LayoutChanged();
break;
}
switch (e.KeyCode) {
case (Keys.Left):
if (SelectedNode != null && SelectedNode.Parent != null) {
SelectedNode = SelectedNode.Parent;
if (ClickNode != null) {
ClickNode(SelectedNode);
}
LayoutChanged();
}
break;
case (Keys.Right):
if (SelectedNode != null && SelectedNode.Children.Count > 0) {
SelectedNode = SelectedNode.Children[0] as NodeViewData;
if (ClickNode != null) {
ClickNode(SelectedNode);
}
LayoutChanged();
}
break;
case (Keys.Up):
if (SelectedNode != null) {
if (!KeyShiftIsDown || !SwitchSelection()) {
// Node
if (SelectedNode.SelectedSubItem == null) {
if (SelectedNode.PreviousNode != null) {
if (KeyCtrlIsDown) { // Move
MoveNode(true);
} else { // Select
SelectedNode = SelectedNode.PreviousNode as NodeViewData;
if (ClickNode != null) {
ClickNode(SelectedNode);
}
}
}
}
// Attachment
else {
NodeViewData.SubItem previousItem = SelectedNode.PreviousSelectedSubItem;
if (previousItem != null) {
if (KeyCtrlIsDown) { // Move
NodeViewData.SubItemAttachment sourceItem = SelectedNode.SelectedSubItem as NodeViewData.SubItemAttachment;
NodeViewData.SubItemAttachment targetItem = previousItem as NodeViewData.SubItemAttachment;
MoveSubItem(SelectedNode, SelectedNode, sourceItem, targetItem, true, false);
SelectedNode.SelectedSubItem = sourceItem;
} else { // Select
SelectedNode.SelectedSubItem = previousItem;
if (ClickEvent != null) {
ClickEvent(SelectedNode);
}
}
}
}
}
LayoutChanged();
}
break;
case (Keys.Down):
if (SelectedNode != null) {
if (!KeyShiftIsDown || !SwitchSelection()) {
// Node
if (SelectedNode.SelectedSubItem == null) {
if (SelectedNode.NextNode != null) {
if (KeyCtrlIsDown) { // Move
MoveNode(false);
} else { // Select
SelectedNode = SelectedNode.NextNode as NodeViewData;
if (ClickNode != null) {
ClickNode(SelectedNode);
}
}
}
}
// Attachment
else {
NodeViewData.SubItem nextItem = SelectedNode.NextSelectedSubItem;
if (nextItem != null) {
if (KeyCtrlIsDown) { // Move
NodeViewData.SubItemAttachment sourceItem = SelectedNode.SelectedSubItem as NodeViewData.SubItemAttachment;
NodeViewData.SubItemAttachment targetItem = nextItem as NodeViewData.SubItemAttachment;
MoveSubItem(SelectedNode, SelectedNode, sourceItem, targetItem, false, false);
SelectedNode.SelectedSubItem = sourceItem;
} else { // Select
SelectedNode.SelectedSubItem = nextItem;
if (ClickEvent != null) {
ClickEvent(SelectedNode);
}
}
}
}
}
LayoutChanged();
}
break;
}
break;
default:
base.OnKeyUp(e);
break;
}
}
/// <summary>
/// Handles when the mouse is moved.
/// </summary>
protected override void OnMouseMove(MouseEventArgs e) {
if (_lostFocus) {
_lostFocus = false;
// update the last ouse position
_lastMousePosition = e.Location;
base.OnMouseMove(e);
return;
}
// returns the mouse under the mouse cursor
NodeViewData nodeFound = _rootNodeView.GetInsideNode(e.Location);
NodeViewData.SubItem subItemFound = null;
if (nodeFound != null) {
subItemFound = nodeFound.GetSubItem(nodeFound, _nodeLayoutManager.ViewToGraph(e.Location));
} else {
this.toolTip.Hide(this);
}
// clear previously stored node which can cause problems when dragging to another view
//_dragTargetNode = null;
if (nodeFound != null || _currentExpandNode != null || subItemFound != null) {
if (_dragAttachment == null) {
_currentNode = nodeFound;
}
if (Settings.Default.ShowNodeToolTips) {
if (nodeFound != null) {
_nodeToolTip = (subItemFound != null) ? subItemFound.ToolTip : nodeFound.ToolTip;
}
if (!string.IsNullOrEmpty(_nodeToolTip)) {
this.toolTipTimer.Start();
}
}
Invalidate();
}
// check if we are currently dragging the graph
if ((e.Button == MouseButtons.Middle || (e.Button == MouseButtons.Left && _objectDragType == ObjectDragTypes.kGraph)) && _lastMousePosition != e.Location && !this.contextMenu.Visible) {
Cursor = Cursors.SizeAll;
// move the graph according to the last mouse position
_nodeLayoutManager.Offset = new PointF(_nodeLayoutManager.Offset.X - (_lastMousePosition.X - e.X), _nodeLayoutManager.Offset.Y - (_lastMousePosition.Y - e.Y));
Invalidate();
}
// check if we start duplicating an existing node step 1
else if (e.Button == MouseButtons.Left && KeyCtrlIsDown && _lastMousePosition != e.Location && _dragNodeDefaults == null && _copiedNode == null && _currentNode != null && !(_currentNode.Node is BehaviorNode)) {
if (_objectDragType == ObjectDragTypes.kNode) { // node
_movedNode = null;
_copiedNode = _currentNode.Node;
// create the layout manager used to draw the graph
_movedNodeGraph = new NodeLayoutManager(_copiedNode.CloneBranch().CreateNodeViewData(null, _rootNodeView.RootBehavior), _nodeLayoutManager.EdgePen, _nodeLayoutManager.EdgePenSelected, _nodeLayoutManager.EdgePenHighlighted, _nodeLayoutManager.EdgePenUpdate, _nodeLayoutManager.EdgePenReadOnly, true);
_movedNodeGraph.Scale = 0.3f;
_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
// use the existing node as the node defaults
_dragNodeDefaults = _copiedNode;
} else if (_objectDragType == ObjectDragTypes.kAttachment) { // attachment
if (_dragAttachment == null) {
NodeViewData.SubItem subItem = _currentNode.GetSubItem(_currentNode, _nodeLayoutManager.ViewToGraph(e.Location));
_dragAttachment = subItem as NodeViewData.SubItemAttachment;
}
}
Invalidate();
}
// check if we are duplicating an existing node step 2
else if (e.Button == MouseButtons.Left && KeyCtrlIsDown && (_copiedNode != null || _dragAttachment != null)) {
if (_objectDragType == ObjectDragTypes.kNode) { // node
_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
_dragTargetNode = _currentNode;
Cursor = _currentNode == null ? Cursors.No : Cursors.Default;
//Point movedGraphGraphPos= new Point(e.Location.X + _movedNodeGraph.Offset.X, e.Location.Y + _movedNodeGraph.Offset.Y /-2);
//_movedNodeGraph.Location= movedGraphGraphPos;
} else if (_objectDragType == ObjectDragTypes.kAttachment) { // attachment
_dragTargetNode = nodeFound;
if (_dragTargetNode != null) {
NodeViewData.SubItem subItem = _dragTargetNode.GetSubItem(_dragTargetNode, _nodeLayoutManager.ViewToGraph(e.Location));
_dragTargetAttachment = subItem as NodeViewData.SubItemAttachment;
}
}
Invalidate();
}
// check if we start dragging an existing node step 1
else if (e.Button == MouseButtons.Left && _lastMousePosition != e.Location && !KeyCtrlIsDown && _movedNode == null && _currentNode != null) {
if (_objectDragType == ObjectDragTypes.kNode) { // node
if (_currentNode.CanBeDragged())
{
if (_currentNode.IsFSM)
{
PointF currentGraphMousePos = _nodeLayoutManager.ViewToGraph(e.Location);
PointF lastGraphMousePos = _nodeLayoutManager.ViewToGraph(_lastMousePosition);
_currentNode.ScreenLocation = new PointF(_currentNode.ScreenLocation.X + currentGraphMousePos.X - lastGraphMousePos.X,
_currentNode.ScreenLocation.Y + currentGraphMousePos.Y - lastGraphMousePos.Y);
LayoutChanged();
}
else if ((KeyShiftIsDown || _currentNode.Node.ParentCanAdoptChildren))
{
_movedNode = _currentNode.Node;
// create the layout manager used to draw the graph
if (_movedNodeGraph == null)
{
_movedNodeGraph = new NodeLayoutManager(_movedNode.CloneBranch().CreateNodeViewData(null, _rootNodeView.RootBehavior), _nodeLayoutManager.EdgePen, _nodeLayoutManager.EdgePenSelected, _nodeLayoutManager.EdgePenHighlighted, _nodeLayoutManager.EdgePenUpdate, _nodeLayoutManager.EdgePenReadOnly, true);
}
_movedNodeGraph.Scale = 0.3f;
//_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
_movedNodeGraph.RenderDepth = int.MaxValue;
}
}
} else if (_objectDragType == ObjectDragTypes.kAttachment) { // attachment
if (_fsmDragMode == FSMDragModes.kNone && Plugin.EditMode == EditModes.Design) {
_movedNodeGraph = null;
_dragTargetNode = nodeFound;
if (_dragAttachment == null) {
NodeViewData.SubItem subItem = _currentNode.GetSubItem(_currentNode, _nodeLayoutManager.ViewToGraph(e.Location));
_dragAttachment = subItem as NodeViewData.SubItemAttachment;
if (_dragAttachment != null) {
_movedSubItem = _dragAttachment.Clone(_currentNode.Node);
}
} else if (_dragTargetNode != null) {
NodeViewData.SubItem subItem = _dragTargetNode.GetSubItem(_dragTargetNode, _nodeLayoutManager.ViewToGraph(e.Location));
_dragTargetAttachment = subItem as NodeViewData.SubItemAttachment;
}
}
}
Invalidate();
}
// check if we start dragging an existing node step 2
else if (e.Button == MouseButtons.Left && _movedNode != null && !_clipboardPasteMode) {
// create the layout manager used to draw the graph
if (_movedNodeGraph == null) {
_movedNodeGraph = new NodeLayoutManager(_movedNode.CloneBranch().CreateNodeViewData(null, _rootNodeView.RootBehavior), _nodeLayoutManager.EdgePen, _nodeLayoutManager.EdgePenSelected, _nodeLayoutManager.EdgePenHighlighted, _nodeLayoutManager.EdgePenUpdate, _nodeLayoutManager.EdgePenReadOnly, true);
}
_movedNodeGraph.Scale = 0.3f;
_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
_dragNodeDefaults = _movedNode;
_dragTargetNode = _currentNode;
Cursor = _currentNode == null ? Cursors.No : Cursors.Default;
Invalidate();
} else if (_clipboardPasteMode) {
if (_movedNodeGraph != null) {
//_movedNodeGraph.RenderDepth = KeyShiftIsDown ? int.MaxValue : 0;
_movedNodeGraph.RenderDepth = int.MaxValue;
}
_dragTargetNode = _currentNode;
Cursor = _currentNode == null ? Cursors.No : Cursors.Default;
Invalidate();
} else if (_currentNode != null && _dragAttachment == null) {
// Highlight the expand/collapse flag
PointF graphMousePos = _nodeLayoutManager.ViewToGraph(e.Location);
bool isInExandRange = _currentNode.IsInExpandRange(graphMousePos);
bool isInExandConnectorRange = _currentNode.IsInExpandConnectorRange(graphMousePos);
if (isInExandRange || isInExandConnectorRange) {
_currentExpandNode = _currentNode;
_nodeToolTip = isInExandRange ? Resources.ExpandAllInfo : Resources.ExpandConnectorInfo;
Invalidate();
} else if (_currentExpandNode != null) {
_currentExpandNode = null;
Invalidate();
}
}
// update the last ouse position
_lastMousePosition = e.Location;
base.OnMouseMove(e);
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (type != typeof(string))
{ throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }
return str;
}
public override bool AcceptsAttachment(DefaultObject obj)
{
return false;
}
public static VariableDef setParameter(List<Nodes.Node.ErrorCheck> result, DefaultObject node, string propertyName)
{
Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
// Convert the Par to the Property
if (!propertyName.Contains(".") && !propertyName.Contains(":"))
{ propertyName = "Self." + behavior.AgentType.AgentTypeName + "::" + propertyName; }
VariableDef var = null;
string instance = Plugin.GetInstanceName(propertyName);
if (!string.IsNullOrEmpty(instance)) {
propertyName = propertyName.Substring(instance.Length + 1, propertyName.Length - instance.Length - 1);
var = createVariable(result, node, behavior.AgentType, instance, propertyName);
if (var != null) {
return var;
}
}
// Try to find the Agent property with the name.
if (behavior != null && behavior.AgentType != null) {
instance = "Self";
var = createVariable(result, node, behavior.AgentType, instance, propertyName);
if (var != null) {
return var;
}
}
// Try to find the global property with the name.
string instacneName = Plugin.GetClassName(propertyName);
if (!string.IsNullOrEmpty(instacneName) && Plugin.GetInstanceAgentType(instacneName, behavior, null) != null) {
var = createVariable(result, node, behavior.AgentType, instacneName, propertyName);
if (var != null) {
return var;
}
}
return null;
}
/// <summary>
/// Handles when dropping a tree node on the view.
/// </summary>
private void BehaviorTreeView_DragDrop(object sender, DragEventArgs e) {
// make sure the view is focused
Focus();
// drag the property or method into the node
string dragItem = (string)e.Data.GetData(DataFormats.Text);
if (!string.IsNullOrEmpty(dragItem) && _dragTargetNode != null && _dragTargetNode.Node != null) {
if (_dragTargetNode.Node.SetDefaultPropertyByDragAndDrop(dragItem)) {
if (ClickNode != null) {
ClickNode(_dragTargetNode);
}
UndoManager.Save(this.RootNode);
LayoutChanged();
}
return;
}
// get source node
TreeNode sourceNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
if (sourceNode == null) {
return;
}
NodeTag sourceNodeTag = (NodeTag)sourceNode.Tag;
// keep the current node position
//KeepNodePosition(_dragTargetNode);
bool bDragBTOverNode = !((Node)this.RootNode).IsFSM && sourceNodeTag.Type == NodeTagType.Behavior && _dragTargetNode is Behaviac.Design.NodeViewData;
// check if we are dropping an attach
// or if we are dropping a bt to a node and the indicator is not left/right/up/bottom/center
if (_dragAttachMode == NodeAttachMode.Attachment ||
(bDragBTOverNode && (_dragAttachMode == NodeAttachMode.None || _dragAttachMode == NodeAttachMode.Attachment))) {
Attachments.Attachment attach = null;
// when we attach a behaviour we must create a special referenced behaviour node
if (bDragBTOverNode) {
//drag an event(a bt) to a node
if (!File.Exists(sourceNodeTag.Filename))
{
MainWindow.Instance.SaveBehavior(sourceNodeTag.Defaults as Nodes.BehaviorNode, false);
}
if (File.Exists(sourceNodeTag.Filename)) {
// get the behavior we want to reference
BehaviorNode behavior = _behaviorTreeList.LoadBehavior(sourceNodeTag.Filename);
Behavior rootB = _rootNodeView.RootBehavior as Behavior;
Behavior b = behavior as Behavior;
if (!b.CanBeAttached || !IsCompatibleAgentType(rootB, b))
return;
attach = Behaviac.Design.Attachments.Attachment.Create(typeof(Behaviac.Design.Attachments.Event), _dragTargetNode.Node);
Behaviac.Design.Attachments.Event evt = (Behaviac.Design.Attachments.Event)attach;
evt.ReferencedBehavior = behavior;
}
} else if (_dragTargetNode != null) {
Debug.Check(_dragAttachMode == NodeAttachMode.Attachment);
// add the attach to the target node
attach = Behaviac.Design.Attachments.Attachment.Create(sourceNodeTag.NodeType, _dragTargetNode.Node);
}
if (_dragTargetNode != null && attach != null && _dragTargetNode.Node.AcceptsAttachment(attach))
{
attach.OnPropertyValueChanged(false);
attach.ResetId();
_dragTargetNode.Node.AddAttachment(attach);
NodeViewData.SubItemAttachment sub = attach.CreateSubItem();
_dragTargetNode.AddSubItem(sub);
SelectedNode = _dragTargetNode;
SelectedNode.SelectedSubItem = sub;
// call the ClickEvent event handler
if (ClickEvent != null) {
ClickEvent(SelectedNode);
}
UndoManager.Save(this.RootNode);
LayoutChanged();
}
}
//else if (_dragAttachMode != NodeAttachMode.None)
else {
// attach a new node to the target node
InsertNewNode(_dragTargetNode, _dragAttachMode, sourceNodeTag, this.PointToClient(new Point(e.X, e.Y)));
}
// reset drag stuff
_dragTargetNode = null;
_dragNodeDefaults = null;
_dragAttachMode = NodeAttachMode.None;
Invalidate();
}
public static bool parseParam(List<Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
{
string propName = null;
if (param[0] == '\"')
{
param = param.Substring(1, param.Length - 2);
}
else if (param[0] == '{') //struct
{
//to set it as action.Method is used in the following parsing
Nodes.Action action = node as Nodes.Action;
if (action != null)
{
action.Method = method;
}
}
else
{
string noStaticParam = param.Replace("static ", "");
int index = noStaticParam.IndexOf(" ");
if (index >= 0)
propName = noStaticParam.Substring(index + 1);
}
bool bOk = false;
if (propName != null)
{
VariableDef var = setParameter(result, node, propName);
if (var != null)
{
par.Value = var;
bOk = true;
}
}
else
{
bOk = Plugin.InvokeTypeParser(result, par.Type, param,
(object value) => par.Value = value,
node, par.Name);
}
return bOk;
}
/// <summary>
/// Handles when a tree node is dragged into the view.
/// </summary>
private void BehaviorTreeView_DragEnter(object sender, DragEventArgs e) {
TreeNode sourceNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
if (sourceNode != null) {
NodeTag sourceNodeTag = sourceNode.Tag as NodeTag;
if (sourceNodeTag == null) {
return;
}
// store the tree node's defaults
_dragNodeDefaults = sourceNodeTag.Defaults;
}
}
public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
{
if (!Plugin.IsIntergerNumberType(type))
throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
int resultValue = 0;
if (int.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out resultValue))
return resultValue;
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalIntegerValue, str));
}
/// <summary>
/// Used to replace the default object with a behaviour once loaded.
/// </summary>
/// <param name="behavior">The behaviour we have loaded.</param>
public void AssignLoadedBehavior(BehaviorNode behavior)
{
Debug.Check(_type ==NodeTagType.Behavior);
Debug.Check(_filename ==behavior.FileManager.Filename);
_defaults= (DefaultObject)behavior;
}
protected static VariableDef setProperty(List<Nodes.Node.ErrorCheck> result, DefaultObject node, AgentType agentType, string propertyName, string arrayIndexStr, string valueType)
{
if (agentType != null)
{
IList<PropertyDef> properties = agentType.GetProperties();
foreach (PropertyDef p in properties)
{
if (p.Name == propertyName
#if BEHAVIAC_NAMESPACE_FIX
|| p.Name.EndsWith(propertyName)
#endif
)
{
PropertyDef prop = p.Clone();
prop.Owner = valueType;
VariableDef v = new VariableDef(prop, valueType);
if (v != null && !string.IsNullOrEmpty(arrayIndexStr))
{
v.ArrayIndexElement = new MethodDef.Param("ArrayIndex", typeof(int), "int", "ArrayIndex", "ArrayIndex");
v.ArrayIndexElement.IsArrayIndex = true;
DesignerMethodEnum.parseParam(result, node, null, v.ArrayIndexElement, arrayIndexStr);
}
return v;
}
}
}
return null;
}
/// <summary>
/// Creates a new NodeTag and an instance of the node for the defaults.
/// </summary>
/// <param name="type">The type of the node in the node explorer.</param>
/// <param name="nodetype">The type of the node which will be added to the behaviour tree.</param>
/// <param name="filename">The filename of the behaviour we want to load. Use string.Empty if the node is not a behaviour.</param>
public NodeTag(NodeTagType type, Type nodetype, string filename)
{
if((type ==NodeTagType.BehaviorFolder || type ==NodeTagType.NodeFolder) && nodetype !=null)
throw new Exception(Resources.ExceptionWrongNodeTagType);
_type= type;
_nodetype= nodetype;
_filename= filename;
if(nodetype ==null)
{
_defaults= null;
}
else
{
//if(!nodetype.IsSubclassOf(typeof(DefaultObject)))
// throw new Exception(Resources.ExceptionNotImplementDefaultObject);
if(nodetype.IsSubclassOf(typeof(Events.Event)) && type !=NodeTagType.Event)
throw new Exception(Resources.ExceptionWrongNodeTagType);
if(nodetype.IsSubclassOf(typeof(Nodes.Node)) && type !=NodeTagType.Node && type !=NodeTagType.Behavior)
throw new Exception(Resources.ExceptionWrongNodeTagType);
_defaults=type ==NodeTagType.Event ? (DefaultObject)Brainiac.Design.Events.Event.Create(nodetype, null) : (DefaultObject)Nodes.Node.Create(nodetype);
}
}
/// <summary>
/// Parse the string value to create an object.
/// </summary>
/// <param name="type">The type of the created object.</param>
/// <param name="str">The string value of the created object.</param>
/// <param name="node">The owner node of the created object.</param>
/// <returns>Returns the created object.</returns>
public static object ParseStringValue(List<Nodes.Node.ErrorCheck> result, Type type, string str, DefaultObject node)
{
object obj = null;
Plugin.InvokeTypeParser(result, type, str, (object value) => obj = value, node);
return obj;
}
public static object ParseStringValue(List<Nodes.Node.ErrorCheck> result, Type type, string str, DefaultObject node)
{
Debug.Check(Plugin.IsArrayType(type));
Type itemType = type.GetGenericArguments()[0];
if (Plugin.IsCustomClassType(itemType))
{ return DesignerArrayStruct.ParseStringValue(result, type, str, node); }
object obj = Plugin.CreateInstance(type);
Debug.Check(obj != null);
if (!string.IsNullOrEmpty(str)) {
System.Collections.IList list = (System.Collections.IList)obj;
int index = str.IndexOf(':');
if (index >= 0)
{ str = str.Substring(index + 1); }
if (!string.IsNullOrEmpty(str)) {
string[] tokens = str.Split('|');
foreach(string s in tokens) {
if (!string.IsNullOrEmpty(s))
{
Plugin.InvokeTypeParser(result, itemType, s, (object value) => { list.Add(value); }, node);
}
}
}
}
return obj;
}
