public static SkillInt FsmIntPopup(GUIContent label, Skill fsm, SkillInt fsmInt)
{
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
fsmInt = VariableEditor.DoFsmIntPopup(label, fsm, fsmInt);
VariableEditor.EndVariableEditor(fsmInt);
return(fsmInt);
}
public static SkillInt FsmIntField(GUIContent label, Skill fsm, SkillInt fsmInt, object[] attributes)
{
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (fsmInt.get_UseVariable())
{
fsmInt = VariableEditor.DoFsmIntPopup(label, fsm, fsmInt);
}
else
{
UIHint uIHint = CustomAttributeHelpers.GetUIHint(attributes);
UIHint uIHint2 = uIHint;
if (uIHint2 == 8)
{
fsmInt.set_Value(EditorGUILayout.LayerField(label, Convert.ToInt32(fsmInt.get_Value(), CultureInfo.get_CurrentCulture()), new GUILayoutOption[0]));
}
else
{
fsmInt.set_Value(EditorGUILayout.IntField(label, fsmInt.get_Value(), new GUILayoutOption[0]));
}
}
fsmInt = (SkillInt)VariableEditor.VariableToggle(fsmInt, label.get_text());
VariableEditor.EndVariableEditor(fsmInt);
return(fsmInt);
}
private static void NetworkSyncVariables(BitStream stream, SkillVariables variables)
{
SkillInt[] intVariables;
SkillQuaternion[] quaternionVariables;
SkillVector3[] vector3Variables;
SkillColor[] colorVariables;
SkillVector2[] vector2Variables;
if (stream.get_isWriting())
{
SkillString[] stringVariables = variables.StringVariables;
for (int i = 0; i < stringVariables.Length; i++)
{
SkillString fsmString = stringVariables[i];
if (fsmString.NetworkSync)
{
char[] array = fsmString.Value.ToCharArray();
int num = array.Length;
stream.Serialize(ref num);
for (int j = 0; j < num; j++)
{
stream.Serialize(ref array[j]);
}
}
}
SkillBool[] boolVariables = variables.BoolVariables;
for (int k = 0; k < boolVariables.Length; k++)
{
SkillBool fsmBool = boolVariables[k];
if (fsmBool.NetworkSync)
{
bool value = fsmBool.Value;
stream.Serialize(ref value);
}
}
SkillFloat[] floatVariables = variables.FloatVariables;
for (int l = 0; l < floatVariables.Length; l++)
{
SkillFloat fsmFloat = floatVariables[l];
if (fsmFloat.NetworkSync)
{
float value2 = fsmFloat.Value;
stream.Serialize(ref value2);
}
}
intVariables = variables.IntVariables;
for (int m = 0; m < intVariables.Length; m++)
{
SkillInt fsmInt = intVariables[m];
if (fsmInt.NetworkSync)
{
int value3 = fsmInt.Value;
stream.Serialize(ref value3);
}
}
quaternionVariables = variables.QuaternionVariables;
for (int n = 0; n < quaternionVariables.Length; n++)
{
SkillQuaternion fsmQuaternion = quaternionVariables[n];
if (fsmQuaternion.NetworkSync)
{
Quaternion value4 = fsmQuaternion.Value;
stream.Serialize(ref value4);
}
}
vector3Variables = variables.Vector3Variables;
for (int num2 = 0; num2 < vector3Variables.Length; num2++)
{
SkillVector3 fsmVector = vector3Variables[num2];
if (fsmVector.NetworkSync)
{
Vector3 value5 = fsmVector.Value;
stream.Serialize(ref value5);
}
}
colorVariables = variables.ColorVariables;
for (int num3 = 0; num3 < colorVariables.Length; num3++)
{
SkillColor fsmColor = colorVariables[num3];
if (fsmColor.NetworkSync)
{
Color value6 = fsmColor.Value;
stream.Serialize(ref value6.r);
stream.Serialize(ref value6.g);
stream.Serialize(ref value6.b);
stream.Serialize(ref value6.a);
}
}
vector2Variables = variables.Vector2Variables;
for (int num4 = 0; num4 < vector2Variables.Length; num4++)
{
SkillVector2 fsmVector2 = vector2Variables[num4];
if (fsmVector2.NetworkSync)
{
Vector2 value7 = fsmVector2.Value;
stream.Serialize(ref value7.x);
stream.Serialize(ref value7.y);
}
}
return;
}
SkillString[] stringVariables2 = variables.StringVariables;
for (int num5 = 0; num5 < stringVariables2.Length; num5++)
{
SkillString fsmString2 = stringVariables2[num5];
if (fsmString2.NetworkSync)
{
int num6 = 0;
stream.Serialize(ref num6);
char[] array2 = new char[num6];
for (int num7 = 0; num7 < num6; num7++)
{
stream.Serialize(ref array2[num7]);
}
fsmString2.Value = new string(array2);
}
}
SkillBool[] boolVariables2 = variables.BoolVariables;
for (int num8 = 0; num8 < boolVariables2.Length; num8++)
{
SkillBool fsmBool2 = boolVariables2[num8];
if (fsmBool2.NetworkSync)
{
bool value8 = false;
stream.Serialize(ref value8);
fsmBool2.Value = value8;
}
}
SkillFloat[] floatVariables2 = variables.FloatVariables;
for (int i = 0; i < floatVariables2.Length; i++)
{
SkillFloat fsmFloat2 = floatVariables2[i];
if (fsmFloat2.NetworkSync)
{
float value9 = 0f;
stream.Serialize(ref value9);
fsmFloat2.Value = value9;
}
}
intVariables = variables.IntVariables;
for (int i = 0; i < intVariables.Length; i++)
{
SkillInt fsmInt2 = intVariables[i];
if (fsmInt2.NetworkSync)
{
int value10 = 0;
stream.Serialize(ref value10);
fsmInt2.Value = value10;
}
}
quaternionVariables = variables.QuaternionVariables;
for (int i = 0; i < quaternionVariables.Length; i++)
{
SkillQuaternion fsmQuaternion2 = quaternionVariables[i];
if (fsmQuaternion2.NetworkSync)
{
Quaternion identity = Quaternion.get_identity();
stream.Serialize(ref identity);
fsmQuaternion2.Value = identity;
}
}
vector3Variables = variables.Vector3Variables;
for (int i = 0; i < vector3Variables.Length; i++)
{
SkillVector3 fsmVector3 = vector3Variables[i];
if (fsmVector3.NetworkSync)
{
Vector3 zero = Vector3.get_zero();
stream.Serialize(ref zero);
fsmVector3.Value = zero;
}
}
colorVariables = variables.ColorVariables;
for (int i = 0; i < colorVariables.Length; i++)
{
SkillColor fsmColor2 = colorVariables[i];
if (fsmColor2.NetworkSync)
{
float num9 = 0f;
stream.Serialize(ref num9);
float num10 = 0f;
stream.Serialize(ref num10);
float num11 = 0f;
stream.Serialize(ref num11);
float num12 = 0f;
stream.Serialize(ref num12);
fsmColor2.Value = new Color(num9, num10, num11, num12);
}
}
vector2Variables = variables.Vector2Variables;
for (int i = 0; i < vector2Variables.Length; i++)
{
SkillVector2 fsmVector4 = vector2Variables[i];
if (fsmVector4.NetworkSync)
{
float num13 = 0f;
stream.Serialize(ref num13);
float num14 = 0f;
stream.Serialize(ref num14);
fsmVector4.Value = new Vector2(num13, num14);
}
}
}
private static SkillInt DoFsmIntPopup(GUIContent label, Skill fsm, SkillInt fsmInt)
{
ActionEditor.DoVariableSelector(label, fsm, 1, fsmInt, -1, null);
fsmInt.set_UseVariable(true);
return(fsmInt);
}
public static void OnGUI()
{
EditorGUI.BeginChangeCheck();
Skill fsm = SkillEditor.SelectedFsm;
if (fsm == null)
{
GUILayout.FlexibleSpace();
return;
}
if (!FsmInspector.isInitialized)
{
FsmInspector.isInitialized = true;
FsmInspector.Init();
}
FsmInspector.scrollViewPosition = GUILayout.BeginScrollView(FsmInspector.scrollViewPosition, new GUILayoutOption[0]);
EditorGUI.BeginChangeCheck();
fsm.set_Name(EditorGUILayout.TextField(fsm.get_Name(), new GUILayoutOption[0]));
if (EditorGUI.EndChangeCheck())
{
Labels.Update(fsm);
}
if (fsm.get_Owner() != null)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
SkillTemplate fsmTemplate = (SkillTemplate)EditorGUILayout.ObjectField(FsmInspector.SelectedTemplate, typeof(SkillTemplate), false, new GUILayoutOption[0]);
if (fsmTemplate != FsmInspector.SelectedTemplate)
{
FsmInspector.SelectTemplate(fsmTemplate);
}
if (GUILayout.Button(SkillEditorContent.BrowseTemplateButton, new GUILayoutOption[]
{
GUILayout.MaxWidth(30f),
GUILayout.Height(16f)
}))
{
Templates.DoSelectTemplateMenu(FsmInspector.SelectedTemplate, new GenericMenu.MenuFunction(FsmInspector.ClearTemplate), new GenericMenu.MenuFunction2(FsmInspector.SelectTemplate));
}
GUILayout.EndHorizontal();
}
EditorGUI.BeginDisabledGroup(!Application.get_isPlaying() && SkillEditor.SelectedFsmUsesTemplate);
if (fsm.get_Template() != null)
{
fsm = fsm.get_Template().fsm;
}
fsm.set_Description(SkillEditorGUILayout.TextAreaWithHint(fsm.get_Description(), Strings.get_Label_Description___(), new GUILayoutOption[]
{
GUILayout.MinHeight(80f)
}));
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
fsm.set_DocUrl(SkillEditorGUILayout.TextFieldWithHint(fsm.get_DocUrl(), Strings.get_Tooltip_Documentation_Url(), new GUILayoutOption[0]));
EditorGUI.BeginDisabledGroup(!string.IsNullOrEmpty(fsm.get_DocUrl()));
if (SkillEditorGUILayout.HelpButton("Online Help"))
{
Application.OpenURL(fsm.get_DocUrl());
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUI.BeginDisabledGroup(!Application.get_isPlaying() && SkillEditor.SelectedFsmUsesTemplate);
fsm.set_MaxLoopCountOverride(EditorGUILayout.IntField(SkillEditorContent.MaxLoopOverrideLabel, fsm.get_MaxLoopCountOverride(), new GUILayoutOption[0]));
fsm.RestartOnEnable = GUILayout.Toggle(fsm.RestartOnEnable, SkillEditorContent.ResetOnDisableLabel, new GUILayoutOption[0]);
EditorGUI.EndDisabledGroup();
EditorGUI.EndDisabledGroup();
fsm = SkillEditor.SelectedFsm;
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
GUILayout.Label(SkillEditorContent.FsmControlsLabel, EditorStyles.get_boldLabel(), new GUILayoutOption[0]);
if (fsm.ExposedEvents.get_Count() + FsmInspector.fsmVariables.get_Count() == 0)
{
SkillEditorGUILayout.DisabledLabel(Strings.get_Label_None_In_Table());
}
else
{
SkillEditorGUILayout.LabelWidth(100f);
int num = 0;
for (int i = 0; i < FsmInspector.fsmVariables.get_Count(); i++)
{
SkillVariable fsmVariable = FsmInspector.fsmVariables.get_Item(i);
if (fsmVariable.ShowInInspector)
{
int categoryID = fsmVariable.CategoryID;
if (categoryID > 0 && categoryID != num)
{
num = categoryID;
GUILayout.Label(SkillEditor.SelectedFsm.get_Variables().get_Categories()[categoryID], EditorStyles.get_boldLabel(), new GUILayoutOption[0]);
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
}
fsmVariable.DoInspectorGUI(SkillEditorContent.TempContent(fsmVariable.Name, fsmVariable.Name + ((!string.IsNullOrEmpty(fsmVariable.Tooltip)) ? (":\n" + fsmVariable.Tooltip) : "")), false);
}
}
using (List <SkillEvent> .Enumerator enumerator = fsm.ExposedEvents.GetEnumerator())
{
while (enumerator.MoveNext())
{
SkillEvent current = enumerator.get_Current();
if (GUILayout.Button(current.get_Name(), new GUILayoutOption[0]))
{
fsm.Event(current);
}
}
}
if (GUI.get_changed())
{
SkillEditor.RepaintAll();
}
}
if (FsmEditorSettings.ShowHints)
{
GUILayout.Box(Strings.get_Hint_Expose_Events_and_Variables(), SkillEditorStyles.HintBox, new GUILayoutOption[0]);
}
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
GUILayout.Label(SkillEditorContent.NetworkSyncLabel, EditorStyles.get_boldLabel(), new GUILayoutOption[0]);
int num2 = 0;
SkillBool[] boolVariables = fsm.get_Variables().get_BoolVariables();
for (int j = 0; j < boolVariables.Length; j++)
{
SkillBool fsmBool = boolVariables[j];
if (fsmBool.get_NetworkSync())
{
GUILayout.Label(fsmBool.get_Name(), new GUILayoutOption[0]);
num2++;
}
}
SkillFloat[] floatVariables = fsm.get_Variables().get_FloatVariables();
for (int k = 0; k < floatVariables.Length; k++)
{
SkillFloat fsmFloat = floatVariables[k];
if (fsmFloat.get_NetworkSync())
{
GUILayout.Label(fsmFloat.get_Name(), new GUILayoutOption[0]);
num2++;
}
}
SkillInt[] intVariables = fsm.get_Variables().get_IntVariables();
for (int l = 0; l < intVariables.Length; l++)
{
SkillInt fsmInt = intVariables[l];
if (fsmInt.get_NetworkSync())
{
GUILayout.Label(fsmInt.get_Name(), new GUILayoutOption[0]);
num2++;
}
}
SkillQuaternion[] quaternionVariables = fsm.get_Variables().get_QuaternionVariables();
for (int m = 0; m < quaternionVariables.Length; m++)
{
SkillQuaternion fsmQuaternion = quaternionVariables[m];
if (fsmQuaternion.get_NetworkSync())
{
GUILayout.Label(fsmQuaternion.get_Name(), new GUILayoutOption[0]);
num2++;
}
}
SkillVector3[] vector3Variables = fsm.get_Variables().get_Vector3Variables();
for (int n = 0; n < vector3Variables.Length; n++)
{
SkillVector3 fsmVector = vector3Variables[n];
if (fsmVector.get_NetworkSync())
{
GUILayout.Label(fsmVector.get_Name(), new GUILayoutOption[0]);
num2++;
}
}
if (num2 == 0)
{
SkillEditorGUILayout.DisabledLabel(Strings.get_Label_None_In_Table());
}
if (FsmEditorSettings.ShowHints)
{
GUILayout.Box(Strings.get_Hint_Network_Sync_Variables(), SkillEditorStyles.HintBox, new GUILayoutOption[0]);
}
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
GUILayout.Label("Debug", EditorStyles.get_boldLabel(), new GUILayoutOption[0]);
fsm.set_ShowStateLabel(GUILayout.Toggle(fsm.get_ShowStateLabel(), SkillEditorContent.ShowStateLabelsLabel, new GUILayoutOption[0]));
fsm.EnableBreakpoints = GUILayout.Toggle(fsm.EnableBreakpoints, SkillEditorContent.EnableBreakpointsLabel, new GUILayoutOption[0]);
fsm.EnableDebugFlow = GUILayout.Toggle(fsm.EnableDebugFlow, SkillEditorContent.EnableDebugFlowLabel, new GUILayoutOption[0]);
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
GUILayout.Label("Experimental", EditorStyles.get_boldLabel(), new GUILayoutOption[0]);
EditorGUILayout.HelpBox(Strings.get_Help_Experimental_Warning(), 0);
fsm.set_KeepDelayedEventsOnStateExit(GUILayout.Toggle(fsm.get_KeepDelayedEventsOnStateExit(), SkillEditorContent.KeepDelayedEvents, new GUILayoutOption[0]));
fsm.set_ManualUpdate(GUILayout.Toggle(fsm.get_ManualUpdate(), SkillEditorContent.ManualUpdate, new GUILayoutOption[0]));
GUILayout.EndScrollView();
EventType arg_641_0 = Event.get_current().get_type();
if (EditorGUI.EndChangeCheck())
{
SkillEditor.SetFsmDirty(false, false);
}
if (Event.get_current().get_type() == null)
{
GUIUtility.set_keyboardControl(0);
}
SkillEditorGUILayout.LightDivider(new GUILayoutOption[0]);
EditorGUI.BeginDisabledGroup(true);
GUILayout.Label("Data Version: " + fsm.get_DataVersion(), EditorStyles.get_miniLabel(), new GUILayoutOption[0]);
EditorGUI.EndDisabledGroup();
SkillEditorGUILayout.LockFsmGUI(fsm);
}
