// Creates particles for the body
    protected void CreateParticles()
    {
        particles          = new PSBParticle[numOfParticles];
        predictedParticles = new PSBParticle[numOfParticles];
        internalSprings    = new PSBInternalSpring[numOfParticles];

        // Create the particles
        for (int i = 0; i < numOfParticles; i++)
        {
            particles[i]          = new PSBParticle();
            predictedParticles[i] = new PSBParticle();

            particles[i].position.x = bodyRadius * Mathf.Sin((i + 1) * (2.0f * Mathf.PI) / numOfParticles);
            particles[i].position.y = bodyRadius * Mathf.Cos((i + 1) * (2.0f * Mathf.PI) / numOfParticles);            // + SCRSIZE/2;

            // Gameobject
            particles[i].gameObj                         = new GameObject();
            particles[i].gameObj.name                    = "Particle_" + i;
            particles[i].gameObj.transform.parent        = transform;
            particles[i].gameObj.transform.localPosition = Vector2.zero;
            particles[i].gameObj.layer                   = 8;

            // Rigidbody
            particles[i].rBody                        = particles[i].gameObj.AddComponent <Rigidbody2D>();
            particles[i].rBody.mass                   = mass;
            particles[i].rBody.position               = particles[i].position;
            particles[i].rBody.angularDrag            = 0.5f;
            particles[i].rBody.drag                   = rigidbodyDrag;
            particles[i].rBody.constraints            = RigidbodyConstraints2D.FreezeRotation;
            particles[i].rBody.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
            particles[i].rBody.gravityScale           = gravityScale;

            // Collider
            particles[i].circleCol        = particles[i].gameObj.AddComponent <CircleCollider2D>();
            particles[i].circleCol.radius = particleColliderRadius;
        }
    }
    protected Vector3[] vertices = null; // Mesh vertices...

    #endregion Fields

    #region Methods

    // Calculates the accumululation of forces to the character
    protected void AccumulateForces(ref PSBParticle[] particleArray)
    {
        float lengthBetweenParticles = 0f;	// length of p1 - p2 vector
        float hookeForceValue = 0f;			// hooke force value
        float pressurev = 0f;				// pressure force value
        float volume = 0f;					// the volume of the body
        Vector2 particle1Pos = Vector2.zero;// positions of spring particles p1, p2
        Vector2 particle2Pos = Vector2.zero;// positions of spring particles p1, p2
        Vector2 v12 = Vector2.zero;			// particle1Pos.vel - particle2Pos.vel
        Vector2 force = Vector2.zero;		// the calculated force for each spring

        // Reset all forces
        for (int i = 0; i < numOfParticles ; i++)
        {
            particleArray[i].force = Vector2.zero;
        }

        // Spring force
        for (int i = 0; i < numOfParticles ; i++)
        {
            // get positions of spring start & end particles
            particle1Pos = particleArray[internalSprings[i].i].position;
            particle2Pos = particleArray[internalSprings[i].j].position;
            lengthBetweenParticles = (particle1Pos - particle2Pos).magnitude; // calculate square root  of the distance

            if (lengthBetweenParticles != 0)
            {
                // get velocities of start & end particles
                v12 = particleArray[internalSprings[i].i].velocity - particleArray[internalSprings[i].j].velocity;

                // calculate force value
                hookeForceValue = (lengthBetweenParticles - internalSprings[i].length) * springConstantElasticity + (v12.x * (particle1Pos.x - particle2Pos.x) + v12.y * (particle1Pos.y - particle2Pos.y)) * springDamping / lengthBetweenParticles;

                // force vector
                force = ((particle1Pos - particle2Pos) / lengthBetweenParticles ) * hookeForceValue;

                // accumulate force for starting particle
                particleArray[internalSprings[i].i].force -= force;

                // accumulate force for end particle
                particleArray[internalSprings[i].j].force += force;
            }

            // Calculate normal vectors to springs
            internalSprings[i].norm.x =  (particle1Pos.y - particle2Pos.y) / lengthBetweenParticles;
            internalSprings[i].norm.y = -(particle1Pos.x - particle2Pos.x) / lengthBetweenParticles;
        }

        // Calculate Volume of the Ball (Gauss Theorem)
        for (int i = 0; i < numOfParticles; i++)
        {
            particle1Pos = particleArray[internalSprings[i].i].position;
            particle2Pos = particleArray[internalSprings[i].j].position;
            lengthBetweenParticles = (particle1Pos - particle2Pos).magnitude;
            volume += 0.5f * Mathf.Abs(particle1Pos.x - particle2Pos.x) * Mathf.Abs(internalSprings[i].norm.x) * (lengthBetweenParticles);
        }

        // Calculate Pressure Force Distribution
        for (int i = 0; i < numOfParticles; i++)
        {
            // Get the particles and calculate the distance between them
            particle1Pos = particleArray[internalSprings[i].i].position;
            particle2Pos = particleArray[internalSprings[i].j].position;
            lengthBetweenParticles = (particle1Pos - particle2Pos).magnitude;

            // P = 1/V * A * P * N
            pressurev = lengthBetweenParticles * pressure * (1.0f/volume);
            particleArray[internalSprings[i].i].force.x += internalSprings[i].norm.x * pressurev;
            particleArray[internalSprings[i].i].force.y += internalSprings[i].norm.y * pressurev;
            particleArray[internalSprings[i].j].force.x += internalSprings[i].norm.x * pressurev;
            particleArray[internalSprings[i].j].force.y += internalSprings[i].norm.y * pressurev;

            // Calculate the particle normal by using the normal of the two springs attached to it
            particleArray[i].normal = (internalSprings[particleArray[i].prevInternalSpring].norm + internalSprings[particleArray[i].nextInternalSpring].norm).normalized;
        }
    }
    // Creates particles for the body
    protected void CreateParticles()
    {
        particles = new PSBParticle[numOfParticles];
        predictedParticles = new PSBParticle[numOfParticles];
        internalSprings = new PSBInternalSpring[numOfParticles];

        // Create the particles
        for (int i = 0; i < numOfParticles; i++)
        {
            particles[i] = new PSBParticle();
            predictedParticles[i] = new PSBParticle();

            particles[i].position.x = bodyRadius * Mathf.Sin((i + 1) * (2.0f * Mathf.PI) / numOfParticles);
            particles[i].position.y = bodyRadius * Mathf.Cos((i + 1) * (2.0f * Mathf.PI) / numOfParticles);// + SCRSIZE/2;

            // Gameobject
            particles[i].gameObj = new GameObject();
            particles[i].gameObj.name = "Particle_" + i;
            particles[i].gameObj.transform.parent = transform;
            particles[i].gameObj.transform.localPosition = Vector2.zero;
            particles[i].gameObj.layer = 8;

            // Rigidbody
            particles[i].rBody = particles[i].gameObj.AddComponent<Rigidbody2D>();
            particles[i].rBody.mass = mass;
            particles[i].rBody.position = particles[i].position;
            particles[i].rBody.angularDrag = 0.5f;
            particles[i].rBody.drag = rigidbodyDrag;
            particles[i].rBody.constraints = RigidbodyConstraints2D.FreezeRotation;
            particles[i].rBody.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
            particles[i].rBody.gravityScale = gravityScale;

            // Collider
            particles[i].circleCol = particles[i].gameObj.AddComponent<CircleCollider2D>();
            particles[i].circleCol.radius = particleColliderRadius;
        }
    }