Puppet Master Body Collision Integration with Invector TPC

using Invector.vCharacterController;
using RootMotion.Dynamics;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace Fox.Flow {
    public class vThirdPersonControllerPuppetMaster : vThirdPersonController {


        //##########################################################################################
        //##########################################################################################
        //
        //                                DAMAGE
        //
        //##########################################################################################
        //##########################################################################################

        protected PuppetMaster puppetMaster;
        protected BehaviourPuppet behaviourPuppet;

        private List<BodyCollisionInfo> BodyCollision = new List<BodyCollisionInfo>();
        public struct BodyCollisionInfo
        {
            public int muscle;
            public Vector3 position;
            public BodyCollisionInfo( int m, Vector3 p )
            {
                muscle = m;
                position = p;
            }
        }

        protected override void Start()
        {
            base.Start();

            // GETTING THE COMPONENTS ( SHOULD WORK WHEN PUPPET MASTER 0.9 IS SET UP CORRECTLY )
            puppetMaster = this.transform.parent.GetComponentInChildren<PuppetMaster>();
            behaviourPuppet = puppetMaster.behaviours.ToList().Find( x => x is BehaviourPuppet ) as BehaviourPuppet;

            // ADDING THE MUSCLE COLLISION EVENT
            behaviourPuppet.OnPreMuscleCollision += OnMuscleCollision;
        }


        private void OnMuscleCollision( MuscleCollision m )
        {
            // DON'T APPLY DAMAGE TO PROPS
            if ( puppetMaster.muscles[ m.muscleIndex ].props.group == Muscle.Group.Prop ) return;
            // RETURN WHEN DEAD
            if ( isDead ) return;

            // TO PREVENT THE CHARACTER TAKING DAMAGE ON THE COLLIDER
            // WHEN JUST STANDING IN PLACE OR BY JUST TOUCHING THE OTHER
            // COLLIDER I IMPLEMENTED A DISTANCE CHECK ON THE HIT POINT
            // TO PREVENT THIS SITUATION:
            // FIRST GETTING THE LAST HIT
            var bodyPart = GetCollisionInfo( m.muscleIndex );
            // GETTING THE CURRENT HIT
            BodyCollisionInfo newBodyPart = new BodyCollisionInfo( m.muscleIndex, m.collision.contacts[ 0 ].point );
            BodyCollision.Add( newBodyPart );
            bool count = false;
            // WHEN THERE IS NO LAST HIT THAN COUNT
            if ( bodyPart.Equals( default( BodyCollisionInfo ) ) )
            {
                count = true;
            }
            else
            {
                // OTHERWISE MAKE A DISTANCE CHECK
                if ( Vector3.Distance( bodyPart.position, newBodyPart.position ) > 0.1f )
                {
                    count = true;
                }

                BodyCollision.Remove( bodyPart );
            }

            // WHEN THE HIT IS VALID
            if ( count )
            {
                // CALCULATE THE IMPULSE BETWEEN THIS 2 COLLIDER
                var impulse = GetImpulse( m );

                // GIVE THE DAMAGE A VALUE, HIPS, SPINE AND HEAD ARE MORE SENSITIVE USUALLY
                var healthMinus = GetCollisionDamage( impulse, puppetMaster.muscles[ m.muscleIndex ].props.group );
                // CONVERT THE DAMAGE TO A LOWER USEFUL VALUE
                var healthDamage = healthMinus * 0.05f;

                // GET THE CURRENT HEALTH
                var health = currentHealth - healthDamage;

                // SUBTRACT HEALTH
                ChangeHealth( (int)health );
            }
        }

        // JUST MADE THIS FOR TESTING, USUALLY YOU WANT TO CREATE A COMPLEX COUNT SYSTEM ON
        // THE CHARACTER, BASICALLY SENSITIVE PARTS TAKE MORE DAMAGE THAN OTHER
        private float GetCollisionDamage( float rawDamage, Muscle.Group group )
        {
            switch ( group )
            {
                case Muscle.Group.Hips:
                    return rawDamage * 1.1f;
                case Muscle.Group.Spine:
                    return rawDamage;
                case Muscle.Group.Head:
                    return rawDamage * 2f;
                case Muscle.Group.Arm:
                    return rawDamage * 0.4f;
                case Muscle.Group.Hand:
                    return rawDamage * 0.2f;
                case Muscle.Group.Leg:
                    return rawDamage * 0.5f;
                case Muscle.Group.Foot:
                    return rawDamage * 0.2f;
                case Muscle.Group.Tail:
                    return rawDamage * 0.2f;
                case Muscle.Group.Prop:
                    return default;
                default:
                    return default;
            }
        }

        // GETS THE MUSCLE COLLISION INFO TO PREVENT A STRANGE DAMAGE BEHAVIOR WHEN COLLIDING
        private BodyCollisionInfo GetCollisionInfo( int muscle )
        {
            return BodyCollision.Find( x => x.muscle == muscle );
        }

        // GETTING THE RAW DAMAGE BASED ON THE COLLIDER MASS
        private float GetImpulse( MuscleCollision m )
        {
            float i = m.collision.impulse.sqrMagnitude;

            i /= puppetMaster.muscles[ m.muscleIndex ].rigidbody.mass;
            i *= 0.3f; // Coeficient for evening out for pre-0.3 versions

            return i;
        }
    }
}