private static void TransitionTools()
{
ToolWindow.Header(Strings.get_ToolWindow_Header_Transition_Tools());
SkillState selectedState = SkillEditor.SelectedState;
SkillTransition selectedTransition = SkillEditor.SelectedTransition;
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Label(Strings.get_Label_Event(), new GUILayoutOption[]
{
GUILayout.MaxWidth(40f)
});
if (GUILayout.Button(Labels.GetEventLabel(selectedTransition), EditorStyles.get_popup(), new GUILayoutOption[0]))
{
ToolWindow.editingTransition = selectedTransition;
SkillEditorGUILayout.GenerateEventSelectionMenu(SkillEditor.SelectedFsm, selectedTransition.get_FsmEvent(), new GenericMenu.MenuFunction2(ToolWindow.SelectEvent), new GenericMenu.MenuFunction(SkillEditor.OpenEventManager)).ShowAsContext();
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Label(Strings.get_Label_State(), new GUILayoutOption[]
{
GUILayout.MaxWidth(40f)
});
if (GUILayout.Button(Labels.GetStateLabel(selectedTransition.get_ToState()), EditorStyles.get_popup(), new GUILayoutOption[0]))
{
ToolWindow.editingTransition = selectedTransition;
SkillEditorGUILayout.GenerateStateSelectionMenu(SkillEditor.SelectedFsm, selectedTransition.get_ToState(), new GenericMenu.MenuFunction2(ToolWindow.SelectToState)).ShowAsContext();
}
GUILayout.EndHorizontal();
if (GUILayout.Button(Strings.get_Command_Delete(), new GUILayoutOption[0]))
{
EditorCommands.DeleteTransition(selectedState, selectedTransition);
SkillEditor.Selection.SelectTransition(null);
SkillEditor.RepaintAll();
}
}
private static void CheckSystemEventsForErrors(SkillState state, SkillTransition transition, SkillEvent fsmEvent)
{
GameObject gameObject = state.get_Fsm().get_GameObject();
if (gameObject == null)
{
return;
}
if (FsmEditorSettings.CheckForMouseEventErrors && fsmEvent.get_Name().Contains("MOUSE") && gameObject.GetComponent <Collider>() == null && gameObject.GetComponent <GUIElement>() == null)
{
FsmErrorChecker.AddError(state, transition, Strings.get_FsmErrorChecker_MouseEventsNeedCollider());
}
if ((FsmEditorSettings.CheckForCollisionEventErrors && fsmEvent.get_Name().Contains("COLLISION")) || fsmEvent.get_Name().Contains("TRIGGER"))
{
if (fsmEvent.get_Name().Contains("2D"))
{
if (gameObject.GetComponent <Collider2D>() == null && gameObject.GetComponent <Rigidbody2D>() == null)
{
FsmErrorChecker.AddError(state, transition, Strings.get_FsmErrorChecker_CollisionEventsNeedCollider2D());
}
}
else
{
if (gameObject.GetComponent <Collider>() == null && gameObject.GetComponent <Rigidbody>() == null)
{
FsmErrorChecker.AddError(state, transition, Strings.get_FsmErrorChecker_CollisionEventsNeedCollider());
}
}
}
if (FsmEditorSettings.CheckForCollisionEventErrors && fsmEvent.get_Name().Contains("CONTROLLER COLLIDER") && gameObject.GetComponent <CharacterController>() == null)
{
FsmErrorChecker.AddError(state, transition, Strings.get_FsmErrorChecker_ControllerCollisionEventsNeedController());
}
}
public FsmError(SkillState state, SkillTransition transition, string errorString)
{
this.State = state;
this.Fsm = state.get_Fsm();
this.Transition = transition;
this.ErrorString = errorString;
}
public static bool FsmStateRespondsToEvent(SkillState state, SkillEvent fsmEvent)
{
if (SkillEvent.IsNullOrEmpty(fsmEvent))
{
return(false);
}
SkillTransition[] globalTransitions = state.get_Fsm().get_GlobalTransitions();
for (int i = 0; i < globalTransitions.Length; i++)
{
SkillTransition fsmTransition = globalTransitions[i];
if (fsmTransition.get_EventName() == fsmEvent.get_Name())
{
bool result = true;
return(result);
}
}
SkillTransition[] transitions = state.get_Transitions();
for (int j = 0; j < transitions.Length; j++)
{
SkillTransition fsmTransition2 = transitions[j];
if (fsmTransition2.get_EventName() == fsmEvent.get_Name())
{
bool result = true;
return(result);
}
}
return(false);
}
public static bool FsmRespondsToEvent(Skill fsm, string fsmEventName)
{
if (fsm == null || string.IsNullOrEmpty(fsmEventName))
{
return(false);
}
SkillTransition[] globalTransitions = fsm.get_GlobalTransitions();
for (int i = 0; i < globalTransitions.Length; i++)
{
SkillTransition fsmTransition = globalTransitions[i];
if (fsmTransition.get_EventName() == fsmEventName)
{
bool result = true;
return(result);
}
}
SkillState[] states = fsm.get_States();
for (int j = 0; j < states.Length; j++)
{
SkillState fsmState = states[j];
SkillTransition[] transitions = fsmState.get_Transitions();
for (int k = 0; k < transitions.Length; k++)
{
SkillTransition fsmTransition2 = transitions[k];
if (fsmTransition2.get_EventName() == fsmEventName)
{
bool result = true;
return(result);
}
}
}
return(false);
}
public static void SetTransitionTarget(SkillTransition transition, string toState)
{
SkillEditor.RegisterUndo(Strings.get_Command_Set_Transition_Target());
SkillEditor.Builder.SetTransitionTarget(transition, toState);
SkillSearch.Update(SkillEditor.SelectedFsm);
SkillEditor.SetFsmDirty(true, false);
}
private static void CheckTransitionsForErrors(SkillState state)
{
List <string> list = new List <string>();
SkillTransition[] transitions = state.get_Transitions();
for (int i = 0; i < transitions.Length; i++)
{
SkillTransition fsmTransition = transitions[i];
if (FsmEditorSettings.CheckForTransitionMissingEvent && string.IsNullOrEmpty(fsmTransition.get_EventName()))
{
FsmErrorChecker.AddError(state, fsmTransition, Strings.get_FsmErrorChecker_TransitionMissingEventError());
}
if (FsmEditorSettings.CheckForDuplicateTransitionEvent && list.Contains(fsmTransition.get_EventName()))
{
FsmErrorChecker.AddError(state, fsmTransition, Strings.get_FsmErrorChecker_DuplicateTransitionEventError());
}
if (!string.IsNullOrEmpty(fsmTransition.get_EventName()))
{
list.Add(fsmTransition.get_EventName());
}
if (FsmEditorSettings.CheckForTransitionMissingTarget && string.IsNullOrEmpty(fsmTransition.get_ToState()))
{
FsmErrorChecker.AddError(state, fsmTransition, Strings.get_FsmErrorChecker_TransitionMissingTargetError());
}
if (state.get_Fsm() != null)
{
SkillEvent fsmEvent = fsmTransition.get_FsmEvent();
if (fsmEvent != null && fsmEvent.get_IsSystemEvent())
{
FsmErrorChecker.CheckSystemEventsForErrors(state, fsmTransition, fsmEvent);
}
}
}
}
public static void DeleteTransition(SkillState state, SkillTransition transition)
{
SkillEditor.RegisterUndo(Strings.get_Menu_Delete_Transition());
SkillEditor.Builder.DeleteTransition(state, transition);
SkillEditor.GraphView.UpdateStateSize(state);
SkillSearch.Update(state.get_Fsm());
SkillEditor.SetFsmDirty(state.get_Fsm(), true, false, true);
}
public static void SetTransitionEvent(SkillTransition transition, SkillEvent fsmEvent)
{
SkillEditor.RegisterUndo(Strings.get_Command_Set_Transition_Event());
SkillEditor.Builder.SetTransitionEvent(transition, fsmEvent);
SkillEditor.GraphView.UpdateStateSize(SkillEditor.SelectedState);
SkillSearch.Update(SkillEditor.SelectedFsm);
SkillEditor.SetFsmDirty(true, false);
}
public SkillTransition SelectTransition(SkillTransition transition)
{
if (this.ActiveState == null)
{
return(null);
}
this.ActiveTransition = transition;
return(transition);
}
public void SanityCheck()
{
if (this.fsmComponent != null)
{
PlayMakerFSM[] components = this.fsmComponent.get_gameObject().GetComponents <PlayMakerFSM>();
PlayMakerFSM[] array = components;
for (int i = 0; i < array.Length; i++)
{
PlayMakerFSM playMakerFSM = array[i];
if (this.fsmComponent == playMakerFSM)
{
this.ActiveFsm = playMakerFSM.get_Fsm();
this.fsmComponent = playMakerFSM;
break;
}
}
}
else
{
if (this.fsmTemplate != null)
{
this.ActiveFsm = this.fsmTemplate.fsm;
}
}
if (this.ActiveFsm != null)
{
SkillState[] array2 = this.ActiveFsm.get_States();
for (int j = 0; j < array2.Length; j++)
{
SkillState fsmState = array2[j];
fsmState.set_Fsm(this.ActiveFsm);
}
this.activeState = this.ActiveFsm.GetState(this.stateName);
this.states = new List <SkillState>();
using (List <string> .Enumerator enumerator = this.StateNames.GetEnumerator())
{
while (enumerator.MoveNext())
{
string current = enumerator.get_Current();
this.states.Add(this.ActiveFsm.GetState(current));
}
goto IL_137;
}
}
this.activeState = null;
this.states = new List <SkillState>();
IL_137:
this.activeTransition = ((this.activeState != null) ? this.activeState.GetTransition(this.transitionIndex) : null);
if (!SkillEditor.FsmContainsState(this.ActiveFsm, this.activeState))
{
this.activeState = null;
}
if (!SkillEditor.StateContainsTransition(this.activeState, this.activeTransition))
{
this.activeTransition = null;
}
}
public static SkillTransition AddGlobalTransition(SkillState state, SkillEvent fsmEvent)
{
SkillEditor.RegisterUndo(Strings.get_Command_Add_Global_Transition());
SkillTransition result = SkillEditor.Builder.AddGlobalTransition(state, fsmEvent);
SkillEditor.GraphView.UpdateStateSize(state);
SkillSearch.Update(state.get_Fsm());
SkillEditor.SetFsmDirty(state.get_Fsm(), true, false, true);
return(result);
}
public static DrawState GetFsmTransitionDrawState(Skill fsm, SkillTransition transition, bool selected)
{
bool active = false;
if (fsm.get_SwitchedState() || Skill.get_BreakAtFsm() == fsm)
{
active = (fsm.get_LastTransition() == transition && fsm.get_Active());
}
return(FsmDrawState.GetDrawState(fsm, selected, active, false, false));
}
public static GUIContent GetEventLabel(SkillTransition transition)
{
SkillEditorContent.EventLabel.set_text("...");
SkillEditorContent.EventLabel.set_tooltip("");
if (!SkillEvent.IsNullOrEmpty(transition.get_FsmEvent()))
{
SkillEditorContent.EventLabel.set_text(transition.get_FsmEvent().get_Name());
}
return(SkillEditorContent.EventLabel);
}
public static void AddTransitionToState(SkillState state, string eventName = "")
{
SkillEditor.RegisterUndo(Strings.get_Command_Add_Transition());
SkillTransition fsmTransition = SkillEditor.Builder.AddTransition(SkillEditor.SelectedState);
fsmTransition.set_FsmEvent(SkillEvent.GetFsmEvent(eventName));
SkillEditor.Selection.SelectTransition(fsmTransition);
SkillEditor.GraphView.UpdateStateSize(SkillEditor.SelectedState);
SkillSearch.Update(SkillEditor.SelectedFsm);
SkillEditor.SetFsmDirty(true, false);
}
public static void DeleteGlobalTransition(SkillTransition transition)
{
SkillEditor.RegisterUndo(Strings.get_Command_Delete_Global_Transition());
SkillState transitionState = SkillBuilder.GetTransitionState(SkillEditor.SelectedFsm, transition);
SkillEditor.Builder.DeleteGlobalTransition(transition);
SkillSearch.Update(SkillEditor.SelectedFsm);
SkillEditor.GraphView.UpdateStateSize(transitionState);
SkillEditor.SetFsmDirty(true, false);
Keyboard.ResetFocus();
}
private void FindEventUsage(SkillState state)
{
SkillTransition[] transitions = state.get_Transitions();
for (int i = 0; i < transitions.Length; i++)
{
SkillTransition fsmTransition = transitions[i];
if (fsmTransition.get_EventName() != string.Empty)
{
this.GetEventUsageList(fsmTransition.get_EventName()).Add(new SkillInfo
{
fsm = this.fsm,
state = state,
transition = fsmTransition
});
}
}
}
public static List <string> GetTransitionErrors(SkillTransition transition)
{
List <string> list = new List <string>();
using (List <FsmError> .Enumerator enumerator = FsmErrorChecker.FsmErrorList.GetEnumerator())
{
while (enumerator.MoveNext())
{
FsmError current = enumerator.get_Current();
if (current.Transition == transition)
{
list.Add(current.ErrorString);
}
}
}
return(list);
}
private void FindEventsInGlobalTransitions()
{
if (this.fsm == null)
{
return;
}
SkillTransition[] globalTransitions = this.fsm.get_GlobalTransitions();
for (int i = 0; i < globalTransitions.Length; i++)
{
SkillTransition fsmTransition = globalTransitions[i];
if (fsmTransition.get_EventName() != string.Empty)
{
this.GetEventUsageList(fsmTransition.get_EventName()).Add(new SkillInfo
{
fsm = this.fsm,
state = this.fsm.GetState(fsmTransition.get_ToState()),
transition = fsmTransition
});
}
}
}
public static List <SkillInfo> FindTransitionsUsingEvent(Skill fsm, string eventName)
{
List <SkillInfo> list = new List <SkillInfo>();
SkillState[] states = fsm.get_States();
for (int i = 0; i < states.Length; i++)
{
SkillState fsmState = states[i];
SkillTransition[] transitions = fsmState.get_Transitions();
for (int j = 0; j < transitions.Length; j++)
{
SkillTransition fsmTransition = transitions[j];
if (fsmTransition.get_EventName() == eventName)
{
list.Add(new SkillInfo
{
fsm = fsm,
state = fsmState,
transition = fsmTransition
});
}
}
}
SkillTransition[] globalTransitions = fsm.get_GlobalTransitions();
for (int k = 0; k < globalTransitions.Length; k++)
{
SkillTransition fsmTransition2 = globalTransitions[k];
if (fsmTransition2.get_EventName() == eventName)
{
list.Add(new SkillInfo
{
fsm = fsm,
state = fsm.GetState(fsmTransition2.get_ToState()),
transition = fsmTransition2
});
}
}
return(list);
}
public static void Draw(SkillState fromState, SkillState toState, int transitionIndex, Color linkColor, float linkWidth, Texture leftArrow, Texture rightArrow, float scale)
{
SkillTransition fsmTransition = fromState.get_Transitions()[transitionIndex];
SkillTransition.CustomLinkConstraint linkConstraint = fsmTransition.get_LinkConstraint();
float stateRowHeight = SkillEditorStyles.StateRowHeight;
float num = stateRowHeight * 0.5f;
Rect rect = SkillEditor.GraphView.ScaleRect(fromState.get_Position());
Rect rect2 = SkillEditor.GraphView.ScaleRect(toState.get_Position());
float num2 = rect.get_y() + (float)(transitionIndex + 1) * stateRowHeight + num;
float num3 = rect2.get_y() + num;
float num4 = rect.get_x() - 1f;
float num5 = num4 + rect.get_width() + 2f;
float num6 = rect2.get_x() - 1f;
float num7 = num6 + rect2.get_width() + 2f;
Vector3 vector = new Vector3(0f, num2, 0f);
Vector3 vector2 = new Vector3(0f, num3, 0f);
Vector3 vector3 = vector;
Vector3 vector4 = vector2;
float num8 = Mathf.Abs(num2 - num3) * 0.4f;
num8 = Mathf.Clamp(num8, 30f, 48f) * scale;
float num9 = 30f * scale;
bool flag = false;
switch (linkConstraint)
{
case 0:
if (num7 + num9 < num4 - num9)
{
vector.x = num4;
vector2.x = num7;
float num10 = vector.x - num8;
float num11 = vector2.x + num8;
vector3.x = num10 + (num11 - num10) * 0.3f;
vector4.x = vector3.x;
flag = true;
}
else
{
if (num6 < num4)
{
vector.x = num4;
vector2.x = num6;
float num12 = vector.x - num8;
float num13 = vector2.x - num8;
vector3.x = Mathf.Min(num12, num13);
vector4.x = vector3.x;
}
else
{
if (num6 - num9 > num5 + num9)
{
vector.x = num5;
vector2.x = num6;
float num14 = vector.x + num8;
float num15 = vector2.x - num8;
vector3.x = num14 + (num15 - num14) * 0.3f;
vector4.x = vector3.x;
}
else
{
vector.x = num5;
vector2.x = num7;
float num16 = vector.x + num8;
float num17 = vector2.x + num8;
vector3.x = Mathf.Max(num16, num17);
vector4.x = vector3.x;
flag = true;
}
}
}
break;
case 1:
if (num7 < num4)
{
vector.x = num4;
vector2.x = num7;
float num18 = vector.x - num8;
float num19 = vector2.x + num8;
vector3.x = num18 + (num19 - num18) * 0.3f;
vector4.x = vector3.x;
flag = true;
}
else
{
vector.x = num4;
vector2.x = num6;
float num20 = vector.x - num8;
float num21 = vector2.x - num8;
vector3.x = Mathf.Min(num20, num21);
vector4.x = vector3.x;
}
break;
default:
if (num6 > num5)
{
vector.x = num5;
vector2.x = num6;
float num22 = vector.x + num8;
float num23 = vector2.x - num8;
vector3.x = num22 + (num23 - num22) * 0.3f;
vector4.x = vector3.x;
}
else
{
vector.x = num5;
vector2.x = num7;
float num24 = vector.x + num8;
float num25 = vector2.x + num8;
vector3.x = Mathf.Max(num24, num25);
vector4.x = vector3.x;
flag = true;
}
break;
}
CircuitLink.DrawLine(vector, vector3, linkColor, linkWidth);
CircuitLink.DrawLine(vector4, vector2, linkColor, linkWidth);
float y = Mathf.Max(vector3.y, vector4.y) + 1f;
float y2 = Mathf.Min(vector3.y, vector4.y) - 1f;
vector3.y = y;
vector4.y = y2;
CircuitLink.DrawLine(vector3, vector4, linkColor, linkWidth);
if (!flag)
{
leftArrow = rightArrow;
vector2.x -= (float)leftArrow.get_width() * scale;
}
Link.DrawArrowHead(leftArrow, vector2, linkColor, false, scale);
}
public bool Contains(SkillTransition testTransition)
{
return(this.ActiveTransition == testTransition);
}
public static GUIContent GetEventLabel(SkillTransition transition)
{
return(Labels.GetEventLabel(transition));
}
public static void Draw(SkillState fromState, SkillState toState, int transitionIndex, Color linkColor, float linkWidth, Texture leftArrow, Texture rightArrow, float scale)
{
SkillTransition fsmTransition = fromState.get_Transitions()[transitionIndex];
SkillTransition.CustomLinkConstraint linkConstraint = fsmTransition.get_LinkConstraint();
float stateRowHeight = SkillEditorStyles.StateRowHeight;
float num = stateRowHeight * 0.5f;
Rect rect = SkillEditor.GraphView.ScaleRect(fromState.get_Position());
Rect rect2 = SkillEditor.GraphView.ScaleRect(toState.get_Position());
float num2 = rect.get_y() + (float)(transitionIndex + 1) * stateRowHeight + num;
float num3 = rect2.get_y() + num;
float num4 = rect.get_x() - 1f;
float num5 = num4 + rect.get_width() + 2f;
float num6 = rect2.get_x() - 1f;
float num7 = num6 + rect2.get_width() + 2f;
Vector3 vector = new Vector3(0f, num2, 0f);
Vector3 vector2 = new Vector3(0f, num3, 0f);
float num8 = (float)leftArrow.get_width() * scale;
float num9;
float num10;
switch (linkConstraint)
{
case 0:
if (num7 < num4)
{
vector.x = num4;
vector2.x = num7 + num8;
num9 = -1f;
num10 = 1f;
}
else
{
if (num6 < num4)
{
vector.x = num4;
vector2.x = num6 - num8;
num9 = -1f;
num10 = -1f;
}
else
{
if (num6 > num5)
{
vector.x = num5;
vector2.x = num6 - num8;
num9 = 1f;
num10 = -1f;
}
else
{
vector.x = num5;
vector2.x = num7 + num8;
num9 = 1f;
num10 = 1f;
}
}
}
break;
case 1:
if (num7 < num4)
{
vector.x = num4;
vector2.x = num7 + num8;
num9 = -1f;
num10 = 1f;
}
else
{
vector.x = num4;
vector2.x = num6 - num8;
num9 = -1f;
num10 = -1f;
}
break;
default:
if (num6 > num5)
{
vector.x = num5;
vector2.x = num6 - num8;
num9 = 1f;
num10 = -1f;
}
else
{
vector.x = num5;
vector2.x = num7 + num8;
num9 = 1f;
num10 = 1f;
}
break;
}
float num11 = (vector - vector2).get_magnitude() * 0.5f * scale;
float num12 = Mathf.Min(num11, 40f);
if (fromState == toState)
{
num12 = 50f * scale;
}
Vector3 vector3 = vector;
vector3.x += num9 * num12;
Vector3 vector4 = vector2;
vector4.x += num10 * num12;
Handles.DrawBezier(vector, vector2, vector3, vector4, linkColor, SkillEditorStyles.LineTexture, linkWidth * 2f);
vector2.x -= num10 * num8;
Color color = GUI.get_color();
GUI.set_color(Color.get_red());
if (num10 != 1f)
{
leftArrow = rightArrow;
vector2.x -= num8;
}
Link.DrawArrowHead(leftArrow, vector2, linkColor, false, scale);
GUI.set_color(color);
}
private static void StateTools()
{
ToolWindow.Header(Strings.get_ToolWindow_Header_State_Tools());
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (GUILayout.Button(Strings.get_Command_Copy(), new GUILayoutOption[0]))
{
EditorCommands.CopyStateSelection();
}
EditorGUI.BeginDisabledGroup(!SkillEditor.Builder.CanPaste());
if (GUILayout.Button(Strings.get_Command_Paste(), new GUILayoutOption[0]))
{
EditorCommands.PasteStates(FsmGraphView.GetViewCenter());
SkillEditor.RepaintAll();
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button(Strings.get_Command_Delete(), new GUILayoutOption[0]))
{
SkillEditor.RepaintAll();
EditorCommands.DeleteMultiSelection();
}
GUILayout.EndHorizontal();
if (GUILayout.Button(Strings.get_Command_Save_Selection_as_Template(), new GUILayoutOption[0]))
{
EditorCommands.SaveSelectionAsTemplate();
}
if (GUILayout.Button(Strings.get_Command_Set_As_Start_State(), new GUILayoutOption[0]))
{
EditorCommands.SetSelectedStateAsStartState();
SkillEditor.RepaintAll();
}
if (GUILayout.Button(Strings.get_Command_Toggle_Breakpoint(), new GUILayoutOption[0]))
{
EditorCommands.ToggleBreakpointOnSelectedState();
SkillEditor.RepaintAll();
}
ToolWindow.Divider(Strings.get_ToolWindow_Header_Transitions());
if (GUILayout.Button(Strings.get_Command_Add_Transition(), new GUILayoutOption[0]))
{
EditorCommands.AddTransitionToSelectedState();
SkillEditor.RepaintAll();
}
if (GUILayout.Button(Strings.get_Command_Add_Global_Transition(), new GUILayoutOption[0]))
{
EditorCommands.AddGlobalTransitionToSelectedState();
SkillEditor.RepaintAll();
}
if (!SkillEditor.Builder.HasGlobalTransition(SkillEditor.SelectedState))
{
return;
}
ToolWindow.Divider(Strings.get_ToolWindow_Header_Global_Transitions());
SkillState selectedState = SkillEditor.SelectedState;
SkillTransition[] globalTransitions = SkillEditor.SelectedFsm.get_GlobalTransitions();
for (int i = 0; i < globalTransitions.Length; i++)
{
SkillTransition fsmTransition = globalTransitions[i];
if (!(fsmTransition.get_ToState() != selectedState.get_Name()))
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (GUILayout.Button(Labels.GetEventLabel(fsmTransition), EditorStyles.get_popup(), new GUILayoutOption[]
{
GUILayout.MinWidth(140f)
}))
{
ToolWindow.editingTransition = fsmTransition;
SkillEditorGUILayout.GenerateEventSelectionMenu(SkillEditor.SelectedFsm, fsmTransition.get_FsmEvent(), new GenericMenu.MenuFunction2(ToolWindow.SelectGlobalTransitionEvent), new GenericMenu.MenuFunction(SkillEditor.OpenEventManager)).ShowAsContext();
}
if (SkillEditorGUILayout.DeleteButton())
{
EditorCommands.DeleteGlobalTransition(fsmTransition);
SkillEditor.RepaintAll();
}
GUILayout.EndHorizontal();
}
}
}
private static FsmError AddError(SkillState state, SkillTransition transition, string error)
{
return(FsmErrorChecker.AddError(new FsmError(state, transition, error)));
}
