static public RoutineType GetRoutineTypeFromNode(NodeMethodAttribute node)
{
switch (node.type)
{
case NodeMethodType.Event:
return(RoutineType.Event);
case NodeMethodType.Condition:
return(RoutineType.Condition);
case NodeMethodType.Action:
return(RoutineType.Action);
case NodeMethodType.Other:
throw new Exception("Other is not a suitable type for a Routine");
default:
if (((NodeMethodType.Event) & node.type) == NodeMethodType.Event)
{
return(RoutineType.Event);
}
else if (((NodeMethodType.Condition) & node.type) == NodeMethodType.Condition)
{
return(RoutineType.Condition);
}
else if (((NodeMethodType.Action) & node.type) == NodeMethodType.Action)
{
return(RoutineType.Action);
}
else
{
throw new Exception("Node type is not a suitable type for a Routine");
}
}
}
protected ButtonAnswer[] GetNodeButtons(NodeMethodAttribute node)
{
if (node.type == NodeMethodType.Other)
{
if (m_selectedRoutine == null)
{
return(new ButtonAnswer[] { });
}
else
{
return(new ButtonAnswer[] { ButtonAnswer.Insert });
}
}
else
{
if (m_selectedRoutine == null)
{
return(new ButtonAnswer[] { ButtonAnswer.Add });
}
else
{
return(new ButtonAnswer[] { ButtonAnswer.Add, ButtonAnswer.Insert });
}
}
}
static public MethodInfo[] GetNodeMethods(out NodeMethodAttribute[] nodeMethodsAttribute, NodeMethodType filter)
{
List <MethodInfo> resultMethodsInfo = new List <MethodInfo>();
List <NodeMethodAttribute> resultAttributes = new List <NodeMethodAttribute>();
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
foreach (Type type in types)
{
MethodInfo[] allMethodsOfType = type.GetMethods();
foreach (MethodInfo methodInfo in allMethodsOfType)
{
if (methodInfo.DeclaringType != methodInfo.ReflectedType)
{
continue;
}
object[] methodAttributes = methodInfo.GetCustomAttributes(typeof(NodeMethodAttribute), true);
if (methodAttributes.Length > 0)
{
NodeMethodAttribute nodeMethodAttribute = (NodeMethodAttribute)methodAttributes[0];
if ((nodeMethodAttribute.m_type & filter) != nodeMethodAttribute.m_type)
{
continue;
}
resultMethodsInfo.Add(methodInfo);
resultAttributes.Add(nodeMethodAttribute);
}
}
}
nodeMethodsAttribute = resultAttributes.ToArray();
return(resultMethodsInfo.ToArray());
}
protected void RetrieveNodeMethodAttribute()
{
if (methodInfo == null)
{
return;
}
object[] attributes = methodInfo.GetCustomAttributes(typeof(NodeMethodAttribute), true);
if ((attributes == null) || (attributes.Length == 0))
{
return;
}
m_nodeMethodAttribute = attributes[0] as NodeMethodAttribute;
}
static private NodeSetData RetrieveNodeMethods(NodeMethodType filter)
{
NodeMethodAttribute[] nodeMethodsAttribute;
MethodInfo[] nodeMethodsInfo = NodeMethodAttribute.GetNodeMethods(out nodeMethodsAttribute, filter);
List <string> categories = GetNodeCategories(nodeMethodsAttribute);
categories.Sort();
List <NodeMethodAttribute>[] attributesByCategory = new List <NodeMethodAttribute> [categories.Count];
List <MethodInfo>[] methodsByCategory = new List <MethodInfo> [categories.Count];
for (int i = 0; i < categories.Count; i++)
{
attributesByCategory[i] = new List <NodeMethodAttribute>();
methodsByCategory[i] = new List <MethodInfo>();
}
for (int i = 0; i < nodeMethodsAttribute.Length; i++)
{
int categoryIndex = categories.IndexOf(nodeMethodsAttribute[i].category);
attributesByCategory[categoryIndex].Add(nodeMethodsAttribute[i]);
methodsByCategory[categoryIndex].Add(nodeMethodsInfo[i]);
}
List <string> filteredCategories = new List <string>(categories.Count);
List <NodeMethodAttribute[]> filteredNodeMethodsAttributes = new List <NodeMethodAttribute[]>(categories.Count);
List <MethodInfo[]> filteredNodeMethods = new List <MethodInfo[]>(categories.Count);
for (int i = 0; i < categories.Count; i++)
{
if (!categories[i].StartsWith("Hidden"))
{
filteredCategories.Add(categories[i]);
filteredNodeMethodsAttributes.Add(attributesByCategory[i].ToArray());
filteredNodeMethods.Add(methodsByCategory[i].ToArray());
}
}
return(new NodeSetData
{
nodeMethodsAttributes = filteredNodeMethodsAttributes.ToArray(),
nodeMethods = filteredNodeMethods.ToArray(),
nodeCategories = filteredCategories.ToArray()
});
}
protected void DrawRoutineLine(Routine routine, float rectOffset, int routineIndex)
{
Texture2D routineIcon = null;
if (routine.finalNode != null)
{
MethodInfo nodeMethodInfo = routine.finalNode.methodInfo;
if (nodeMethodInfo == null)
{
routine.RemoveNode(routine.finalNode);
return;
}
NodeMethodAttribute nodeMethodAttribute = routine.finalNode.nodeMethodAttribute;
if (nodeMethodAttribute == null)
{
routine.RemoveNode(routine.finalNode);
return;
}
routineIcon = GetCategoryIcon(nodeMethodAttribute.category);
}
GUIContent routineNameGUIContent = new GUIContent(routine.name, routineIcon);
float width = topPanelRect.width;
Color routineColor = (routine == m_selectedRoutine) ? s_topPanelSelectedRoutineColor : s_topPanelRoutineColor;
Rect routineRect = new Rect(16, rectOffset, width - 18, 18);
EditorGUI.DrawRect(routineRect, routineColor);
routineRect.position += Vector2.one * 2;
routineRect.size -= Vector2.one * 4;
EditorGUI.DrawRect(routineRect, Color.Lerp(routineColor, s_sidePanelsColor, 0.7f));
switch (DrawLabeledIconButtons(routineNameGUIContent, false, ButtonAnswer.Modify, ButtonAnswer.Duplicate, ButtonAnswer.MoveDown, ButtonAnswer.MoveUp, ButtonAnswer.Delete))
{
case ButtonAnswer.Modify:
if (m_selectedRoutine != routine)
{
GUI.FocusControl("Dummy");
}
m_selectedRoutine = routine;
break;
case ButtonAnswer.Duplicate:
m_selectedTrigger.DuplicateRoutine(routine);
SetSceneDirty();
break;
case ButtonAnswer.MoveDown:
m_selectedTrigger.SwapRoutines(routineIndex, (routineIndex + 1) % m_selectedTrigger.GetRoutinesCount(routine.type), routine.type);
SetSceneDirty();
break;
case ButtonAnswer.MoveUp:
m_selectedTrigger.SwapRoutines(routineIndex, (routineIndex == 0) ? m_selectedTrigger.GetRoutinesCount(routine.type) - 1 : routineIndex - 1, routine.type);
SetSceneDirty();
break;
case ButtonAnswer.Delete:
if (routine == m_selectedRoutine)
{
m_selectedRoutine = null;
}
GUI.FocusControl("Dummy");
m_selectedTrigger.RemoveRoutine(routine);
SetSceneDirty();
break;
}
GUILayout.Space(2);
}
