using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class characterCustomizationManager : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public bool characterCustomizationEnabled = true;

    public string objectCategoryName = "Object";
    public string blendShapesCategoryName = "BlendShapes";
    public string accessoriesCategoryName = "Accessories";

    [Space]
    [Header ("Main Character Base Model Settings")]
    [Space]

    public characterObjectTypeInfo mainCharacterBaseInfo;

    [Space]
    [Header ("Character Sets Settings")]
    [Space]

    public List<characterObjectTypeInfo> characterObjectTypeInfoList = new List<characterObjectTypeInfo> ();

    [Space]
    [Header ("Character Accesories Settings")]
    [Space]

    public List<characterObjectTypeInfo> characterAccessoriesTypeInfoList = new List<characterObjectTypeInfo> ();

    [Space]
    [Header ("Character Blend Shapes Settings")]
    [Space]

    public List<characterBlendShapeTypeInfo> characterBlendShapeTypeInfoList = new List<characterBlendShapeTypeInfo> ();

    [Space]
    [Header ("Head Settings")]
    [Space]

    public string headObjectName = "Head";

    public List<string> objectsOnHeadList = new List<string> ();

    [Space]
    [Header ("Body Parts Settings")]
    [Space]

    public bool useMultipleBodyPartsInfoList;
    public List<multipleBodyPartsInfo> multipleBodyPartsInfoList = new List<multipleBodyPartsInfo> ();

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showDebugPrint;

    public bool keepAllCharacterMeshesDisabledActive;

    public bool headActiveTemporaly;

    [Space]
    [Header ("Current Elements Debug")]
    [Space]

    public List<string> currentPiecesList = new List<string> ();

    public List<string> currentAccessoriesList = new List<string> ();

    public List<temporalBlendshapeInfo> temporalBlendshapeInfoList = new List<temporalBlendshapeInfo> ();

    [Space]
    [Header ("Editor Settings")]
    [Space]

    public string armorSetToCreatePieceMeshesObjects;

    [Space]
    [Header ("Durability Settings")]
    [Space]

    public bool useEventOnDurabilityAffectedEnabled;

    [Space]

    public List<durabilityPartInfo> durabilityPartInfoList = new List<durabilityPartInfo> ();

    [Space]
    [Header ("Components")]
    [Space]

    public Transform characterTransform;

    public Animator mainAnimator;


    bool headActivePreviously;


    public void resetAllCharacterObjectstoMainBaseModel ()
    {
        disableAndClearAccessoriesList ();

        disableAndClearAllCharacterObjectList ();

        setMainCharacterBaseInfoFullActiveState (true);
    }

    //Functions to activate select full set templates
    public void setCustomizationFromTemplate (characterAspectCustomizationTemplate newCharacterAspectCustomizationTemplate, bool isFullSet)
    {
        if (isFullSet) {
            resetAllCharacterObjectstoMainBaseModel ();
        }

        for (int i = 0; i < newCharacterAspectCustomizationTemplate.characterCustomizationTypeInfoList.Count; i++) {
            for (int j = 0; j < newCharacterAspectCustomizationTemplate.characterCustomizationTypeInfoList [i].characterCustomizationInfoList.Count; j++) {
                setCustomizationFromOptionInfo (newCharacterAspectCustomizationTemplate.characterCustomizationTypeInfoList [i].characterCustomizationInfoList [j], isFullSet);
            }
        }
    }

    void setCustomizationFromOptionInfo (characterCustomizationInfo newCharacterCustomizationInfo, bool isFullSet)
    {
        if (showDebugPrint) {
            print (newCharacterCustomizationInfo.Name);
        }

        bool isObjectCategory = newCharacterCustomizationInfo.typeName.Equals (objectCategoryName);
        bool isAccessoriesCategory = newCharacterCustomizationInfo.typeName.Equals (accessoriesCategoryName);

        if (showDebugPrint) {
            print ("isObjectCategory " + isObjectCategory + " isAccessoriesCategory " + isAccessoriesCategory);
        }

        if (isObjectCategory || isAccessoriesCategory) {
            List<characterObjectTypeInfo> currentCharacterObjectTypeInfoList = new List<characterObjectTypeInfo> ();

            if (isObjectCategory) {
                currentCharacterObjectTypeInfoList = characterObjectTypeInfoList;
            }

            if (isAccessoriesCategory) {
                currentCharacterObjectTypeInfoList = characterAccessoriesTypeInfoList;
            }

            for (int i = 0; i < currentCharacterObjectTypeInfoList.Count; i++) {
                if (!isFullSet) {
                    for (int j = 0; j < currentCharacterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                        if (newCharacterCustomizationInfo.categoryName.Equals (currentCharacterObjectTypeInfoList [i].categoryName)) {

                            characterObjectInfo currentInfo = currentCharacterObjectTypeInfoList [i].characterObjectInfoList [j];

                            checkElementObjectInitialized (currentInfo);

                            if (currentInfo.elementObject.activeSelf != false) {
                                currentInfo.elementObject.SetActive (false);

                                if (isAccessoriesCategory) {
                                    checkCurrentAccessoriesList (currentInfo.Name, false);
                                } else {
                                    checkCurrentPieceList (currentInfo.Name, false);
                                }
                            }
                        }
                    }
                }


                //set random bool value
                bool boolValue = newCharacterCustomizationInfo.boolValue;

                if (newCharacterCustomizationInfo.useRandomBoolValue) {
                    int boolInteger = Random.Range (0, 2);

                    boolValue = (boolInteger == 0);

                    if (showDebugPrint) {
                        print ("Random bool value is " + boolValue);
                    }
                }


                //check the type of option to use for the elements to change its active state
                if (newCharacterCustomizationInfo.multipleElements) {
                    bool isCurrentOption = (currentCharacterObjectTypeInfoList [i].Name.Equals (newCharacterCustomizationInfo.Name));

                    if (isCurrentOption) {

                        for (int j = 0; j < currentCharacterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                            characterObjectInfo currentInfo = currentCharacterObjectTypeInfoList [i].characterObjectInfoList [j];

                            if (!keepAllCharacterMeshesDisabledActive || !boolValue) {
                                checkElementObjectInitialized (currentInfo);

                                if (currentInfo.elementObject.activeSelf != boolValue) {
                                    currentInfo.elementObject.SetActive (boolValue);
                                }
                            }

                            if (isAccessoriesCategory) {
                                checkCurrentAccessoriesList (currentInfo.Name, boolValue);
                            } else {
                                checkCurrentPieceList (currentInfo.Name, boolValue);
                            }

                            if (!isAccessoriesCategory) {
                                if (!currentInfo.ignoreDisableSameTypeName) {
                                    GameObject mainCharacterBaseInfoObject = getMainCharacterBaseInfoObjectByTypeName (currentInfo.typeName);

                                    if (mainCharacterBaseInfoObject != null) {
                                        checkElementObjectInitialized (currentInfo);

                                        if (mainCharacterBaseInfoObject != currentInfo.elementObject) {
                                            mainCharacterBaseInfoObject.SetActive (false);
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else if (newCharacterCustomizationInfo.useRandomObjectFromCategoryName) {
                    bool isCurrentOption = (currentCharacterObjectTypeInfoList [i].Name.Equals (newCharacterCustomizationInfo.Name));

                    if (isCurrentOption) {
                        int randomIndex = Random.Range (0, currentCharacterObjectTypeInfoList [i].characterObjectInfoList.Count);

                        characterObjectInfo currentInfo = currentCharacterObjectTypeInfoList [i].characterObjectInfoList [randomIndex];

                        if (!keepAllCharacterMeshesDisabledActive || !boolValue) {
                            checkElementObjectInitialized (currentInfo);

                            if (currentInfo.elementObject.activeSelf != boolValue) {
                                currentInfo.elementObject.SetActive (boolValue);
                            }
                        }

                        if (isAccessoriesCategory) {
                            checkCurrentAccessoriesList (currentInfo.Name, boolValue);
                        } else {
                            checkCurrentPieceList (currentInfo.Name, boolValue);
                        }

                        if (!isAccessoriesCategory) {
                            if (!currentInfo.ignoreDisableSameTypeName) {
                                GameObject mainCharacterBaseInfoObject = getMainCharacterBaseInfoObjectByTypeName (currentInfo.typeName);

                                if (mainCharacterBaseInfoObject != null) {
                                    checkElementObjectInitialized (currentInfo);

                                    if (mainCharacterBaseInfoObject != currentInfo.elementObject) {
                                        mainCharacterBaseInfoObject.SetActive (false);
                                    }
                                }
                            }
                        }
                    }
                } else {
                    for (int j = 0; j < currentCharacterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                        characterObjectInfo currentInfo = currentCharacterObjectTypeInfoList [i].characterObjectInfoList [j];

                        bool isCurrentOption = (currentInfo.Name.Equals (newCharacterCustomizationInfo.Name));

                        if (isCurrentOption) {
                            checkElementObjectInitialized (currentInfo);

                            if (!keepAllCharacterMeshesDisabledActive || !boolValue) {
                                if (currentInfo.elementObject.activeSelf != boolValue) {
                                    currentInfo.elementObject.SetActive (boolValue);
                                }
                            }

                            if (isAccessoriesCategory) {
                                checkCurrentAccessoriesList (currentInfo.Name, boolValue);
                            } else {
                                checkCurrentPieceList (currentInfo.Name, boolValue);
                            }

                            if (!isAccessoriesCategory) {
                                if (!currentInfo.ignoreDisableSameTypeName) {
                                    GameObject mainCharacterBaseInfoObject = getMainCharacterBaseInfoObjectByTypeName (currentInfo.typeName);

                                    if (mainCharacterBaseInfoObject != null) {
                                        if (mainCharacterBaseInfoObject != currentInfo.elementObject) {
                                            mainCharacterBaseInfoObject.SetActive (false);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } else if (newCharacterCustomizationInfo.typeName.Equals (blendShapesCategoryName)) {
            setBlendShapeValue (newCharacterCustomizationInfo.Name, newCharacterCustomizationInfo.floatValue,
                newCharacterCustomizationInfo.useRandomFloatValue, -1);
        }

        if (isAccessoriesCategory) {
            checkDisableAccessoryByNameAndCategory (newCharacterCustomizationInfo.categoryName, newCharacterCustomizationInfo.Name);
        }
    }

    void disableAndClearAccessoriesList ()
    {
        for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
            for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                if (currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {
                    checkElementObjectInitialized (currentAccessoryInfo);

                    if (currentAccessoryInfo.elementObject.activeSelf) {
                        currentAccessoryInfo.elementObject.SetActive (false);
                    }
                }
            }
        }

        currentAccessoriesList.Clear ();
    }

    void disableAndClearAllCharacterObjectList ()
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name)) {
                    checkElementObjectInitialized (currentInfo);

                    if (currentInfo.elementObject.activeSelf) {
                        currentInfo.elementObject.SetActive (false);
                    }

                    checkCurrentPieceList (currentInfo.Name, false);
                }
            }
        }
    }

    GameObject getMainCharacterBaseInfoObjectByTypeName (string typeName)
    {
        //		print ("checking for " + typeName);

        int characterObjectInfoListCount = mainCharacterBaseInfo.characterObjectInfoList.Count;

        for (int i = 0; i < characterObjectInfoListCount; i++) {
            characterObjectInfo currentCharacterObjectInfo = mainCharacterBaseInfo.characterObjectInfoList [i];

            if (currentCharacterObjectInfo.typeName.Equals (typeName)) {
                checkElementObjectInitialized (currentCharacterObjectInfo);

                return currentCharacterObjectInfo.elementObject;
            }
        }

        return null;
    }


    //Main functions to enable or disable character objects
    public void checkDisableAccessoryByNameAndCategory (string categoryName, string objectName)
    {
        string categoryEquipped = "";

        int accessoryCategoryIndex = -1;
        int accessoryIndex = -1;

        for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
            for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                if (characterAccessoriesTypeInfoList [i].categoryName.Equals (categoryName) && objectName.Equals (currentAccessoryInfo.Name)) {
                    categoryEquipped = currentAccessoryInfo.typeName;

                    accessoryCategoryIndex = i;

                    accessoryIndex = j;
                }
            }
        }

        if (categoryEquipped != "") {
            for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
                for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                    if (currentPiecesList.Contains (currentInfo.Name) &&
                        categoryEquipped.Equals (currentInfo.typeName)) {

                        if (currentInfo.disableAccesoriesSameTypeName) {
                            characterObjectInfo currentAccessoryInfoToDisable = characterAccessoriesTypeInfoList [accessoryCategoryIndex].characterObjectInfoList [accessoryIndex];

                            bool disableObjectResult = true;

                            if (currentInfo.useCustomAccessoryTypeListToDisable) {
                                if (!currentInfo.customAccessoryTypeListToDisable.Contains (characterAccessoriesTypeInfoList [accessoryCategoryIndex].categoryName)) {
                                    disableObjectResult = false;
                                }
                            }

                            if (disableObjectResult) {
                                checkElementObjectInitialized (currentAccessoryInfoToDisable);

                                if (currentAccessoryInfoToDisable.elementObject.activeSelf) {
                                    currentAccessoryInfoToDisable.elementObject.SetActive (false);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public bool setObjectState (bool boolValue, string objectName, bool disableOtherObjects,
                                string categoryOfObjectsToDisable, bool equippingObject)
    {
        bool objectFound = false;

        if (showDebugPrint) {
            print ("sending toggle value " + objectName + " " + boolValue + " " + disableOtherObjects + " " + categoryOfObjectsToDisable);
        }

        if (disableOtherObjects) {
            for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {

                for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    if (categoryOfObjectsToDisable.Equals (characterObjectTypeInfoList [i].categoryName)) {

                        characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                        bool checkResult = false;

                        checkElementObjectInitialized (currentInfo);

                        if (keepAllCharacterMeshesDisabledActive) {
                            if (currentPiecesList.Contains (currentInfo.Name)) {
                                checkResult = true;
                            }
                        } else {
                            if (currentInfo.elementObject.activeSelf != false) {
                                checkResult = true;
                            }
                        }

                        if (checkResult) {
                            currentInfo.elementObject.SetActive (false);

                            checkCurrentPieceList (currentInfo.Name, false);
                        }
                    }
                }
            }

            for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {

                for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    if (categoryOfObjectsToDisable.Equals (characterAccessoriesTypeInfoList [i].categoryName)) {

                        characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                        checkElementObjectInitialized (currentAccessoryInfo);

                        bool checkResult = false;

                        if (keepAllCharacterMeshesDisabledActive) {
                            if (currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {
                                checkResult = true;
                            }
                        } else {
                            if (currentAccessoryInfo.elementObject.activeSelf != false) {
                                checkResult = true;
                            }
                        }

                        if (checkResult) {
                            currentAccessoryInfo.elementObject.SetActive (false);

                            checkCurrentAccessoriesList (currentAccessoryInfo.Name, false);
                        }
                    }
                }
            }
        }

        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                bool isCurrentOption = (currentInfo.Name.Equals (objectName));

                if (isCurrentOption) {
                    checkElementObjectInitialized (currentInfo);

                    bool checkResult = false;

                    if (keepAllCharacterMeshesDisabledActive) {
                        if (currentPiecesList.Contains (currentInfo.Name) || boolValue) {
                            checkResult = true;
                        }
                    } else {
                        if (equippingObject) {
                            checkResult = true;
                        } else {
                            if (currentInfo.elementObject.activeSelf != boolValue) {
                                checkResult = true;
                            }
                        }
                    }

                    if (checkResult) {
                        if (!keepAllCharacterMeshesDisabledActive) {
                            currentInfo.elementObject.SetActive (boolValue);
                        }

                        checkCurrentPieceList (currentInfo.Name, boolValue);
                    }

                    objectFound = true;
                }
            }
        }

        if (!objectFound) {
            for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
                for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                    bool isCurrentOption = (currentAccessoryInfo.Name.Equals (objectName));

                    if (isCurrentOption) {
                        checkElementObjectInitialized (currentAccessoryInfo);

                        bool checkResult = false;

                        if (keepAllCharacterMeshesDisabledActive) {
                            if (currentAccessoriesList.Contains (currentAccessoryInfo.Name) || boolValue) {
                                checkResult = true;
                            }
                        } else {
                            if (currentAccessoryInfo.elementObject.activeSelf != boolValue) {
                                checkResult = true;
                            }
                        }

                        if (checkResult) {
                            if (!keepAllCharacterMeshesDisabledActive) {
                                currentAccessoryInfo.elementObject.SetActive (boolValue);
                            }

                            checkCurrentAccessoriesList (currentAccessoryInfo.Name, boolValue);
                        }

                        objectFound = true;
                    }
                }
            }
        }

        return objectFound;
    }

    public void setBlendShapeValue (string blendShapeName, float blendShapeValue, bool useRandomFloatValue, float sliderMaxValue)
    {
        for (int i = 0; i < characterBlendShapeTypeInfoList.Count; i++) {
            for (int j = 0; j < characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList.Count; j++) {
                characterBlendShapeInfo currentInfo = characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList [j];

                bool isCurrentOption = (currentInfo.Name.Equals (blendShapeName));

                if (showDebugPrint) {
                    print (blendShapeName + " " + isCurrentOption + " " + blendShapeValue + " " + sliderMaxValue);
                }

                if (isCurrentOption) {

                    Vector2 blendShapeLimits = currentInfo.blendShapeLimits;

                    if (sliderMaxValue > -1) {
                        blendShapeValue = (blendShapeLimits.y / sliderMaxValue) * blendShapeValue;
                    }

                    if (useRandomFloatValue) {
                        blendShapeValue = Random.Range (blendShapeLimits.x, blendShapeLimits.y);
                    } else {
                        blendShapeValue = Mathf.Clamp (blendShapeValue, blendShapeLimits.x, blendShapeLimits.y);
                    }

                    characterBlendShapeTypeInfoList [i].mainSkinnedMeshRenderer.SetBlendShapeWeight (currentInfo.blendShapeIndex, blendShapeValue);
                }
            }
        }
    }

    public float getBlendShapeValue (string blendShapeName, float sliderMaxValue)
    {
        for (int i = 0; i < characterBlendShapeTypeInfoList.Count; i++) {
            for (int j = 0; j < characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList.Count; j++) {
                characterBlendShapeInfo currentInfo = characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList [j];

                bool isCurrentOption = (currentInfo.Name.Equals (blendShapeName));

                if (isCurrentOption) {

                    float blendShapeValue = characterBlendShapeTypeInfoList [i].mainSkinnedMeshRenderer.GetBlendShapeWeight (currentInfo.blendShapeIndex);

                    return blendShapeValue / (characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList [j].blendShapeLimits.y / sliderMaxValue);
                }
            }
        }

        return -1;
    }

    public List<string> getExtraTypeNameListObjectByName (string objectName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {

            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentInfo.useExtraTypeNameList && currentInfo.Name.Equals (objectName)) {
                    return currentInfo.extraTypeNameList;
                }
            }
        }

        for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {

            for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                if (currentAccessoryInfo.useExtraTypeNameList && currentAccessoryInfo.Name.Equals (objectName)) {
                    return currentAccessoryInfo.extraTypeNameList;
                }
            }
        }

        return null;
    }

    public void setEditActiveState (bool state)
    {

    }

    public List<temporalBlendshapeInfo> getTemporalBlendshapeInfoList ()
    {
        temporalBlendshapeInfoList.Clear ();

        for (int i = 0; i < characterBlendShapeTypeInfoList.Count; i++) {
            for (int j = 0; j < characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList.Count; j++) {
                characterBlendShapeInfo currentInfo = characterBlendShapeTypeInfoList [i].characterBlendShapeInfoList [j];

                float blendShapeValue = characterBlendShapeTypeInfoList [i].mainSkinnedMeshRenderer.GetBlendShapeWeight (currentInfo.blendShapeIndex);

                temporalBlendshapeInfo newTemporalBlendshapeInfo = new temporalBlendshapeInfo ();

                newTemporalBlendshapeInfo.Name = currentInfo.Name;
                newTemporalBlendshapeInfo.blendShapeValue = blendShapeValue;

                temporalBlendshapeInfoList.Add (newTemporalBlendshapeInfo);
            }
        }

        return temporalBlendshapeInfoList;
    }

    //Functions to enable or disable the head meshes if needed
    public void enableOrDisableHeadTemporaly (bool state)
    {
        if (headActiveTemporaly == state) {
            return;
        }

        headActiveTemporaly = state;

        GameObject mainCharacterBaseInfoObject = getMainCharacterBaseInfoObjectByTypeName (headObjectName);

        if (state) {
            headActivePreviously = isObjectActiveOnMainCharacterBaseInfo (headObjectName);

            if (!headActivePreviously) {
                if (mainCharacterBaseInfoObject != null && mainCharacterBaseInfoObject.activeSelf != state) {
                    mainCharacterBaseInfoObject.SetActive (state);
                }
            }

        } else {
            if (!headActivePreviously) {
                if (mainCharacterBaseInfoObject != null && mainCharacterBaseInfoObject.activeSelf != state) {
                    mainCharacterBaseInfoObject.SetActive (state);
                }
            }
        }

        bool setActiveStateValue = !state;

        if (isObjectTypeOnCurrentPiecesList (headObjectName)) {
            for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
                for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                    if (currentPiecesList.Contains (currentInfo.Name) && currentInfo.typeName.Equals (headObjectName)) {

                        if (!keepAllCharacterMeshesDisabledActive || !setActiveStateValue) {
                            checkElementObjectInitialized (currentInfo);

                            if (currentInfo.elementObject.activeSelf != setActiveStateValue) {
                                currentInfo.elementObject.SetActive (setActiveStateValue);
                            }
                        }
                    }
                }
            }

            for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
                for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {

                    characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                    //					print ("checking accessory on head state " + characterAccessoriesTypeInfoList [i].Name + " " + currentInfo.Name
                    //					+ " " + (currentAccessoriesList.Contains (currentInfo.Name)));

                    if (objectsOnHeadList.Contains (characterAccessoriesTypeInfoList [i].Name) &&
                        currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {

                        //						print ("object located, setting state " + setActiveStateValue);

                        if (!keepAllCharacterMeshesDisabledActive || setActiveStateValue) {
                            checkElementObjectInitialized (currentAccessoryInfo);

                            if (currentAccessoryInfo.elementObject.activeSelf == setActiveStateValue) {
                                bool setActiveResult = !setActiveStateValue;

                                if (!keepAllCharacterMeshesDisabledActive) {
                                    if (!setActiveResult) {
                                        if (checkIfAccessoryCanRemainActive (currentAccessoryInfo.typeName, characterAccessoriesTypeInfoList [i].categoryName)) {
                                            setActiveResult = true;
                                        }
                                    }
                                }

                                currentAccessoryInfo.elementObject.SetActive (setActiveResult);
                            }
                        }
                    }
                }
            }
        }
    }

    bool isObjectTypeOnCurrentPiecesList (string categoryName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name) && currentInfo.typeName.Equals (categoryName)) {

                    return true;
                }
            }
        }

        return false;
    }

    bool isObjectActiveOnMainCharacterBaseInfo (string categoryName)
    {
        int characterObjectInfoListCount = mainCharacterBaseInfo.characterObjectInfoList.Count;

        for (int i = 0; i < characterObjectInfoListCount; i++) {
            characterObjectInfo currentCharacterObjectInfo = mainCharacterBaseInfo.characterObjectInfoList [i];

            if (currentCharacterObjectInfo.typeName.Equals (categoryName)) {
                checkElementObjectInitialized (currentCharacterObjectInfo);

                return currentCharacterObjectInfo.elementObject.activeSelf;
            }
        }

        return false;
    }

    bool checkIfAccessoryCanRemainActive (string typeName, string accessoryCategoryName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name) && typeName.Equals (currentInfo.typeName)) {

                    if (currentInfo.disableAccesoriesSameTypeName) {
                        bool disableObjectResult = true;

                        if (currentInfo.useCustomAccessoryTypeListToDisable) {
                            if (!currentInfo.customAccessoryTypeListToDisable.Contains (accessoryCategoryName)) {
                                disableObjectResult = false;
                            }
                        }

                        return !disableObjectResult;
                    }
                }
            }
        }

        return false;
    }


    //Functions to check the change of view to third or first person
    public void checkCameraViewToFirstOrThirdPerson (bool state)
    {
        if (!characterCustomizationEnabled) {
            return;
        }

        //If state is true, it is activating the first person view, so the meshes are disabled

        if (!state) {
            setMainCharacterBaseInfoFullActiveState (true);
        }

        //set main armor pieces state to show or hide all
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name)) {
                    checkElementObjectInitialized (currentInfo);

                    if (currentInfo.elementObject.activeSelf == state) {
                        currentInfo.elementObject.SetActive (!state);
                    }

                    GameObject mainCharacterBaseInfoObject = getMainCharacterBaseInfoObjectByTypeName (currentInfo.typeName);

                    if (mainCharacterBaseInfoObject != null) {
                        //check base model parts to show or hide all
                        if (!state) {
                            //							mainCharacterBaseInfoObject.SetActive (false);
                            //						} else {
                            if (!currentInfo.ignoreDisableSameTypeName) {

                                if (mainCharacterBaseInfoObject != currentInfo.elementObject) {
                                    mainCharacterBaseInfoObject.SetActive (false);
                                }
                            }
                        }
                    }
                }
            }
        }

        //check accessories which can be shown in regular state or hide all
        for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
            for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                if (currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {
                    checkElementObjectInitialized (currentAccessoryInfo);

                    if (currentAccessoryInfo.elementObject.activeSelf == state) {
                        currentAccessoryInfo.elementObject.SetActive (!state);

                        if (!state) {
                            checkDisableAccessoryByNameAndCategory (characterAccessoriesTypeInfoList [i].categoryName, currentAccessoryInfo.Name);
                        }
                    }
                }
            }
        }

        if (state) {
            setMainCharacterBaseInfoFullActiveState (false);
        }

        keepAllCharacterMeshesDisabledActive = state;
    }

    void setMainCharacterBaseInfoFullActiveState (bool state)
    {
        int characterObjectInfoListCount = mainCharacterBaseInfo.characterObjectInfoList.Count;

        for (int i = 0; i < characterObjectInfoListCount; i++) {
            characterObjectInfo currentCharacterObjectInfo = mainCharacterBaseInfo.characterObjectInfoList [i];

            checkElementObjectInitialized (currentCharacterObjectInfo);

            if (currentCharacterObjectInfo.elementObject.activeSelf != state) {
                currentCharacterObjectInfo.elementObject.SetActive (state);
            }
        }
    }

    public void checkEquippedStateOnObject (bool state, string objectName, string categoryName)
    {
        bool disableAccesoriesSameTypeName = false;

        bool ignoreDisableSameTypeName = false;

        bool useCustomAccessoryTypeListToDisable = false;

        List<string> customAccessoryTypeListToDisable = new List<string> ();

        GameObject currentObjectEquipped = null;

        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (objectName.Contains (currentInfo.Name) && categoryName.Equals (currentInfo.typeName)) {

                    disableAccesoriesSameTypeName = currentInfo.disableAccesoriesSameTypeName;

                    useCustomAccessoryTypeListToDisable = currentInfo.useCustomAccessoryTypeListToDisable;

                    if (useCustomAccessoryTypeListToDisable) {
                        customAccessoryTypeListToDisable = currentInfo.customAccessoryTypeListToDisable;
                    }

                    ignoreDisableSameTypeName = currentInfo.ignoreDisableSameTypeName;

                    checkElementObjectInitialized (currentInfo);

                    currentObjectEquipped = currentInfo.elementObject;
                }
            }
        }

        //		print (disableAccesoriesSameTypeName + " " + state + " " + categoryName + " " + objectName
        //		+ " " + ignoreDisableSameTypeName + " " + useCustomAccessoryTypeListToDisable);

        if (disableAccesoriesSameTypeName) {
            for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
                for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                    characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                    if (categoryName.Equals (currentAccessoryInfo.typeName) &&
                        currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {

                        if (disableAccesoriesSameTypeName) {

                            bool disableObjectResult = true;

                            if (state) {
                                if (useCustomAccessoryTypeListToDisable) {
                                    if (customAccessoryTypeListToDisable.Count == 0) {
                                        disableObjectResult = false;
                                    } else {
                                        if (!customAccessoryTypeListToDisable.Contains (characterAccessoriesTypeInfoList [i].categoryName)) {
                                            disableObjectResult = false;
                                        }
                                    }
                                }
                            }

                            if (disableObjectResult) {
                                checkElementObjectInitialized (currentAccessoryInfo);

                                if (currentAccessoryInfo.elementObject.activeSelf == state) {
                                    if (!keepAllCharacterMeshesDisabledActive || state) {
                                        currentAccessoryInfo.elementObject.SetActive (!state);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        bool baseModelObjectState = state;

        if (ignoreDisableSameTypeName && state) {
            baseModelObjectState = !state;
        }

        int characterObjectInfoListCount = mainCharacterBaseInfo.characterObjectInfoList.Count;

        for (int i = 0; i < characterObjectInfoListCount; i++) {
            characterObjectInfo currentCharacterObjectInfo = mainCharacterBaseInfo.characterObjectInfoList [i];

            if (currentCharacterObjectInfo.typeName.Equals (categoryName)) {
                checkElementObjectInitialized (currentCharacterObjectInfo);

                if (currentCharacterObjectInfo.elementObject.activeSelf == baseModelObjectState) {
                    if (!keepAllCharacterMeshesDisabledActive || baseModelObjectState) {
                        bool canSetActiveState = true;

                        //if the same object equipped is the same that is on the base model, ignore to disable its mesh
                        if (baseModelObjectState) {
                            if (currentCharacterObjectInfo.elementObject == currentObjectEquipped) {
                                canSetActiveState = false;
                            }
                        }

                        if (canSetActiveState) {
                            currentCharacterObjectInfo.elementObject.SetActive (!baseModelObjectState);
                        }
                    }
                }

                if (showDebugPrint) {
                    print ("checking to enable or disable base mesh " + baseModelObjectState + "  " + categoryName + "  " + objectName);
                }
            }
        }

        List<string> extraTypeNameList = getExtraTypeNameListObjectByName (objectName);

        if (extraTypeNameList != null && extraTypeNameList.Count > 0) {
            for (int i = 0; i < characterObjectInfoListCount; i++) {
                characterObjectInfo currentCharacterObjectInfo = mainCharacterBaseInfo.characterObjectInfoList [i];

                if (extraTypeNameList.Contains (currentCharacterObjectInfo.typeName)) {
                    checkElementObjectInitialized (currentCharacterObjectInfo);

                    if (currentCharacterObjectInfo.elementObject.activeSelf == baseModelObjectState) {
                        if (!keepAllCharacterMeshesDisabledActive || baseModelObjectState) {
                            currentCharacterObjectInfo.elementObject.SetActive (!baseModelObjectState);
                        }
                    }

                    if (showDebugPrint) {
                        print ("checking to enable or disable base mesh " + baseModelObjectState + "  " + categoryName + "  " + objectName);
                    }
                }
            }
        }
    }


    //FUNCTIONS USED TO INITIALIZE THE ELEMENTS ON LOAD GAME
    public void setBlendshapeList (List<temporalBlendshapeInfo> newTemporalBlendshapeInfoList)
    {
        for (int i = 0; i < newTemporalBlendshapeInfoList.Count; i++) {

            setBlendShapeValue (newTemporalBlendshapeInfoList [i].Name, newTemporalBlendshapeInfoList [i].blendShapeValue, false, -1);
        }
    }

    public List<string> getCurrentPiecesList ()
    {
        return currentPiecesList;
    }

    public List<string> getCurrentAccessoriesList ()
    {
        return currentAccessoriesList;
    }

    public void setCurrentAccessoriesList (List<string> newTemporalAccessoriesList)
    {
        currentAccessoriesList = newTemporalAccessoriesList;

        for (int i = 0; i < characterAccessoriesTypeInfoList.Count; i++) {
            for (int j = 0; j < characterAccessoriesTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentAccessoryInfo = characterAccessoriesTypeInfoList [i].characterObjectInfoList [j];

                if (currentAccessoriesList.Contains (currentAccessoryInfo.Name)) {
                    checkElementObjectInitialized (currentAccessoryInfo);

                    if (!currentAccessoryInfo.elementObject.activeSelf) {
                        if (!keepAllCharacterMeshesDisabledActive) {
                            currentAccessoryInfo.elementObject.SetActive (true);
                        }

                        checkDisableAccessoryByNameAndCategory (characterAccessoriesTypeInfoList [i].categoryName, currentAccessoryInfo.Name);
                    }
                }
            }
        }
    }


    //Other functions
    public string getArmorClothPieceByName (string categoryName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name) && currentInfo.typeName.Equals (categoryName)) {

                    return currentInfo.Name;
                }
            }
        }

        return "";
    }

    List<string> getArmorClothPieceListByCategoryName (string categoryName)
    {
        List<string> armorPartsSameTypeEquippedList = new List<string> ();

        int characterObjectTypeInfoListCount = characterObjectTypeInfoList.Count;

        for (int i = 0; i < characterObjectTypeInfoListCount; i++) {
            int characterObjectInfoListCount = characterObjectTypeInfoList [i].characterObjectInfoList.Count;

            for (int j = 0; j < characterObjectInfoListCount; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentPiecesList.Contains (currentInfo.Name) && currentInfo.typeName.Equals (categoryName)) {

                    armorPartsSameTypeEquippedList.Add (currentInfo.Name);
                }
            }
        }

        return armorPartsSameTypeEquippedList;
    }

    public string getArmorClothCategoryByName (string objectName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentInfo.Name.Equals (objectName)) {

                    return currentInfo.typeName;
                }
            }
        }

        return "";
    }

    public List<string> checkIfArmorPartCanBeEquippedOnSameBodyPart (string objectName)
    {
        List<string> armorPartsSameTypeEquippedList = new List<string> ();

        string categoryName = getArmorClothCategoryByName (objectName);

        //print (objectName);

        if (categoryName != "") {
            bool anyObjectOfSameTypeEquipped = isObjectTypeOnCurrentPiecesList (categoryName);

            if (anyObjectOfSameTypeEquipped) {
                string armorPartSameTypeEquippedName = getArmorClothPieceByName (categoryName);

                if (armorPartSameTypeEquippedName != "") {
                    //print (armorPartSameTypeEquippedName);

                    characterObjectInfo currentInfo = getcharacterObjectInfoByName (armorPartSameTypeEquippedName);

                    if (currentInfo != null) {
                        //print (currentInfo.Name + " " + currentInfo.allowMultipleArmorPartsEquipped);

                        bool canEquipMultiplePartsResult = false;

                        //if (currentInfo.allowMultipleArmorPartsEquipped) {
                        //    if (currentInfo.multipleArmorPartsToAllowToEquipList.Contains (objectName)) {
                        //        armorPartsSameTypeEquippedList.Add (armorPartSameTypeEquippedName);

                        //        canEquipMultiplePartsResult = true;
                        //    }
                        //} else {

                        if (useMultipleBodyPartsInfoList) {
                            for (int i = 0; i < multipleBodyPartsInfoList.Count; i++) {
                                if (multipleBodyPartsInfoList [i].listEnabled) {
                                    if (multipleBodyPartsInfoList [i].armorPartsAllowedTogetherList.Contains (objectName) &&
                                        multipleBodyPartsInfoList [i].armorPartsAllowedTogetherList.Contains (armorPartSameTypeEquippedName)) {
                                        armorPartsSameTypeEquippedList.Add (armorPartSameTypeEquippedName);

                                        canEquipMultiplePartsResult = true;
                                    }
                                }
                            }
                        } else {
                            //print ("not found");
                        }
                        //}

                        if (!canEquipMultiplePartsResult) {
                            armorPartsSameTypeEquippedList = getArmorClothPieceListByCategoryName (categoryName);

                            armorPartsSameTypeEquippedList.Add ("");
                        }
                    }
                }
            }
        }

        return armorPartsSameTypeEquippedList;
    }

    characterObjectInfo getcharacterObjectInfoByName (string objectName)
    {
        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                if (currentInfo.Name.Equals (objectName)) {
                    return currentInfo;
                }
            }
        }

        return null;
    }

    public bool checkIfObjectAlreadyOnCurrentPiecesList (string pieceName)
    {
        return currentPiecesList.Contains (pieceName);
    }

    void checkCurrentPieceList (string pieceName, bool checkToAdd)
    {
        if (checkToAdd) {
            if (!currentPiecesList.Contains (pieceName)) {
                currentPiecesList.Add (pieceName);
            }
        } else {
            if (currentPiecesList.Contains (pieceName)) {
                currentPiecesList.Remove (pieceName);
            }
        }
    }

    void checkCurrentAccessoriesList (string pieceName, bool checkToAdd)
    {
        if (checkToAdd) {
            if (!currentAccessoriesList.Contains (pieceName)) {
                currentAccessoriesList.Add (pieceName);
            }
        } else {
            if (currentAccessoriesList.Contains (pieceName)) {
                currentAccessoriesList.Remove (pieceName);
            }
        }
    }

    //Durability Functions
    public void checkEventOnDurabilityAffected (string bodyPartName)
    {
        if (useEventOnDurabilityAffectedEnabled) {
            if (showDebugPrint) {
                print ("checking event on durability on body part " + bodyPartName);
            }

            for (int i = 0; i < durabilityPartInfoList.Count; i++) {
                if (durabilityPartInfoList [i].Name.Equals (bodyPartName)) {
                    durabilityPartInfoList [i].eventOnDurabilityAffectedEnabled.Invoke ();

                    return;
                }
            }
        }
    }

    public void setCharacterTransform (Transform newTransform)
    {
        if (characterTransform == null) {
            characterTransform = newTransform;

            if (characterTransform != null && mainAnimator == null) {
                mainAnimator = characterTransform.GetComponent<Animator> ();
            }
        }
    }

    void checkElementObjectInitialized (characterObjectInfo currentCharacterObjectInfo)
    {
        if (currentCharacterObjectInfo.spawnElementObject) {
            if (!currentCharacterObjectInfo.objectInstantiated) {
                Transform newObjectParent = null;

                if (characterTransform != null) {
                    newObjectParent = GKC_Utils.getMountPointTransformByName (currentCharacterObjectInfo.objectMountPointName,
                    characterTransform);
                }

                if (characterTransform == null || newObjectParent == null) {
                    newObjectParent = mainAnimator.GetBoneTransform (currentCharacterObjectInfo.humanBodyBone);
                }

                if (characterTransform != null) {
                    GameObject newElementObject = Instantiate (currentCharacterObjectInfo.objectToSpawn, newObjectParent);

                    if (currentCharacterObjectInfo.useCustomSpawnPositionRotation) {
                        newElementObject.transform.localPosition = currentCharacterObjectInfo.customSpawnPosition;
                        newElementObject.transform.localEulerAngles = currentCharacterObjectInfo.customSpawnRotation;
                    } else {
                        newElementObject.transform.localPosition = Vector3.zero;
                        newElementObject.transform.localEulerAngles = Vector3.zero;
                    }

                    currentCharacterObjectInfo.elementObject = newElementObject;
                }

                currentCharacterObjectInfo.objectInstantiated = true;
            }
        }
    }

    public void renamePiece (string currentObjectName, string newObjectName)
    {
        bool pieceFoundResult = false;

        for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
            for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                characterObjectInfo currentInfo = characterObjectTypeInfoList [i].characterObjectInfoList [j];

                bool isCurrentOption = (currentInfo.Name.Equals (currentObjectName));

                if (isCurrentOption) {
                    currentInfo.Name = newObjectName;

                    pieceFoundResult = true;
                }
            }
        }

        if (pieceFoundResult) {
            updateComponent ();
        }
    }

    //Editor functions
    public void createPieceMeshesObjectsFromSetByName ()
    {
        if (armorSetToCreatePieceMeshesObjects != "") {
            for (int i = 0; i < characterObjectTypeInfoList.Count; i++) {
                if (characterObjectTypeInfoList [i].Name.Equals (armorSetToCreatePieceMeshesObjects)) {
                    print (armorSetToCreatePieceMeshesObjects + " located ");

                    for (int j = 0; j < characterObjectTypeInfoList [i].characterObjectInfoList.Count; j++) {
                        checkElementObjectInitialized (characterObjectTypeInfoList [i].characterObjectInfoList [j]);

                        GKC_Utils.createPieceMeshesObjectsFromSetByName (characterObjectTypeInfoList [i].characterObjectInfoList [j].elementObject,
                            characterObjectTypeInfoList [i].characterObjectInfoList [j].Name);
                    }

                    armorSetToCreatePieceMeshesObjects = "";

                    return;
                }
            }
        }
    }

    public void checkCameraViewToFirstOrThirdPersonOnEditor (bool state)
    {
        keepAllCharacterMeshesDisabledActive = state;

        updateComponent ();
    }

    void updateComponent ()
    {
        GKC_Utils.updateComponent (this);

        GKC_Utils.updateDirtyScene ("Update Character Customization Manager Values", gameObject);
    }

    [System.Serializable]
    public class characterObjectInfo
    {
        [Header ("Main Settings")]
        [Space]

        public string Name;

        public string typeName;

        [Space]

        public GameObject elementObject;

        [Space]

        public bool ignoreDisableSameTypeName;

        [Space]

        public bool disableAccesoriesSameTypeName;

        public bool useCustomAccessoryTypeListToDisable;

        public List<string> customAccessoryTypeListToDisable = new List<string> ();

        //[Space]
        //[Space]

        //public bool allowMultipleArmorPartsEquipped;

        //public List<string> multipleArmorPartsToAllowToEquipList = new List<string> ();

        [Space]
        [Header ("Type Settings")]
        [Space]

        public bool useExtraTypeNameList;

        public List<string> extraTypeNameList = new List<string> ();

        [Space]
        [Header ("Spawn Object Settings")]
        [Space]

        public bool spawnElementObject;

        public string objectMountPointName;
        public HumanBodyBones humanBodyBone;

        public GameObject objectToSpawn;

        [Space]

        public bool useCustomSpawnPositionRotation;
        public Vector3 customSpawnPosition;
        public Vector3 customSpawnRotation;

        [HideInInspector] public bool objectInstantiated;
    }

    [System.Serializable]
    public class characterObjectTypeInfo
    {
        public string Name;

        public string categoryName;

        [Space]

        public List<characterObjectInfo> characterObjectInfoList = new List<characterObjectInfo> ();
    }

    [System.Serializable]
    public class characterBlendShapeInfo
    {
        public string Name;

        public int blendShapeIndex;
        public float blendShapeValue;
        public Vector2 blendShapeLimits;
    }

    [System.Serializable]
    public class characterBlendShapeTypeInfo
    {
        public string Name;
        public SkinnedMeshRenderer mainSkinnedMeshRenderer;

        [Space]

        public List<characterBlendShapeInfo> characterBlendShapeInfoList = new List<characterBlendShapeInfo> ();
    }

    [System.Serializable]
    public class temporalBlendshapeInfo
    {
        public string Name;

        public float blendShapeValue;
    }


    [System.Serializable]
    public class durabilityPartInfo
    {
        public string Name;

        [Space]

        public UnityEvent eventOnDurabilityAffectedEnabled;

    }

    [System.Serializable]
    public class multipleBodyPartsInfo
    {
        public string Name;

        public bool listEnabled;

        [Space]

        public List<string> armorPartsAllowedTogetherList = new List<string> ();
    }
}