public static void Stop()
{
if (!DebugFlow.Active || !Application.get_isPlaying())
{
return;
}
DebugFlow.SelectedLogEntry = null;
DebugFlow.Active = false;
List <Skill> list = new List <Skill>(SkillEditor.FsmList);
using (List <Skill> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
Skill current = enumerator.get_Current();
if (current != null && current.EnableDebugFlow)
{
SkillVariables fsmVariables;
DebugFlow.variablesCache.TryGetValue(current, ref fsmVariables);
if (fsmVariables != null)
{
current.get_Variables().ApplyVariableValues(fsmVariables);
}
else
{
Debug.LogWarning("DebugFlow: Missing Cached Variables...");
}
}
}
}
SkillVariables.get_GlobalVariables().ApplyVariableValues(DebugFlow.globalVariablesCache);
DebugFlow.variablesCache.Clear();
DebugFlow.globalVariablesCache = null;
}
private void MoveToGlobals(object userdata)
{
SkillVariable fsmVariable = userdata as SkillVariable;
if (fsmVariable != null && fsmVariable.NamedVar != null)
{
if (SkillVariables.get_GlobalVariables().Contains(fsmVariable.Name))
{
NamedVariable variable = SkillVariables.get_GlobalVariables().GetVariable(fsmVariable.Name);
if (variable.get_VariableType() != fsmVariable.NamedVar.get_VariableType())
{
Dialogs.OkDialog(Strings.get_Dialog_Make_Global_Variable(), Strings.get_VariableManager_MoveToGlobals_Warning());
return;
}
if (Dialogs.YesNoDialog(Strings.get_Dialog_Make_Global_Variable(), Strings.get_VariableManager_MoveToGlobals_Confirm()))
{
this.RemoveLocalVariable(fsmVariable);
return;
}
}
else
{
if (Dialogs.AreYouSure(Strings.get_Dialog_Make_Global_Variable()))
{
SkillVariable.AddVariable(SkillVariables.get_GlobalVariables(), fsmVariable.NamedVar.Clone());
this.RemoveLocalVariable(fsmVariable);
}
}
}
}
public static void Cleanup()
{
DebugFlow.variablesCache.Clear();
DebugFlow.globalVariablesCache = null;
DebugFlow.SelectedLog = null;
DebugFlow.SelectedLogEntry = null;
DebugFlow.DebugState = null;
DebugFlow.lastEnter = null;
}
public override void DoGUI()
{
this.fsmVariablesEditor.SetTarget(SkillVariables.get_GlobalsComponent());
this.fsmVariablesEditor.OnGUI();
if (GUILayout.Button(new GUIContent(Strings.get_GlobalVariablesWindow_Refresh_Used_Count_In_This_Scene(), Strings.get_GlobalVariablesWindow_Refresh_Tooltip()), new GUILayoutOption[0]))
{
SkillSearch.UpdateAll();
}
EditorGUILayout.HelpBox(Strings.get_GlobalVariablesWindow_Note_Asset_Location(), 1);
}
private void RemoveUnusedCategories(SkillVariables variables, List <SkillVariable> fsmVariables)
{
List <string> usedVariableCategories = FsmVariablesEditor.GetUsedVariableCategories(fsmVariables);
usedVariableCategories.Add("");
List <string> list = new List <string>(variables.get_Categories());
list.Sort();
variables.set_Categories(Enumerable.ToArray <string>(Enumerable.Where <string>(list, new Func <string, bool>(usedVariableCategories.Contains))));
SkillVariable.RemapVariableCategories(variables, fsmVariables);
}
private static void RefreshTemplate()
{
if (FsmInspector.SelectedTemplate == null || Application.get_isPlaying())
{
return;
}
SkillVariables fsmVariables = new SkillVariables(SkillEditor.SelectedFsm.get_Variables());
SkillEditor.SelectedFsmComponent.SetFsmTemplate(FsmInspector.SelectedTemplate);
SkillEditor.SelectedFsm.get_Variables().OverrideVariableValues(fsmVariables);
FsmInspector.BuildFsmVariableList(SkillEditor.SelectedFsm);
}
public void SetTarget(Object newOwner)
{
if (newOwner == this.owner)
{
return;
}
this.owner = newOwner;
this.target = SkillVariable.GetVariables(this.owner);
this.editingGlobalVariables = (newOwner is PlayMakerGlobals);
this.editingAsset = (this.editingGlobalVariables || newOwner is SkillTemplate);
this.Reset();
}
public override void Initialize()
{
this.isToolWindow = true;
GlobalVariablesWindow.instance = this;
this.InitWindowTitle();
base.set_minSize(new Vector2(200f, 200f));
this.fsmVariablesEditor = new FsmVariablesEditor(this, SkillVariables.get_GlobalsComponent());
FsmVariablesEditor expr_3F = this.fsmVariablesEditor;
expr_3F.SettingsButtonClicked = (EditorApplication.CallbackFunction)Delegate.Combine(expr_3F.SettingsButtonClicked, new EditorApplication.CallbackFunction(this.DoSettingsMenu));
FsmVariablesEditor expr_66 = this.fsmVariablesEditor;
expr_66.VariableContextClicked = (FsmVariablesEditor.ContextClickVariable)Delegate.Combine(expr_66.VariableContextClicked, new FsmVariablesEditor.ContextClickVariable(GlobalVariablesWindow.DoVariableContextMenu));
}
private void Init(string windowTitle, SkillVariables variables, string variableName)
{
this.titleLabel = windowTitle;
this.fsmVariables = variables;
this.editField = new TextField(this, GUIContent.none, "");
this.editField.Focus();
this.editField.EditCommited = new TextField.EditCommitedCallback(this.Commit);
this.editField.EditCanceled = new TextField.EditingCancelledCallback(this.Cancel);
this.editField.ValidateText = new TextField.ValidateCallback(this.ValidateVariableName);
this.editField.Text = variableName;
this.editField.Validate();
this.framePoints = new Vector3[5];
this.framePoints[0] = new Vector3(0f, 1f);
this.framePoints[1] = new Vector3(base.get_position().get_width() - 1f, 1f);
this.framePoints[2] = new Vector3(base.get_position().get_width() - 1f, base.get_position().get_height() - 1f);
this.framePoints[3] = new Vector3(1f, base.get_position().get_height() - 1f);
this.framePoints[4] = new Vector3(1f, 1f);
}
private static void MoveToLocal(object userdata)
{
NamedVariable namedVariable = userdata as NamedVariable;
if (namedVariable != null && SkillEditor.SelectedFsm != null)
{
SkillVariables variables = SkillEditor.SelectedFsm.get_Variables();
if (variables.Contains(namedVariable.get_Name()))
{
Dialogs.OkDialog(Strings.get_Dialog_Make_Local_Variable(), Strings.get_Dialog_Error_Variable_with_same_name_already_exists());
return;
}
SkillVariable.AddVariable(variables, namedVariable.Clone());
SkillEditor.SelectedFsm.Reinitialize();
SkillEditor.SetFsmDirty();
SkillEditor.VariableManager.Reset();
SkillEditor.RepaintAll();
}
}
public static void Start(Skill fsm)
{
DebugFlow.UpdateTime();
DebugFlow.Active = true;
DebugFlow.SyncFsmLog(fsm);
DebugFlow.StartedDebugFrame = Time.get_frameCount();
DebugFlow.variablesCache.Clear();
using (List <Skill> .Enumerator enumerator = SkillEditor.FsmList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Skill current = enumerator.get_Current();
if (current.EnableDebugFlow)
{
DebugFlow.variablesCache.Add(current, new SkillVariables(current.get_Variables()));
}
}
}
DebugFlow.globalVariablesCache = new SkillVariables(SkillVariables.get_GlobalVariables());
}
public static void SortVariables(SkillVariables fsmVariables)
{
if (fsmVariables == null)
{
return;
}
fsmVariables.set_BoolVariables(ArrayUtility.Sort <SkillBool>(fsmVariables.get_BoolVariables()));
fsmVariables.set_FloatVariables(ArrayUtility.Sort <SkillFloat>(fsmVariables.get_FloatVariables()));
fsmVariables.set_IntVariables(ArrayUtility.Sort <SkillInt>(fsmVariables.get_IntVariables()));
fsmVariables.set_Vector2Variables(ArrayUtility.Sort <SkillVector2>(fsmVariables.get_Vector2Variables()));
fsmVariables.set_Vector3Variables(ArrayUtility.Sort <SkillVector3>(fsmVariables.get_Vector3Variables()));
fsmVariables.set_GameObjectVariables(ArrayUtility.Sort <SkillGameObject>(fsmVariables.get_GameObjectVariables()));
fsmVariables.set_ObjectVariables(ArrayUtility.Sort <SkillObject>(fsmVariables.get_ObjectVariables()));
fsmVariables.set_RectVariables(ArrayUtility.Sort <SkillRect>(fsmVariables.get_RectVariables()));
fsmVariables.set_QuaternionVariables(ArrayUtility.Sort <SkillQuaternion>(fsmVariables.get_QuaternionVariables()));
fsmVariables.set_MaterialVariables(ArrayUtility.Sort <SkillMaterial>(fsmVariables.get_MaterialVariables()));
fsmVariables.set_TextureVariables(ArrayUtility.Sort <SkillTexture>(fsmVariables.get_TextureVariables()));
fsmVariables.set_StringVariables(ArrayUtility.Sort <SkillString>(fsmVariables.get_StringVariables()));
fsmVariables.set_ColorVariables(ArrayUtility.Sort <SkillColor>(fsmVariables.get_ColorVariables()));
}
private static void RestoreVariables(SkillLogEntry logEntry)
{
if (logEntry == null)
{
Debug.Log("Bad Log Entry!");
return;
}
Skill fsm = logEntry.get_Fsm();
if (!fsm.EnableDebugFlow)
{
return;
}
if (fsm == null)
{
Debug.Log("Fsm == null!!");
return;
}
if (logEntry.get_FsmVariablesCopy() != null)
{
fsm.get_Variables().ApplyVariableValues(logEntry.get_FsmVariablesCopy());
}
else
{
Debug.LogError("Missing Local Variables Cache!");
}
if (logEntry.get_GlobalVariablesCopy() != null)
{
SkillVariables.get_GlobalVariables().ApplyVariableValues(logEntry.get_GlobalVariablesCopy());
}
else
{
Debug.LogError("Missing global Variables Cache!");
}
if (SkillEditor.SelectedFsm == fsm)
{
SkillEditor.VariableManager.UpdateView();
GlobalVariablesWindow.UpdateView();
SkillEditor.Repaint(false);
}
}
public void DeleteVariable(SkillVariable fsmVariable, bool undo = true, bool checkDialog = true)
{
if (checkDialog && !this.CheckDeleteVariable(Strings.get_Dialog_Delete_Variable(), Strings.get_Dialog_Delete_Variable_Are_you_sure(), fsmVariable))
{
return;
}
if (undo)
{
this.RegisterUndo(Strings.get_Dialog_Delete_Variable());
}
if (!this.editingGlobalVariables)
{
SkillBuilder.RemoveVariableUsage(fsmVariable.NamedVar);
SkillVariable.DeleteVariable(this.target, fsmVariable);
}
else
{
SkillBuilder.RemoveGlobalVariableUsage(fsmVariable.NamedVar);
SkillVariable.DeleteVariable(SkillVariables.get_GlobalVariables(), fsmVariable);
}
this.listIsDirty = true;
this.SetDirty(true);
this.Reset();
}
public static void PlayAnimation(SkillVariables variables, PlayAnimation anim)
{
AnimationController animationCtrler = variables.skillCaster.AnimationCtrler;
if (animationCtrler != null)
{
animationCtrler.PlayAnimation(anim);
}
else
{
GameObject gameObject = variables.skillCaster.gameObject;
if (gameObject && gameObject.animation)
{
if (anim.BlendTime < 0.001f)
{
gameObject.animation.Play(anim.AnimName, anim.PlayMode);
}
else
{
gameObject.animation.CrossFade(anim.AnimName, anim.BlendTime, anim.PlayMode);
}
gameObject.animation.wrapMode = anim.WrapMode;
}
}
}
private void OnInit(object value)
{
if (!base.enabled)
{
return;
}
this.variables = (value as SkillVariables);
if (this.variables == null)
{
global::Debug.LogError(new object[]
{
"SkillVariables could not be null"
});
return;
}
this.doAction = false;
this.pause = false;
this.actionIndex = this.variables.GenerateActionIndex();
if (this.delayTime > 0f)
{
this.updateTimer = this.delayTime / this.variables.skillCaster.AttackSpeed;
}
else
{
this.updateTimer = 0f;
this.DoBaseAction();
}
}
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 bool IsGlobalVariable(NamedVariable variable)
{
return(SkillVariables.get_GlobalVariables().Contains(variable));
}
public static void SortFsmVariables(SkillVariables fsmVariables)
{
VariableManager.SortVariables(fsmVariables);
}
public static NewVariableWindow CreateDropdown(string title, Rect buttonRect, SkillVariables fsmVariables, string variableName)
{
NewVariableWindow newVariableWindow = ScriptableObject.CreateInstance <NewVariableWindow>();
newVariableWindow.Init(title, fsmVariables, variableName);
newVariableWindow.ShowAsDropDown(buttonRect, new Vector2(194f, 70f));
return(newVariableWindow);
}
public void Apply(SkillVariables variables)
{
this.variable = variables.GetVariable(this.variable.Name);
this.fsmVar.ApplyValueTo(this.variable);
}
public void OnAdd()
{
if (this.Owner == null)
{
return;
}
if (string.IsNullOrEmpty(this.Info.AddAction))
{
return;
}
if (this.Owner.BuffAction != null)
{
PoolMgr.Despawn(this.Owner.BuffAction);
this.Owner.BuffAction = null;
}
this.addAction = PoolMgr.Spawn(this.Info.AddAction, this.Owner.transform.position, this.Owner.transform.rotation);
this.Owner.BuffAction = this.addAction;
if (this.addAction != null)
{
SkillVariables skillVariables = new SkillVariables();
skillVariables.skillCaster = this.Owner;
skillVariables.skillTarget = this.Caster;
this.addAction.SendMessage("OnInit", skillVariables, SendMessageOptions.DontRequireReceiver);
}
}
