Synty's Character Cleaner For Blink's RPG Builder

/*************************************************************************************************
 *  1.1 - 19/01/2021 by MaximilianPS                                                             *
 *                                                                                               *
 *  This piece of cake as been made to makes a bit easier to setup the character for             *
 *  RPG Builder by Blink.                                                                        *
 *  It will re-organize the hierarchy structure for the Modular Character from Synty.            *
 *  You will have Chest with Upper Arms (booth arms) and same for gloves and boots.              *
 *  Will be created a parent object that will store the left and right element so you            *
 *  have to just enable the parent to have booth gloves or boots enabled.                        *
 *  Same for the Chest, once activated the Parent, also booth upper arms will be visibile.       *
 *                                                                                               *
 *  Anyway the code should be extremely easy to be modified for any use.                         *
 *                                                                                               *
 *                                                             And soz for my English ^^"        *
 *************************************************************************************************/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Linq;

namespace MaximilianPs
{
    [ExecuteInEditMode]
    public class SetupSyntyHero4RPGB : MonoBehaviour
    {
        private enum Gender { Male, Female }
        private GameObject body;
        private GameObject hair;
        private GameObject head;
        private GameObject beard;
        private GameObject ear;
        private GameObject headgear;
        private GameObject headgearDeco;
        private GameObject headgearNoHair;
        private GameObject headgearNoBeard;
        private GameObject headgearNoHead;
        private GameObject armor;
        private GameObject chest;
        private GameObject elbows;
        private GameObject shoulders;
        private GameObject lowerArms;
        private GameObject back;
        private GameObject hands;
        private GameObject pants;
        private GameObject hipsAttachmentRight;
        private GameObject hipsAttachmentLeft;
        private GameObject knees;
        private GameObject boots;

        [SerializeField]
        [Tooltip("Within which GameObject the body parts are contained (usually Modular_Characters)")]
        private Transform parent;

        [Space]
        [SerializeField]
        private Gender gender = Gender.Male;

        [Space]
        [SerializeField]
        [Tooltip("WARNING THIS WILL REMOVE ALL OPPOSITE GENDER GAMEOBJECTS")]
        private bool removeOppositeGender = false;
        [SerializeField]
        [Tooltip("START TO MOVE THE ENTIRE UNIVERSE!")]
        private bool startSettingUp = false;

        private void Update()
        {
            if(startSettingUp)
            {
                startSettingUp = false;
                Debug.Log("Starting the job");
                SetItUp(gender);
            }
        }

        private void SetItUp(Gender gender)
        {
            DisableOppositeGenderGameObjects();
            CreateParents();

            // Store all elements in an array to speedup operations =)
            var elements = parent.gameObject.GetComponentsInChildren(typeof(Renderer), true);

            // HEAD
            Debug.Log("Working on heads...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_Head_"+ gender))
                {
                    elements[i].transform.parent = head.transform;

                    if(StringTail(elements[i].transform.name.ToString(), 2) != "00")
                        elements[i].gameObject.SetActive(false);
                }
            }

            // EARS
            Debug.Log("Working on ears...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_Ear_"))
                {
                    elements[i].transform.parent = ear.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HAIRS
            Debug.Log("Working on hairs...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_Hair_"))
                {
                    elements[i].transform.parent = hair.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // BEARDS
            Debug.Log("Working on beards...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_FacialHair_"))
                {
                    elements[i].transform.parent = beard.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HEADGEAR GEAR
            Debug.Log("Working on Headgears...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Base_Hair_"))
                {
                    elements[i].transform.parent = headgear.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HEADGEAR NO BEARDS
            Debug.Log("Working on headgears without beards...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("No_FacialHair_"))
                {
                    elements[i].transform.parent = headgearNoBeard.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HEADGEAR NO HAIRS
            Debug.Log("Working on headgears without hair...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("No_Hair_"))
                {
                    elements[i].transform.parent = headgearNoHair.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HEADGEAR NO HEAD
            Debug.Log("Working on headgears without heads...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("No_Elements_" + gender))
                {
                    elements[i].transform.parent = headgearNoHead.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // HEADGEAR DECO
            Debug.Log("Working on headgears decorations...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_HelmetAttachment_"))
                {
                    elements[i].transform.parent = headgearDeco.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // BACK
            Debug.Log("Working on back accessories...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_BackAttachment_"))
                {
                    elements[i].transform.parent = back.transform;
                    elements[i].gameObject.SetActive(false);
                }
            }

            // CHEST
            // this will include also Upper Arms (left and right) so there's a bit of job to do:
            // We need a new GameObject called Chest_XX that will be the parent for the Chest armor and the corresponding arms!
            Debug.Log("Working on chest armors...");
            for (int i = 0; i < elements.Length; i++)
            {

                if (elements[i].transform.name.Contains("Chr_Torso_" + gender))
                {
                    // Creating the Arms strings
                    string armLeftName = "Chr_ArmUpperLeft_" + gender + "_" + StringTail(elements[i].transform.name, 2);
                    string armRightName = "Chr_ArmUpperRight_" + gender + "_" + StringTail(elements[i].transform.name, 2);

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component armLeft = elements.Where(obj => obj.name == armLeftName).FirstOrDefault();
                    Component armRight = elements.Where(obj => obj.name == armRightName).FirstOrDefault();

                    // Creating the Chest parent.
                    GameObject torso = new GameObject();
                    torso.name = "Chest";
                    torso.gameObject.AddComponent<SkinnedMeshRenderer>();

                    if (StringTail(elements[i].transform.name, 2) == "00")
                    {
                        // Move the Chest parent inside the body, this one is the naked version
                        torso.transform.parent = body.transform;

                        elements[i].transform.parent = torso.transform;
                        armLeft.transform.parent = torso.transform;
                        armRight.transform.parent = torso.transform;

                    }
                    else
                    {
                        // Moving the chest inside the new parent object
                        elements[i].transform.parent = torso.transform;

                        if(armRight != null)
                        {
                            armLeft.transform.parent = torso.transform;
                            armRight.transform.parent = torso.transform;
                        }

                        torso.name = "Chest_" + StringTail(elements[i].name, 2);
                        torso.transform.parent = chest.transform;   // Moving the current Armor Parent, inside the \ARMOR\CHEST\...
                        torso.gameObject.SetActive(false);
                    }
                }
            }

            // SHOULDERS
            Debug.Log("Working on shoulders armors...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_ShoulderAttachRight_"))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parentShoulders = new GameObject();
                    parentShoulders.name = "Shoulders_" + partIndex;

                    // Creating the shoulder(s) strings
                    string shoulderLeftName = "Chr_ShoulderAttachLeft_" + partIndex;
                    string shoulderRightName = "Chr_ShoulderAttachRight_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component shoulderLeft = elements.Where(obj => obj.name == shoulderLeftName).FirstOrDefault();
                    Component shoulderRight = elements.Where(obj => obj.name == shoulderRightName).FirstOrDefault();

                    shoulderLeft.transform.parent = parentShoulders.transform;
                    shoulderRight.transform.parent = parentShoulders.transform;

                    parentShoulders.gameObject.AddComponent<SkinnedMeshRenderer>();
                    parentShoulders.transform.parent = shoulders.transform;
                    parentShoulders.gameObject.SetActive(false);
                }
            }

            // ELBOWS
            Debug.Log("Working on elbows armors...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_ElbowAttachRight_"))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parentElbow = new GameObject();
                    parentElbow.name = "Elbows_" + partIndex;

                    // Creating the shoulder(s) strings
                    string elbowLeftName = "Chr_ElbowAttachLeft_" + partIndex;
                    string elbowRightName = "Chr_ElbowAttachRight_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component elbowLeft = elements.Where(obj => obj.name == elbowLeftName).FirstOrDefault();
                    Component elbowRight = elements.Where(obj => obj.name == elbowRightName).FirstOrDefault();

                    elbowLeft.transform.parent = parentElbow.transform;
                    elbowRight.transform.parent = parentElbow.transform;

                    parentElbow.gameObject.AddComponent<SkinnedMeshRenderer>();
                    parentElbow.transform.parent = elbows.transform;
                    parentElbow.gameObject.SetActive(false);
                }
            }

            // LOWER ARMS
            Debug.Log("Working on lower arms armors...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_ArmLowerRight_" + gender))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parentLowerArms = new GameObject();
                    parentLowerArms.name = "LowerArm_" + partIndex;

                    // Creating the Arms strings
                    string lowerArmLeftName = "Chr_ArmLowerLeft_" + gender + "_" + partIndex;
                    string lowerArmRightName = "Chr_ArmLowerRight_" + gender + "_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component lowerArmLeft = elements.Where(obj => obj.name == lowerArmLeftName).FirstOrDefault();
                    Component lowerArmRight = elements.Where(obj => obj.name == lowerArmRightName).FirstOrDefault();

                    lowerArmLeft.transform.parent = parentLowerArms.transform;
                    lowerArmRight.transform.parent = parentLowerArms.transform;

                    parentLowerArms.gameObject.AddComponent<SkinnedMeshRenderer>();

                    // We check if it's the first, for naked, or index is higher and so it's an armor
                    if (elements[i].transform.name == "Chr_ArmLowerRight_" + gender + "_00")
                    {
                        parentLowerArms.transform.parent = body.transform;
                        parentLowerArms.name = "LowerArms";
                    }
                    else
                    {
                        parentLowerArms.transform.parent = lowerArms.transform;
                        parentLowerArms.gameObject.SetActive(false);
                    }
                }
            }

            // GAUNTLETS
            Debug.Log("Working on hands...");
            for (int i = 0; i < elements.Length; i++)
            {

                if (elements[i].transform.name.Contains("Chr_HandRight_" + gender))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parentHands = new GameObject();
                    parentHands.name = "Hands_" + partIndex;

                    // Creating the Arms strings
                    string handLeftName = "Chr_HandLeft_" + gender + "_" + partIndex;
                    string handRightName = "Chr_HandRight_" + gender + "_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component handLeft = elements.Where(obj => obj.name == handLeftName).FirstOrDefault();
                    Component handRight = elements.Where(obj => obj.name == handRightName).FirstOrDefault();

                    handLeft.transform.parent = parentHands.transform;
                    handRight.transform.parent = parentHands.transform;

                    parentHands.gameObject.AddComponent<SkinnedMeshRenderer>();

                    // Let's check if it's naked or a piece of armor
                    if (elements[i].transform.name == "Chr_HandRight_" + gender + "_00")
                    {
                        parentHands.transform.parent = body.transform;
                        parentHands.name = "Hands";
                    }
                    else
                    {
                        parentHands.transform.parent = hands.transform;
                        parentHands.gameObject.SetActive(false);
                    }
                }
            }

            // HIPS-PANTS
            Debug.Log("Working on pants...");
            for (int i = 0; i < elements.Length; i++)
            {
                if(elements[i].transform.name.Contains("Chr_Hips_" + gender))
                {
                    if (elements[i].transform.name.Contains("Chr_Hips_" + gender + "_00"))
                    {
                        elements[i].transform.parent = body.transform;
                        elements[i].gameObject.name = "Hips";
                    }
                    else
                    {
                        elements[i].transform.parent = pants.transform;
                        elements[i].gameObject.SetActive(false);
                    }

                }
            }

            // HIPS-PANTS ATTACHMENT
            Debug.Log("Working on hips attachment...");
            for (int i = 0; i < elements.Length; i++)
            {
                if(elements[i].name.Contains("Chr_HipsAttachment_"))
                {
                    int partIndex = int.Parse(StringTail(elements[i].transform.name, 2));
                    if(partIndex < 7)
                    {
                        elements[i].transform.name = "Hips_Right_" + StringTail(elements[i].transform.name, 2);
                        elements[i].transform.parent = hipsAttachmentRight.transform;
                    }
                    else
                    {
                        elements[i].transform.name = "Hips_Left_" + StringTail(elements[i].transform.name, 2);
                        elements[i].transform.parent = hipsAttachmentLeft.transform;
                    }

                    elements[i].gameObject.SetActive(false);
                }
            }

            // KNEES
            Debug.Log("Working on knees armors...");
            for (int i = 0; i < elements.Length; i++)
            {
                if (elements[i].transform.name.Contains("Chr_KneeAttachRight_"))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parenKnees = new GameObject();
                    parenKnees.name = "Knees_" + partIndex;

                    // Creating the shoulder(s) strings
                    string kneesLeftName = "Chr_KneeAttachLeft_" + partIndex;
                    string kneesRightName = "Chr_KneeAttachRight_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component kneesLeft = elements.Where(obj => obj.name == kneesLeftName).FirstOrDefault();
                    Component kneesRight = elements.Where(obj => obj.name == kneesRightName).FirstOrDefault();

                    kneesLeft.transform.parent = parenKnees.transform;
                    kneesRight.transform.parent = parenKnees.transform;

                    parenKnees.gameObject.AddComponent<SkinnedMeshRenderer>();
                    parenKnees.transform.parent = knees.transform;
                    parenKnees.gameObject.SetActive(false);
                }
            }

            // BOOTS (booth of lower legs, so the same system used in chest)
            Debug.Log("Working on boots...");
            for (int i = 0; i < elements.Length; i++)
            {

                if (elements[i].transform.name.Contains("Chr_LegRight_" + gender))
                {
                    string partIndex = StringTail(elements[i].transform.name, 2);
                    GameObject parentBoots = new GameObject();
                    parentBoots.name = "Boots_" + partIndex;
                    parentBoots.gameObject.AddComponent<SkinnedMeshRenderer>();

                    // Creating the Arms strings
                    string legLeftName = "Chr_LegLeft_" + gender + "_" + partIndex;
                    string legRightName = "Chr_LegRight_" + gender + "_" + partIndex;

                    // We are using Component 'cause to find the real objects and not the parent, we used the SkinnedMeshRenderer as reference
                    Component legLeft = elements.Where(obj => obj.name == legLeftName).FirstOrDefault();
                    Component legRight = elements.Where(obj => obj.name == legRightName).FirstOrDefault();

                    legLeft.transform.parent = parentBoots.transform;
                    legRight.transform.parent = parentBoots.transform;

                    // There is (was? maybe Synty one day will fix it) and issue with Male Legs
                    // which are inverted, indeed Male_11_Leg_Right have LegLeft inside!
                    // That's why I need another check :-\
                    if (elements[i].transform.name == "Chr_LegRight_" + gender + "_00")
                    {
                        parentBoots.transform.parent = body.transform;
                        parentBoots.name = "Foots";
                    }
                    else
                    {
                        parentBoots.transform.parent = boots.transform;
                        parentBoots.gameObject.SetActive(false);
                    }
                }
            }

            // Removing Uneeded parts
            if (removeOppositeGender)
            { DestroyImmediate(parent.gameObject); }
            else
            {
                GameObject allGendersParts = parent.transform.Find("All_Gender_Parts").gameObject;
                GameObject gendersParts = parent.transform.Find(gender + "_Parts").gameObject;

                DestroyImmediate(allGendersParts);
                DestroyImmediate(gendersParts);
            }
        }

        /// <summary>
        /// Generate all parents needed to store all body parts.
        /// </summary>
        private void CreateParents()
        {
            ///<TODO> MAKE PARAMETERS FOR LESS HARDCODE</TODO>

            body = new GameObject();
            body.name = "Body";
            body.transform.parent = transform.root;

            hair = new GameObject();
            hair.name = "Hairs";
            hair.transform.parent = body.transform;

            head = new GameObject();
            head.name = "Heads";
            head.transform.parent = body.transform;

            beard = new GameObject();
            beard.name = "Beards";
            beard.transform.parent = body.transform;

            ear = new GameObject();
            ear.name = "Ears";
            ear.transform.parent = body.transform;

            armor = new GameObject();
            armor.name = "Armor";
            armor.transform.parent = transform.root;

            headgear = new GameObject();
            headgear.name = "Headgears";
            headgear.transform.parent = armor.transform;

            headgearNoHair = new GameObject();
            headgearNoHair.name = "Headgears_NoHair";
            headgearNoHair.transform.parent = armor.transform;

            headgearNoBeard = new GameObject();
            headgearNoBeard.name = "Headgears_NoBeard";
            headgearNoBeard.transform.parent = armor.transform;

            headgearNoHead = new GameObject();
            headgearNoHead.name = "Headgears_NoHead";
            headgearNoHead.transform.parent = armor.transform;

            headgearDeco = new GameObject();
            headgearDeco.name = "Decorations";
            headgearDeco.transform.parent = headgearNoHead.transform;

            chest = new GameObject();
            chest.name = "Chests";
            chest.transform.parent = armor.transform;

            back = new GameObject();
            back.name = "Backs";
            back.transform.parent = armor.transform;

            shoulders = new GameObject();
            shoulders.name = "Shoulders";
            shoulders.transform.parent = armor.transform;

            elbows = new GameObject();
            elbows.name = "Elbows";
            elbows.transform.parent = armor.transform;

            //Uper Arms (booth) are linked directly to chest so we don't need of this
            lowerArms = new GameObject();
            lowerArms.name = "Arms";
            lowerArms.transform.parent = armor.transform;

            hands = new GameObject();
            hands.name = "Gloves";
            hands.transform.parent = armor.transform;

            pants = new GameObject();
            pants.name = "Pants";
            pants.transform.parent = armor.transform;

            hipsAttachmentRight = new GameObject();
            hipsAttachmentRight.name = "Hips Right Attachment";
            hipsAttachmentRight.transform.parent = armor.transform;

            hipsAttachmentLeft = new GameObject();
            hipsAttachmentLeft.name = "Hips Left Attachment";
            hipsAttachmentLeft.transform.parent = armor.transform;

            knees = new GameObject();
            knees.name = "Knees";
            knees.transform.parent = armor.transform;

            boots = new GameObject();
            boots.name = "Boots";
            boots.transform.parent = armor.transform;

        }

        /// <summary>
        /// Search for opposite gender gameObject and will disable or destroy it.
        /// </summary>
        private void DisableOppositeGenderGameObjects()
        {
            string otherGender = ((int)gender) == 1 ? "Male" : "Female";

            // Search for the Opposite parent which is defined as Female_Parts or Male_Parts
            Transform genderParent = parent.Find(otherGender + "_Parts");
            if (genderParent == null) return;

            if (removeOppositeGender)
            {
                DestroyImmediate(genderParent.gameObject);
                return;
            }

            // First Search for the Opposite Gender and disable all GameObjects
            foreach (Transform child in genderParent)
            {
                foreach (Transform grandChild in child)
                {
                    if (grandChild.childCount > 0)
                    {
                        for (int i = 0; i < grandChild.childCount; i++)
                            grandChild.GetChild(i).gameObject.SetActive(false);
                    }
                    else
                    {
                        grandChild.gameObject.SetActive(false);
                    }
                }
            }
        }

        /// <summary>
        /// Search recursively inside the given hierarchy and return the first child in the bottomest parent.
        /// So it is supposed that you will use SearchForLastParent(Pippo).parent to know who the parent is.
        /// </summary>
        private Transform SearchForLastParent(Transform parent)
        {
            Transform result = null;

            foreach (Transform child in parent)
            {
                if (child.childCount == 0)
                    result = child.transform;
                else
                    result = SearchForLastParent(child);

                if (result != null) break;
            }

            return result;
        }

        /// <summary>
        /// Return the tail of a string based on how many characters do you want
        /// </summary>
        public static string StringTail(string source, int tail_length)
        {
            if (tail_length >= source.Length)
                return source;
            return source.Substring(source.Length - tail_length);
        }
    }
}