コード例 #1
0
        /// <summary>
        /// Clear this instance.
        /// </summary>
        public override void Clear()
        {
            Attribute = null;
            Value     = null;

            base.Clear();
        }
コード例 #2
0
        /// <summary>
        /// Adds the attribute and returns it.
        /// </summary>
        /// <param name="rID">Attribute ID to add</param>
        /// <param name="rValue">Value to add to the attribute</param>
        /// <returns>Attribute that matches the ID</returns>
        public virtual BasicAttribute AddAttribute <T>(string rID, T rValue = default(T))
        {
            BasicAttribute lItem = AddAttribute(rID, typeof(T));

            lItem.SetValue <T>(rValue);

            return(lItem);
        }
コード例 #3
0
        /// <summary>
        /// Removes the specified attribute from the list of items
        /// </summary>
        /// <param name="rAttribute"></param>
        public virtual void RemoveAttribute(BasicAttribute rItem)
        {
            if (!mItemCache.ContainsKey(rItem.ID))
            {
                return;
            }

            rItem.Attributes = null;
            rItem.IsValid    = false;

            mItems.Remove(rItem);
            mItemCache.Remove(rItem.ID);
        }
コード例 #4
0
        /// <summary>
        /// Renames the attribute and fixes the cache
        /// </summary>
        /// <param name="rOldName">Old name of the attribute to change from.</param>
        /// <param name="rNewName">New name of the attribute to change to.</param>
        public virtual void RenameAttribute(string rOldName, string rNewName)
        {
            if (!mItemCache.ContainsKey(rOldName))
            {
                return;
            }

            BasicAttribute lItem = mItemCache[rOldName];

            lItem._ID = rNewName;

            mItemCache.Remove(rOldName);
            mItemCache.Add(rNewName, lItem);
        }
コード例 #5
0
ファイル: BasicAttributes.cs プロジェクト: vRNI/StealthGame
        /// <summary>
        /// Due to Unity's serialization limits, we have to do this ourselves:
        /// 1. GameObjects don't allow for lists of derived types
        /// 2. You can use ScriptableObjects, but prefabs don't support ScriptableObjects
        /// 3. ISerializationCallbackReceiver can't use Find()
        ///
        /// This function is called AFTER the items have been deserialized
        /// </summary>
        public void OnAfterDeserialize()
        {
            JSONSerializer.RootObject = gameObject;

            for (int i = 0; i < mItemDefinitions.Count; i++)
            {
                Type lType = null;

                JSONNode lNode = JSONNode.Parse(mItemDefinitions[i]);
                if (lNode != null)
                {
                    string lTypeString = lNode["__Type"].Value;
                    if (lTypeString != null && lTypeString.Length > 0)
                    {
                        lType = Type.GetType(lTypeString);
                    }
                }

                // Fill an existing existing attribute
                if (lType != null && mItems.Count > i && mItems[i].GetType() == lType)
                {
                    object lItemObj = mItems[i];
                    JSONSerializer.DeserializeInto(mItemDefinitions[i], ref lItemObj);
                }
                // Create a new attribute
                else
                {
                    BasicAttribute lAttribute = JSONSerializer.Deserialize(mItemDefinitions[i]) as BasicAttribute;
                    if (lAttribute != null)
                    {
                        if (mItems.Count <= i)
                        {
                            mItems.Add(lAttribute);
                        }
                        else
                        {
                            mItems[i] = lAttribute;
                        }
                    }
                }
            }

            // Get rid of excess items
            for (int i = mItems.Count - 1; i > mItemDefinitions.Count - 1; i--)
            {
                mItems.RemoveAt(i);
            }

            JSONSerializer.RootObject = null;
        }
コード例 #6
0
        /// <summary>
        /// Removes the specified attribute from the list of items
        /// </summary>
        /// <param name="rID">String representing the name or ID of the attribute we're removing</param>
        /// <param name="rAttribute"></param>
        public virtual void RemoveAttribute(string rID)
        {
            if (!mItemCache.ContainsKey(rID))
            {
                return;
            }

            BasicAttribute lItem = mItemCache[rID];

            lItem.Attributes = null;
            lItem.IsValid    = false;

            mItems.Remove(lItem);
            mItemCache.Remove(rID);
        }
コード例 #7
0
        /// <summary>
        /// Adds the attribute if it doesn't exist and returns it.
        /// </summary>
        /// <param name="rAttributeID">Attribute ID to add (if it doesn't exist)</param>
        /// <returns>Attribute that matches the ID</returns>
        public virtual BasicAttribute AddAttribute(string rAttributeID)
        {
            // Return the existing attribute
            for (int i = Items.Count - 1; i >= 0; i--)
            {
                if (string.Compare(Items[i].ID, rAttributeID, true) == 0)
                {
                    return(Items[i]);
                }
            }

            // Add the new attribute
            BasicAttribute lAttribute = new BasicAttribute();

            lAttribute.ID = rAttributeID;

            Items.Add(lAttribute);

            return(lAttribute);
        }
コード例 #8
0
        /// <summary>
        /// Due to Unity's serialization limits, we have to do this ourselves:
        /// 1. GameObjects don't allow for lists of derived types
        /// 2. You can use ScriptableObjects, but prefabs don't support ScriptableObjects
        /// 3. ISerializationCallbackReceiver can't use Find()
        ///
        /// This function is called AFTER the items have been deserialized
        /// </summary>
        public void OnAfterDeserialize()
        {
            JSONSerializer.RootObject = gameObject;

            // CDL 07/27/2018 - keep track of any invalid attribute definitions
            List <int> lInvalidDefinitions = new List <int>();

            for (int i = 0; i < mItemDefinitions.Count; i++)
            {
                Type lType       = null;
                bool lUpdateType = false;

                JSONNode lNode = JSONNode.Parse(mItemDefinitions[i]);
                if (lNode != null)
                {
                    string lTypeString = lNode["__Type"].Value;

                    // CDL 07/27/2018 - Use AssemblyHelper.ResolveType() intead of Type.GetType() so that
                    // the Type can still be obtained if the Motion was serialized as belonging to a different assembly
                    lType = AssemblyHelper.ResolveType(lTypeString, out lUpdateType);
                    //Debug.Log("Attribute type resolved to " + lType.AssemblyQualifiedName);
                    //if (lTypeString != null && lTypeString.Length > 0) { lType = Type.GetType(lTypeString); }
                }

                // CDL 07/27/2018 - save this definition for removal afterwards, as we can't resolve the Type from any assembly.
                if (lType == null)
                {
                    lInvalidDefinitions.Add(i);
                    continue;
                }

                // Fill an existing existing attribute
                if (lType != null && mItems.Count > i && mItems[i].GetType() == lType)
                {
                    object lItemObj = mItems[i];

                    JSONSerializer.DeserializeInto(mItemDefinitions[i], ref lItemObj);

                    // CDL 07/27/2018 - update the serialized Type if necessary
                    if (lUpdateType)
                    {
                        //Debug.Log("Updating type: " + lItemObj.GetType().AssemblyQualifiedName);
                        mItemDefinitions[i] = JSONSerializer.Serialize(lItemObj, false);
                    }
                }
                // Create a new attribute
                else
                {
                    BasicAttribute lAttribute = JSONSerializer.Deserialize(mItemDefinitions[i]) as BasicAttribute;
                    if (lAttribute != null)
                    {
                        if (mItems.Count <= i)
                        {
                            mItems.Add(lAttribute);
                        }
                        else
                        {
                            mItems[i] = lAttribute;
                        }
                    }
                }
            }

            // Get rid of excess items
            for (int i = mItems.Count - 1; i > mItemDefinitions.Count - 1; i--)
            {
                mItems.RemoveAt(i);
            }

            // CDL 07/27.2018 - Clean up any invalid attribute definitions
            if (lInvalidDefinitions.Count > 0)
            {
                for (int i = 0; i < lInvalidDefinitions.Count; i++)
                {
                    int lIndex = lInvalidDefinitions[i];
                    mItemDefinitions.RemoveAt(lIndex);
                }
            }

            JSONSerializer.RootObject = null;
        }
コード例 #9
0
        /// <summary>
        /// Adds the attribute and returns it.
        /// </summary>
        /// <param name="rID">Attribute ID to add</param>
        /// <param name="rType">Type of attribute we'll add. It must be one of the supported types and null means tag.</param>
        /// <returns>Attribute that matches the ID</returns>
        public virtual BasicAttribute AddAttribute(string rID, Type rType = null)
        {
            // Ensure we have an ID
            if (rID.Length == 0)
            {
                rID = "Attribute";
            }

            // Ensure we have a unique ID
            string lID = rID;

            int i = 0;

            while (mItemCache.ContainsKey(lID))
            {
                i++;
                lID = rID + " (" + i + ")";
            }

            // Add the attribute
            BasicAttribute lItem = null;

            Type lType      = null;
            int  lTypeIndex = EnumAttributeTypes.GetEnum(rType);

            if (lTypeIndex == 0)
            {
                lType = typeof(BasicAttributeTag);
            }
            if (lTypeIndex == 1)
            {
                lType = typeof(BasicAttributeString);
            }
            if (lTypeIndex == 2)
            {
                lType = typeof(BasicAttributeFloat);
            }
            if (lTypeIndex == 3)
            {
                lType = typeof(BasicAttributeInt);
            }
            if (lTypeIndex == 4)
            {
                lType = typeof(BasicAttributeBool);
            }
            if (lTypeIndex == 5)
            {
                lType = typeof(BasicAttributeVector2);
            }
            if (lTypeIndex == 6)
            {
                lType = typeof(BasicAttributeVector3);
            }
            if (lTypeIndex == 7)
            {
                lType = typeof(BasicAttributeVector4);
            }
            if (lTypeIndex == 8)
            {
                lType = typeof(BasicAttributeQuaternion);
            }
            if (lTypeIndex == 9)
            {
                lType = typeof(BasicAttributeTransform);
            }
            if (lTypeIndex == 10)
            {
                lType = typeof(BasicAttributeGameObject);
            }

            if (lType != null)
            {
                lItem            = Activator.CreateInstance(lType) as BasicAttribute; // ScriptableObject.CreateInstance(lType) as BasicAttribute;
                lItem.Attributes = this;
                lItem._ID        = lID;

                mItems.Add(lItem);
                mItemCache.Add(lID, lItem);
            }

            return(lItem);
        }
コード例 #10
0
 /// <summary>
 /// Removes the specified attribute from the list of items
 /// </summary>
 /// <param name="rAttribute"></param>
 public virtual void RemoveAttribute(BasicAttribute rAttribute)
 {
     Items.Remove(rAttribute);
 }