Exemplo n.º 1
0
        public static void DuplicateIConditionList(IConditionsList source, IConditionsList dest)
        {
            if (source == null || source.conditions == null || source.conditions.Length == 0)
            {
                return;
            }
            ICondition[] conditions = new ICondition[source.conditions.Length];

            for (int i = 0; i < source.conditions.Length; i++)
            {
                ICondition sourceAction = source.conditions[i];
                if (sourceAction == null)
                {
                    continue;
                }
                conditions[i] = dest.gameObject.AddComponent(sourceAction.GetType()) as ICondition;
                EditorUtility.CopySerialized(sourceAction, conditions[i]);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(source.gameObject.scene);
                }
            }

            dest.conditions = conditions;
        }
Exemplo n.º 2
0
        // INITIALIZERS: -----------------------------------------------------------------------------------------------

        private void OnEnable()
        {
            if (target == null || serializedObject == null)
            {
                return;
            }
            this.instance           = (Clause)this.target;
            this.instance.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector;

            this.handleDragRect = Rect.zero;
            this.clauseRect     = Rect.zero;

            this.spDescription    = serializedObject.FindProperty(PROP_DESCRIPTION);
            this.spConditionsList = serializedObject.FindProperty(PROP_CONDITIONSLIST);
            this.spActions        = serializedObject.FindProperty(PROP_ACTION);

            if (this.instance.actions != null)
            {
                this.actionsEditor = Editor.CreateEditor(this.instance.actions) as ActionsEditor;
            }

            if (this.instance.conditionsList == null)
            {
                IConditionsList cList = this.instance.gameObject.AddComponent <IConditionsList>();
                this.spConditionsList.objectReferenceValue = cList;
                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            this.conditionsListEditor = Editor.CreateEditor(this.instance.conditionsList) as IConditionsListEditor;
        }
Exemplo n.º 3
0
        private void OnEnable()
        {
            this.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
            if (this.conditionsList != null &&
                this.conditionsList.gameObject != this.gameObject)
            {
                IConditionsList newConditionsList = gameObject.AddComponent <IConditionsList>();
                EditorUtility.CopySerialized(this.conditionsList, newConditionsList);

                SerializedObject serializedObject = new SerializedObject(this);
                serializedObject.FindProperty("conditionsList").objectReferenceValue = newConditionsList;
                serializedObject.ApplyModifiedPropertiesWithoutUndo();
            }
        }
Exemplo n.º 4
0
        // INITIALIZERS: --------------------------------------------------------------------------

        private void OnEnable()
        {
            if (target == null || serializedObject == null)
            {
                return;
            }

            this.forceInitialize = true;
            this.instance        = (IConditionsList)target;
            this.spConditions    = serializedObject.FindProperty(PROP_CONDITIONS);

            this.UpdateSubEditors(instance.conditions);
            this.editorSortableList = new EditorSortableList();

            if (this.target != null)
            {
                this.target.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
            }
        }
Exemplo n.º 5
0
        private void PaintEvent()
        {
            if (this.spInteractions != null && this.spInteractions.arraySize > 0)
            {
                this.PaintInteractions();
            }
            else
            {
                EditorGUILayout.HelpBox(MSG_EMTPY_EVENTS, MessageType.None);
            }

            float widthAddInteraction = 100f;
            Rect  rectControls        = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
            Rect  rectAddInteraction  = new Rect(
                rectControls.x + (rectControls.width / 2.0f) - (widthAddInteraction + 25f) / 2.0f,
                rectControls.y,
                widthAddInteraction,
                rectControls.height
                );

            Rect rectPaste = new Rect(
                rectAddInteraction.x + rectAddInteraction.width,
                rectControls.y,
                25f,
                rectControls.height
                );

            if (GUI.Button(rectAddInteraction, "Add Interaction", CoreGUIStyles.GetButtonLeft()))
            {
                Interaction interactionCreated = this.instance.gameObject.AddComponent <Interaction>();

                int interactionCreatedIndex = this.spInteractions.arraySize;
                this.spInteractions.InsertArrayElementAtIndex(interactionCreatedIndex);
                this.spInteractions.GetArrayElementAtIndex(interactionCreatedIndex).objectReferenceValue = interactionCreated;

                this.AddSubEditorElement(interactionCreated, -1, true);

                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();
            }

            GUIContent gcPaste = InteractionUtilities.Get(InteractionUtilities.Icon.Paste);

            EditorGUI.BeginDisabledGroup(CLIPBOARD_INTERACTION == null);
            if (GUI.Button(rectPaste, gcPaste, CoreGUIStyles.GetButtonRight()))
            {
                Interaction copy = this.instance.gameObject.AddComponent <Interaction>();
                EditorUtility.CopySerialized(CLIPBOARD_INTERACTION, copy);

                if (copy.conditionsList != null)
                {
                    IConditionsList conditionsListSource = copy.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    EventEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(copy);
                    soCopy.FindProperty(InteractionEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedProperties();
                    soCopy.Update();
                }

                int interactionIndex = this.spInteractions.arraySize;
                this.spInteractions.InsertArrayElementAtIndex(interactionIndex);
                this.spInteractions.GetArrayElementAtIndex(interactionIndex).objectReferenceValue = copy;

                this.AddSubEditorElement(copy, -1, true);

                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();

                DestroyImmediate(CLIPBOARD_INTERACTION.gameObject, true);
                CLIPBOARD_INTERACTION = null;

                /*
                 * int srcIndex = duplicateInteractionIndex;
                 * int dstIndex = duplicateInteractionIndex + 1;
                 *
                 * Interaction source = (Interaction)this.subEditors[srcIndex].target;
                 * Interaction copy = (Interaction)this.instance.gameObject.AddComponent(source.GetType());
                 * EditorUtility.CopySerialized(source, copy);
                 *
                 * if (copy.conditionsList != null)
                 * {
                 *  IConditionsList conditionsListSource = copy.conditionsList;
                 *  IConditionsList conditionsListCopy = this.instance.gameObject.AddComponent<IConditionsList>();
                 *
                 *  EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                 *  EventEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);
                 *
                 *  SerializedObject soCopy = new SerializedObject(copy);
                 *  soCopy.FindProperty(InteractionEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                 *  soCopy.ApplyModifiedProperties();
                 *  soCopy.Update();
                 * }
                 *
                 * this.spInteractions.InsertArrayElementAtIndex(dstIndex);
                 * this.spInteractions.GetArrayElementAtIndex(dstIndex).objectReferenceValue = copy;
                 *
                 * this.spInteractions.serializedObject.ApplyModifiedProperties();
                 * this.spInteractions.serializedObject.Update();
                 *
                 * this.AddSubEditorElement(copy, dstIndex, true);
                 */
            }
            EditorGUI.EndDisabledGroup();

            GUIContent gcElse   = InteractionUtilities.Get(InteractionUtilities.Icon.Else);
            Rect       rectElse = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.boldLabel);

            EditorGUI.LabelField(rectElse, gcElse, EditorStyles.boldLabel);

            ActionsEditor.Return returnActions = ActionsEditor.PaintActionsGUI(
                this.instance.gameObject,
                this.spDefaultActions,
                this.actionsEditor
                );

            if (returnActions != null)
            {
                this.spDefaultActions = returnActions.spParentActions;
                this.actionsEditor    = returnActions.parentActionsEditor;

                serializedObject.ApplyModifiedProperties();
                serializedObject.Update();
            }

            EditorGUILayout.Space();
        }
Exemplo n.º 6
0
        private void PaintInteractions()
        {
            int removeInteractionIndex    = -1;
            int duplicateInteractionIndex = -1;
            int copyInteractionIndex      = -1;

            bool forceRepaint     = false;
            int  interactionsSize = this.spInteractions.arraySize;

            for (int i = 0; i < interactionsSize; ++i)
            {
                if (this.subEditors == null || i >= this.subEditors.Length || this.subEditors[i] == null)
                {
                    continue;
                }

                bool repaint = this.editorSortableList.CaptureSortEvents(this.subEditors[i].handleDragRect, i);
                forceRepaint = repaint || forceRepaint;

                EditorGUILayout.BeginVertical();
                Rect rectHeader = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
                this.PaintDragHandle(i, rectHeader);

                EditorGUIUtility.AddCursorRect(this.subEditors[i].handleDragRect, MouseCursor.Pan);
                string   name  = (this.isExpanded[i].target ? "▾ " : "▸ ") + this.instance.interactions[i].description;
                GUIStyle style = (this.isExpanded[i].target
                                        ? CoreGUIStyles.GetToggleButtonMidOn()
                                        : CoreGUIStyles.GetToggleButtonMidOff()
                                  );

                Rect rectDelete = new Rect(
                    rectHeader.x + rectHeader.width - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectDuplicate = new Rect(
                    rectDelete.x - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectCopy = new Rect(
                    rectDuplicate.x - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectMain = new Rect(
                    rectHeader.x + 25f,
                    rectHeader.y,
                    rectHeader.width - (25f * 4f),
                    rectHeader.height
                    );

                if (GUI.Button(rectMain, name, style))
                {
                    this.ToggleExpand(i);
                }

                GUIContent gcCopy      = InteractionUtilities.Get(InteractionUtilities.Icon.Copy);
                GUIContent gcDuplicate = InteractionUtilities.Get(InteractionUtilities.Icon.Duplicate);
                GUIContent gcDelete    = InteractionUtilities.Get(InteractionUtilities.Icon.Delete);

                if (GUI.Button(rectCopy, gcCopy, CoreGUIStyles.GetButtonMid()))
                {
                    copyInteractionIndex = i;
                }

                if (GUI.Button(rectDuplicate, gcDuplicate, CoreGUIStyles.GetButtonMid()))
                {
                    duplicateInteractionIndex = i;
                }

                if (GUI.Button(rectDelete, gcDelete, CoreGUIStyles.GetButtonRight()))
                {
                    if (EditorUtility.DisplayDialog(MSG_REMOVE_TITLE, MSG_REMOVE_DESCR, "Yes", "Cancel"))
                    {
                        removeInteractionIndex = i;
                    }
                }

                using (var group = new EditorGUILayout.FadeGroupScope(this.isExpanded[i].faded))
                {
                    if (group.visible)
                    {
                        EditorGUILayout.BeginVertical(CoreGUIStyles.GetBoxExpanded());
                        this.subEditors[i].OnInteractionGUI();
                        EditorGUILayout.EndVertical();
                    }
                }

                EditorGUILayout.EndVertical();
                if (UnityEngine.Event.current.type == EventType.Repaint)
                {
                    this.subEditors[i].interactionRect = GUILayoutUtility.GetLastRect();
                }

                this.editorSortableList.PaintDropPoints(this.subEditors[i].interactionRect, i, interactionsSize);
            }

            if (copyInteractionIndex >= 0)
            {
                Interaction source       = (Interaction)this.subEditors[copyInteractionIndex].target;
                GameObject  copyInstance = EditorUtility.CreateGameObjectWithHideFlags(
                    "Interaction (Copy)",
                    HideFlags.HideAndDontSave
                    );

                CLIPBOARD_INTERACTION = (Interaction)copyInstance.AddComponent(source.GetType());
                EditorUtility.CopySerialized(source, CLIPBOARD_INTERACTION);

                if (CLIPBOARD_INTERACTION.conditionsList != null)
                {
                    IConditionsList conditionsListSource = CLIPBOARD_INTERACTION.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    EventEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(CLIPBOARD_INTERACTION);
                    soCopy.FindProperty(InteractionEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedProperties();
                    soCopy.Update();
                }
            }

            if (duplicateInteractionIndex >= 0)
            {
                int srcIndex = duplicateInteractionIndex;
                int dstIndex = duplicateInteractionIndex + 1;

                Interaction source = (Interaction)this.subEditors[srcIndex].target;
                Interaction copy   = (Interaction)this.instance.gameObject.AddComponent(source.GetType());
                EditorUtility.CopySerialized(source, copy);

                if (copy.conditionsList != null)
                {
                    IConditionsList conditionsListSource = copy.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    EventEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(copy);
                    soCopy.FindProperty(InteractionEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedProperties();
                    soCopy.Update();
                }

                this.spInteractions.InsertArrayElementAtIndex(dstIndex);
                this.spInteractions.GetArrayElementAtIndex(dstIndex).objectReferenceValue = copy;

                this.spInteractions.serializedObject.ApplyModifiedProperties();
                this.spInteractions.serializedObject.Update();

                this.AddSubEditorElement(copy, dstIndex, true);
            }

            if (removeInteractionIndex >= 0)
            {
                this.subEditors[removeInteractionIndex].OnDestroyInteraction();
                Interaction rmInteraction = (Interaction)this.spInteractions
                                            .GetArrayElementAtIndex(removeInteractionIndex).objectReferenceValue;

                this.spInteractions.DeleteArrayElementAtIndex(removeInteractionIndex);
                this.spInteractions.RemoveFromObjectArrayAt(removeInteractionIndex);
                DestroyImmediate(rmInteraction, true);
            }

            EditorSortableList.SwapIndexes swapIndexes = this.editorSortableList.GetSortIndexes();
            if (swapIndexes != null)
            {
                this.spInteractions.MoveArrayElement(swapIndexes.src, swapIndexes.dst);
                this.MoveSubEditorsElement(swapIndexes.src, swapIndexes.dst);
            }

            if (forceRepaint)
            {
                this.Repaint();
            }
        }
Exemplo n.º 7
0
        private void PaintConditions()
        {
            if (this.spClauses != null && this.spClauses.arraySize > 0)
            {
                this.PaintClauses();
            }
            else
            {
                EditorGUILayout.HelpBox(MSG_EMTPY_CONDITIONS, MessageType.None);
            }

            float widthAddClause = 100f;
            Rect  rectControls   = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
            Rect  rectAddClause  = new Rect(
                rectControls.x + (rectControls.width / 2.0f) - (widthAddClause + 25f) / 2.0f,
                rectControls.y,
                widthAddClause,
                rectControls.height
                );

            Rect rectPaste = new Rect(
                rectAddClause.x + rectAddClause.width,
                rectControls.y,
                25f,
                rectControls.height
                );

            if (GUI.Button(rectAddClause, "Add Clause", CoreGUIStyles.GetButtonLeft()))
            {
                Clause clauseCreated = this.instance.gameObject.AddComponent <Clause>();

                int clauseCreatedIndex = this.spClauses.arraySize;
                this.spClauses.InsertArrayElementAtIndex(clauseCreatedIndex);
                this.spClauses.GetArrayElementAtIndex(clauseCreatedIndex).objectReferenceValue = clauseCreated;

                this.AddSubEditorElement(clauseCreated, -1, true);

                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            GUIContent gcPaste = ClausesUtilities.Get(ClausesUtilities.Icon.Paste);

            EditorGUI.BeginDisabledGroup(CLIPBOARD_CLAUSE == null);
            if (GUI.Button(rectPaste, gcPaste, CoreGUIStyles.GetButtonRight()))
            {
                Clause copy = this.instance.gameObject.AddComponent <Clause>();
                EditorUtility.CopySerialized(CLIPBOARD_CLAUSE, copy);

                if (copy.conditionsList != null)
                {
                    IConditionsList conditionsListSource = copy.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    ConditionsEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(copy);
                    soCopy.FindProperty(ClauseEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedPropertiesWithoutUndo();
                    soCopy.Update();
                }

                int clauseIndex = this.spClauses.arraySize;
                this.spClauses.InsertArrayElementAtIndex(clauseIndex);
                this.spClauses.GetArrayElementAtIndex(clauseIndex).objectReferenceValue = copy;

                this.AddSubEditorElement(copy, -1, true);

                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();

                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                DestroyImmediate(CLIPBOARD_CLAUSE.gameObject, true);
                CLIPBOARD_CLAUSE = null;
            }
            EditorGUI.EndDisabledGroup();

            GUIContent gcElse   = ClausesUtilities.Get(ClausesUtilities.Icon.Else);
            Rect       rectElse = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.boldLabel);

            EditorGUI.LabelField(rectElse, gcElse, EditorStyles.boldLabel);

            ActionsEditor.Return returnActions = ActionsEditor.PaintActionsGUI(
                this.instance.gameObject,
                this.spDefaultActions,
                this.actionsEditor
                );

            if (returnActions != null)
            {
                this.spDefaultActions = returnActions.spParentActions;
                this.actionsEditor    = returnActions.parentActionsEditor;

                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            EditorGUILayout.Space();
        }