Set Number of Targets based on int Number of Players

Hey! So i got this Camera Script:

using UnityEngine;
using System.Collections;

//namespace Complete
    public class CameraControl : MonoBehaviour
        public float m_DampTime = 0.2f;                 // Approximate time for the camera to refocus.
        public float m_ScreenEdgeBuffer = 4f;           // Space between the top/bottom most target and the screen edge.
        public float m_MinSize = 6.5f;                  // The smallest orthographic size the camera can be.

		public Camera m_Camera;                        // Used for referencing the camera.
		public float m_ZoomSpeed;                      // Reference speed for the smooth damping of the orthographic size.
		private Vector3 m_MoveVelocity;                 // Reference velocity for the smooth damping of the position.
		private Vector3 m_DesiredPosition;              // The position the camera is moving towards.

		public bool Player1Joined;						//check which player has Joined
		public bool Player2Joined;
		public bool Player3Joined;
		public bool Player4Joined;

		public int numberOfTargets;						//number of Players joined (1-4)
        public Transform[] m_Targets;					 // All the targets the camera needs to encompass.
		public GameObject[] m_Spawnpoints;				//All available Spawnpoints (4)

        private void Awake ()
            m_Camera = GetComponentInChildren<Camera> ();

        private void FixedUpdate ()
            // Move the camera towards a desired position.
            Move ();

            // Change the size of the camera based.
            Zoom ();

		private void SetCameraTargets()
			// Create a collection of transforms the same size as the number of tanks.
			Transform[] targets = new Transform[m_Spawnpoints.Length];
			// For each of these transforms...
			for (int i = 0; i < targets.Length; i++)
				// ... set it to the appropriate tank transform.
				targets <em>= m_Spawnpoints*.transform;*</em>

* }*

* // These are the targets the camera should follow.*
* //m_CameraControl.m_Targets = targets;
m_Targets = targets;

private void Move ()
// Find the average position of the targets.
FindAveragePosition ();

// Smoothly transition to that position.
transform.position = Vector3.SmoothDamp(transform.position, m_DesiredPosition, ref m_MoveVelocity, m_DampTime);

private void FindAveragePosition ()
Vector3 averagePos = new Vector3 ();
int numTargets = 0;

// Go through all the targets and add their positions together.
for (int i = 0; i < m_Targets.Length; i++)
// If the target isn’t active, go on to the next one.
if (!m_Targets*.gameObject.activeSelf)*

// Add to the average and increment the number of targets in the average.
averagePos += m_Targets*.position;

// If there are targets divide the sum of the positions by the number of them to find the average.
if (numTargets > 0)
averagePos /= numTargets;

// Keep the same y value.
averagePos.y = transform.position.y;

// The desired position is the average position;
m_DesiredPosition = averagePos;

private void Zoom ()
// Find the required size based on the desired position and smoothly transition to that size.
float requiredSize = FindRequiredSize();
m_Camera.orthographicSize = Mathf.SmoothDamp (m_Camera.orthographicSize, requiredSize, ref m_ZoomSpeed, m_DampTime);

private float FindRequiredSize ()
// Find the position the camera rig is moving towards in its local space.
Vector3 desiredLocalPos = transform.InverseTransformPoint(m_DesiredPosition);

// Start the camera’s size calculation at zero.
float size = 0f;

// Go through all the targets…
for (int i = 0; i < m_Targets.Length; i++)
// … and if they aren’t active continue on to the next target.
if (!m_Targets*.gameObject.activeSelf)*

// Otherwise, find the position of the target in the camera’s local space.
Vector3 targetLocalPos = transform.InverseTransformPoint(m_Targets*.position);*

// Find the position of the target from the desired position of the camera’s local space.
Vector3 desiredPosToTarget = targetLocalPos - desiredLocalPos;

// Choose the largest out of the current size and the distance of the tank ‘up’ or ‘down’ from the camera.
size = Mathf.Max(size, Mathf.Abs(desiredPosToTarget.y));

// Choose the largest out of the current size and the calculated size based on the tank being to the left or right of the camera.
size = Mathf.Max(size, Mathf.Abs(desiredPosToTarget.x) / m_Camera.aspect);

// Add the edge buffer to the size.
size += m_ScreenEdgeBuffer;

// Make sure the camera’s size isn’t below the minimum.
size = Mathf.Max (size, m_MinSize);

return size;

public void SetStartPositionAndSize ()
// Find the desired position.
FindAveragePosition ();

// Set the camera’s position to the desired position without damping.
transform.position = m_DesiredPosition;

// Find and set the required size of the camera.
m_Camera.orthographicSize = FindRequiredSize ();
So, the “public int numberOfTargets” and “public bool PlayerXJoined” already gets filled correct based on how much and which players joined (max 4).
what i want to do now is, that the “public Transform[] m_Targets” gets filled correct like this:
(the Targets fields are the important ones)
how can i do this?

I would have something like this.

int targetCount = 0;
    //Check amount of players
    for (int i = 0; i < players.Length; i++) {
           if (player.hasJoined)
                    targetCount ++;
    //Spawn Targets
    for (int i = 0; i < targetCount; i++) {
           //Spawn Target