예제 #1
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            AddOption t = target as AddOption;

            EditorGUILayout.PropertyField(optionTextProp, new GUIContent("Option Text", "Text to display on the option button."));

            SequenceEditor.SequenceField(targetSequenceProp,
                                         new GUIContent("Target Sequence", "Sequence to execute when this option is selected by the player."),
                                         new GUIContent("<Continue>"),
                                         t.GetFungusScript());

            EditorGUILayout.PropertyField(hideOnSelectedProp, new GUIContent("Hide On Selected", "Hide this option forever once the player has selected it."));

            serializedObject.ApplyModifiedProperties();
        }
예제 #2
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            Call t = target as Call;

            FungusScript fungusScript = t.GetFungusScript();

            if (fungusScript == null)
            {
                return;
            }

            SequenceEditor.SequenceField(targetSequenceProp,
                                         new GUIContent("Target Sequence", "Sequence to call"),
                                         new GUIContent("<Continue>"),
                                         fungusScript);

            serializedObject.ApplyModifiedProperties();
        }
예제 #3
0
        public override void DrawCommandGUI()
        {
            FungusScript fungusScript = FungusScriptWindow.GetFungusScript();

            if (fungusScript == null)
            {
                return;
            }

            serializedObject.Update();

            EditorGUILayout.PropertyField(durationProp);

            SequenceEditor.SequenceField(targetSequenceProp,
                                         new GUIContent("Target Sequence", "Sequence to call when timer expires"),
                                         new GUIContent("<None>"),
                                         fungusScript);

            serializedObject.ApplyModifiedProperties();
        }
        public override void OnInspectorGUI()
        {
            SequenceInspector sequenceInspector = target as SequenceInspector;
            Sequence          sequence          = sequenceInspector.sequence;

            if (sequence == null)
            {
                return;
            }

            FungusScript fungusScript = sequence.GetFungusScript();

            SequenceEditor sequenceEditor = Editor.CreateEditor(sequence) as SequenceEditor;

            sequenceEditor.DrawSequenceGUI(fungusScript);
            DestroyImmediate(sequenceEditor);

            Command inspectCommand = null;

            if (fungusScript.selectedCommands.Count == 1)
            {
                inspectCommand = fungusScript.selectedCommands[0];
            }

            if (Application.isPlaying &&
                inspectCommand != null &&
                inspectCommand.parentSequence != sequence)
            {
                Repaint();
                return;
            }

            if (inspectCommand != null)
            {
                CommandEditor commandEditor = Editor.CreateEditor(inspectCommand) as CommandEditor;
                commandEditor.DrawCommandInspectorGUI();
                DestroyImmediate(commandEditor);
            }

            Repaint();
        }
예제 #5
0
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            FungusScript t = target as FungusScript;

            t.UpdateHideFlags();

            if (Application.isPlaying)
            {
                if (t.executingSequence == null)
                {
                    t.selectedCommand = null;
                }
                else
                {
                    t.selectedCommand = t.executingSequence.activeCommand;
                }
            }

            EditorGUILayout.PropertyField(stepTimeProp, new GUIContent("Step Time", "Minimum time to execute each step"));

            SequenceEditor.SequenceField(startSequenceProp,
                                         new GUIContent("Start Sequence", "Sequence to be executed when controller starts."),
                                         new GUIContent("<None>"),
                                         t);

            if (t.startSequence == null)
            {
                GUIStyle style = new GUIStyle(GUI.skin.label);
                style.normal.textColor = new Color(1, 0, 0);
                EditorGUILayout.LabelField(new GUIContent("Error: Please select a Start Sequence"), style);
            }

            EditorGUILayout.PropertyField(executeOnStartProp, new GUIContent("Execute On Start", "Execute this Fungus Script when the scene starts."));

            EditorGUILayout.PropertyField(colorCommandsProp, new GUIContent("Color Commands", "Display commands using colors in editor window."));

            EditorGUILayout.PropertyField(showSequenceObjectsProp, new GUIContent("Show Sequence Objects", "Display the child Sequence game objects in the hierarchy view."));

            EditorGUILayout.Separator();

            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button("Open Editor"))
            {
                EditorWindow.GetWindow(typeof(FungusScriptWindow), false, "Fungus Script");
            }
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();

            EditorGUILayout.Separator();

            if (t.selectedCommand != null)
            {
                CommandEditor commandEditor = Editor.CreateEditor(t.selectedCommand) as CommandEditor;
                commandEditor.DrawCommandInspectorGUI();
                DestroyImmediate(commandEditor);
            }

            EditorGUILayout.Separator();

            DrawVariablesGUI();

            serializedObject.ApplyModifiedProperties();
        }
예제 #6
0
        void DrawSequenceView(FungusScript fungusScript)
        {
            GUILayout.Space(5);

            fungusScript.commandScrollPos = GUILayout.BeginScrollView(fungusScript.commandScrollPos);

            EditorGUILayout.BeginVertical();

            GUILayout.Box("Sequence", GUILayout.ExpandWidth(true));

            GUILayout.BeginHorizontal();

            if (fungusScript.selectedSequence == null)
            {
                GUILayout.FlexibleSpace();
            }

            if (GUILayout.Button(fungusScript.selectedSequence == null ? "Create Sequence" : "Create",
                                 fungusScript.selectedSequence == null ?  EditorStyles.miniButton : EditorStyles.miniButtonLeft))
            {
                Sequence newSequence = fungusScript.CreateSequence(fungusScript.scriptScrollPos);
                Undo.RegisterCreatedObjectUndo(newSequence, "New Sequence");
                fungusScript.selectedSequence = newSequence;
                fungusScript.selectedCommand  = null;
            }

            if (fungusScript.selectedSequence == null)
            {
                GUILayout.FlexibleSpace();
            }

            if (fungusScript.selectedSequence != null)
            {
                if (GUILayout.Button("Delete", EditorStyles.miniButtonMid))
                {
                    Undo.DestroyObjectImmediate(fungusScript.selectedSequence.gameObject);
                    fungusScript.selectedSequence = null;
                    fungusScript.selectedCommand  = null;
                }
                if (GUILayout.Button("Duplicate", EditorStyles.miniButtonRight))
                {
                    GameObject copy = GameObject.Instantiate(fungusScript.selectedSequence.gameObject) as GameObject;
                    copy.transform.parent    = fungusScript.transform;
                    copy.transform.hideFlags = HideFlags.HideInHierarchy;
                    copy.name = fungusScript.selectedSequence.name;

                    Sequence sequenceCopy = copy.GetComponent <Sequence>();
                    sequenceCopy.nodeRect.x += sequenceCopy.nodeRect.width + 10;

                    Undo.RegisterCreatedObjectUndo(copy, "Duplicate Sequence");
                    fungusScript.selectedSequence = sequenceCopy;
                    fungusScript.selectedCommand  = null;
                }
            }

            GUILayout.EndHorizontal();

            if (fungusScript.selectedSequence != null)
            {
                EditorGUILayout.Separator();

                SequenceEditor sequenceEditor = Editor.CreateEditor(fungusScript.selectedSequence) as SequenceEditor;
                sequenceEditor.DrawSequenceGUI(fungusScript);
                DestroyImmediate(sequenceEditor);

                GUILayout.FlexibleSpace();
            }

            EditorGUILayout.EndVertical();

            GUILayout.EndScrollView();
        }