Esempio n. 1
0
        /// <summary>
        /// Inserts a new state element in the state array.
        /// </summary>
        private static Opsive.Shared.StateSystem.State[] InsertStateElement(Opsive.Shared.StateSystem.State[] states, ReorderableList reorderableList, string selectedIndexKey, string name, PersistablePreset preset)
        {
            // The name has to be unique to prevent it from interferring with other state names.
            if (!IsUniqueName(states, name))
            {
                var postfixIndex = 1;
                while (!IsUniqueName(states, name + " " + postfixIndex))
                {
                    postfixIndex++;
                }
                name += " " + postfixIndex;
            }

            // Create the element.
            var state = new Opsive.Shared.StateSystem.State(name, false);

            state.Preset = preset;
            var stateList = new List <Opsive.Shared.StateSystem.State>(states);

            stateList.Insert(0, state);
            reorderableList.displayRemove = stateList.Count > 1;

            // Select the new element.
            reorderableList.index = stateList.Count - 1;
            EditorPrefs.SetInt(selectedIndexKey, reorderableList.index);
            return(stateList.ToArray());
        }
Esempio n. 2
0
        /// <summary>
        /// Draws all of the added states.
        /// </summary>
        public static void OnStateListDraw(object obj, Opsive.Shared.StateSystem.State[] states, SerializedProperty statesProperty, Rect rect, int index)
        {
            if (rect.width < 0)
            {
                return;
            }

            // States cannot be edited at runtime, nor can the Default state ever be edited.
            GUI.enabled = !Application.isPlaying && index != states.Length - 1;
            rect.x     -= EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;

            // Ensure the default state doesn't get changed.
            var state         = states[index];
            var stateProperty = (statesProperty != null ? statesProperty.GetArrayElementAtIndex(index) : null);

            if (!Application.isPlaying && index == states.Length - 1)
            {
                if (statesProperty != null && stateProperty == null)
                {
                    statesProperty.InsertArrayElementAtIndex(index);
                    stateProperty = statesProperty.GetArrayElementAtIndex(index);
                    stateProperty.FindPropertyRelative("m_Name").stringValue  = "Default";
                    stateProperty.FindPropertyRelative("m_Default").boolValue = true;
                }
                else if (statesProperty == null && state == null)
                {
                    states[index] = state = new Opsive.Shared.StateSystem.State("Default", true);
                    GUI.changed   = true;
                }
                if (state.Name != "Default")
                {
                    if (stateProperty != null)
                    {
                        stateProperty.FindPropertyRelative("m_Name").stringValue = "Default";
                    }
                    else
                    {
                        state.Name = "Default";
                    }
                    GUI.changed = true;
                }
                if (!state.Default)
                {
                    if (stateProperty != null)
                    {
                        stateProperty.FindPropertyRelative("m_Default").boolValue = true;
                    }
                    else
                    {
                        state.Default = true;
                    }
                    GUI.changed = true;
                }
            }

            // Setup the field sizings.
            var fieldWidth     = rect.width / 5;
            var blockedByWidth = Mathf.Max(c_MinBlockedByWidth, Mathf.Min(c_MaxBlockedByWidth, fieldWidth)) + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;

            fieldWidth = rect.width / 7;
            var persistWidth  = Mathf.Max(c_MinPersistWidth, Mathf.Min(c_MaxPersistWidth, fieldWidth));
            var activateWidth = Mathf.Max(c_MinActivateWidth, Mathf.Min(c_MaxActivateWidth, fieldWidth));

            fieldWidth = (rect.width - blockedByWidth - persistWidth - activateWidth) / 2 - (c_WidthBuffer * 3);
            var presetWidth = Mathf.Min(c_MaxPresetWidth, fieldWidth) + EditorGUI.indentLevel * 30;
            var nameWidth   = Mathf.Max(0, rect.width - presetWidth - blockedByWidth - persistWidth - activateWidth - (c_WidthBuffer * 6)) + EditorGUI.indentLevel * 45;
            var startRectX  = rect.x;

            // The state name has to be unique.
            var active      = state.Active && !state.IsBlocked();
            var desiredName = EditorGUI.TextField(new Rect(startRectX, rect.y + 1, nameWidth, EditorGUIUtility.singleLineHeight), state.Name +
                                                  (active ? " (Active)" : string.Empty),
                                                  (active ? Utility.InspectorStyles.BoldTextField : EditorStyles.textField));

            if (!Application.isPlaying && desiredName != state.Name && IsUniqueName(states, desiredName))
            {
                // The name of the state that is blocking the current state should be updated.
                for (int i = 0; i < states.Length; ++i)
                {
                    if (states[i] == state)
                    {
                        continue;
                    }

                    if (states[i].BlockList != null)
                    {
                        for (int j = 0; j < states[i].BlockList.Length; ++j)
                        {
                            if (states[i].BlockList[j] == state.Name)
                            {
                                if (stateProperty != null)
                                {
                                    statesProperty.GetArrayElementAtIndex(i).FindPropertyRelative("m_BlockList").GetArrayElementAtIndex(j).stringValue = desiredName;
                                }
                                else
                                {
                                    states[i].BlockList[j] = desiredName;
                                }
                            }
                        }
                    }
                }

                if (stateProperty != null)
                {
                    stateProperty.FindPropertyRelative("m_Name").stringValue = desiredName;
                }
                else
                {
                    state.Name = desiredName;
                }
            }
            startRectX += nameWidth + c_WidthBuffer - EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;

            // The preset cannot be null.
            var desiredPreset = EditorGUI.ObjectField(new Rect(startRectX, rect.y + 1, presetWidth,
                                                               EditorGUIUtility.singleLineHeight), string.Empty, state.Preset, typeof(PersistablePreset), false) as PersistablePreset;

            if (desiredPreset != null)
            {
                var objType = TypeUtility.GetType(desiredPreset.Data.ObjectType);
                if (objType != null && objType.IsInstanceOfType(obj))
                {
                    if (stateProperty != null)
                    {
                        stateProperty.FindPropertyRelative("m_Preset").objectReferenceValue = desiredPreset;
                    }
                    else
                    {
                        state.Preset = desiredPreset;
                    }
                }
                else
                {
                    Debug.LogError($"Error: Unable to add preset. {desiredPreset.name} ({desiredPreset.Data.ObjectType}) doesn't use the same object type ({obj.GetType().FullName}).");
                }
            }
            startRectX += presetWidth + c_WidthBuffer - EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;

            // Create a popup of the states that can block the current state. There are several conditions which would prevent a state from being able to block
            // another state so this popup has to first be filtered.
            var stateName = state.Name;
            var blockList = state.BlockList;
            var allStates = new List <string>();
            var selected  = 0;

            for (int i = 0; i < states.Length; ++i)
            {
                var currentState = states[i];
                if (currentState == null)
                {
                    states[i] = currentState = new Opsive.Shared.StateSystem.State();
                }
                // The current state cannot block the default state.
                if (currentState.Default)
                {
                    continue;
                }
                string name;
                // The current state cannot block itself.
                if ((name = currentState.Name) == stateName)
                {
                    continue;
                }
                // The selected state cannot block the current state if the current state blocks the selected state.
                var currentStateBlockList = currentState.BlockList;
                var canAdd = true;
                if (currentStateBlockList != null)
                {
                    for (int j = 0; j < currentStateBlockList.Length; ++j)
                    {
                        if (stateName == currentStateBlockList[j])
                        {
                            canAdd = false;
                            break;
                        }
                    }
                }

                // canAdd will be false if the current state is blocking the selected state.
                if (!canAdd)
                {
                    continue;
                }

                // The current state can block the selected state. Add the name to the popup and determine if the state is selected. A mask is used
                // to allow multiple selected states.
                allStates.Add(name);
                if (blockList != null)
                {
                    for (int j = 0; j < blockList.Length; ++j)
                    {
                        if (allStates[allStates.Count - 1] == blockList[j])
                        {
                            selected |= 1 << (allStates.Count - 1);
                            break;
                        }
                    }
                }
            }
            // At least one value needs to exist.
            if (allStates.Count == 0)
            {
                allStates.Add("Nothing");
            }

            // Draw the actual popup.
            var blockMask = EditorGUI.MaskField(new Rect(startRectX, rect.y + 1, blockedByWidth, EditorGUIUtility.singleLineHeight), string.Empty, selected, allStates.ToArray());

            if (blockMask != selected)
            {
                var stateNames        = new List <string>();
                var blockListProperty = (stateProperty != null ? stateProperty.FindPropertyRelative("m_BlockList") : null);
                if (blockListProperty != null)
                {
                    blockListProperty.ClearArray();
                }
                for (int i = 0; i < allStates.Count; ++i)
                {
                    // If the state index is within the block mask then that state should be added to the list. A blockMask of -1 indicates Everything.
                    if (((1 << i) & blockMask) != 0 || blockMask == -1)
                    {
                        if (blockListProperty != null)
                        {
                            blockListProperty.InsertArrayElementAtIndex(blockListProperty.arraySize);
                            blockListProperty.GetArrayElementAtIndex(blockListProperty.arraySize - 1).stringValue = allStates[i];
                        }
                        else
                        {
                            stateNames.Add(allStates[i]);
                        }
                    }
                }
                if (blockListProperty == null)
                {
                    state.BlockList = stateNames.ToArray();
                }
            }
            startRectX += blockedByWidth + c_WidthBuffer;

            GUI.enabled = index < states.Length - 1;

            if (GUI.Button(new Rect(startRectX + persistWidth / 2, rect.y + 1, 18, EditorGUIUtility.singleLineHeight), Utility.InspectorStyles.PersistIcon, Utility.InspectorStyles.NoPaddingButtonStyle))
            {
                // Populate the position map so ObjectInspector.DrawProperties to know which properties already exist.
                var valuePositionMap = new Dictionary <int, int>(desiredPreset.Data.ValueHashes.Length);
                for (int i = 0; i < desiredPreset.Data.ValueHashes.Length; ++i)
                {
                    valuePositionMap.Add(desiredPreset.Data.ValueHashes[i], i);
                }

                // Loop through all of the properties on the object.
                var properties  = Serialization.GetSerializedProperties(obj.GetType(), MemberVisibility.Public);
                var bitwiseHash = new System.Version(desiredPreset.Data.Version).CompareTo(new System.Version("3.1")) >= 0;
                // Remove and add the properties that are being serialized.
                for (int i = 0; i < properties.Length; ++i)
                {
                    var hash = Serialization.StringHash(properties[i].PropertyType.FullName) + Serialization.StringHash(properties[i].Name);
                    // The property is currently being serialized.
                    if (valuePositionMap.ContainsKey(hash))
                    {
                        // Add the new property to the serialization.
                        object value    = null;
                        var    property = properties[i];
                        if (!typeof(Object).IsAssignableFrom(property.PropertyType))
                        {
                            var unityObjectIndexes = new List <int>();
                            Serialization.GetUnityObjectIndexes(ref unityObjectIndexes, property.PropertyType, property.Name, 0, valuePositionMap, desiredPreset.Data.ValueHashes, desiredPreset.Data.ValuePositions,
                                                                desiredPreset.Data.Values, false, MemberVisibility.Public, bitwiseHash);

                            Serialization.RemoveProperty(i, unityObjectIndexes, desiredPreset.Data, MemberVisibility.Public, bitwiseHash);

                            // Get the current value of the active object.
                            var getMethod = property.GetGetMethod();
                            if (getMethod != null)
                            {
                                value = getMethod.Invoke(obj, null);
                            }
                            // Add the property back with the updated value.
                            Serialization.AddProperty(property, value, unityObjectIndexes, desiredPreset.Data, MemberVisibility.Public);
                        }
                    }
                }
            }
            startRectX += persistWidth + c_WidthBuffer;

            GUI.enabled = Application.isPlaying && index < states.Length - 1;
            if (GUI.Button(new Rect(startRectX + activateWidth / 2, rect.y + 1, 18, EditorGUIUtility.singleLineHeight), Utility.InspectorStyles.ActivateIcon, Utility.InspectorStyles.NoPaddingButtonStyle))
            {
                StateManager.ActivateState(states[index], !states[index].Active, states);
            }

            GUI.enabled = true;
        }