Blast Till Last

void AC_A_SharedCamera::UpdateCameraLocation(float deltaTime)
{
	//Loop over all active players
	FVector targetLocation{ 0,0,0 };
	float amountOfAdds{ 0 };
	for (int i = 0; i < m_Players.Num(); i++)
	{
		//Add their locations to form a total vector
		if (m_Players[i].IsAlive)
		{
			targetLocation += m_Players[i].Location;
			amountOfAdds++;
		}
	}

	//Divide by the number of alive players to get an average location
	//Here is where the camera is centered to get an optimal view of everyone
	const FVector avgLocation = FVector(targetLocation.X / amountOfAdds, targetLocation.Y / amountOfAdds, targetLocation.Z / amountOfAdds);

	//Ease camera to that new location
	const FVector newCameraLocation = FMath::VInterpTo(m_CameraPreviousLocation, avgLocation, deltaTime, m_InterpSpeed);
	SetActorLocation(newCameraLocation);

	//Set previous location to the current one for next time
	m_CameraPreviousLocation = GetActorLocation();

	//Additional check for Z-axis offset
	if (m_UseZOffset)
	{
		float armLength{};
		for (int i = 0; i < m_Players.Num(); i++)
		{
			if (m_pCameraSpringArm->TargetArmLength < m_ZValueToStopOffset && m_Players[i].Location.Z > m_JumpHeightToStartZOffset)
			{
				//Clamping the arm length in case the distance from player to camera is smaller than the min. allowed value
				armLength = (m_pCameraSpringArm->TargetArmLength < m_MinClamp) ? m_MinClamp : m_pCameraSpringArm->TargetArmLength;

				//We need a percentage of the additional offset to add depending on the max. value to stop ofsetting
				const float ratio = armLength / m_ZValueToStopOffset;
				const float zOffset = m_ExtraZOffset - (ratio * m_ExtraZOffset);

				//Set the correct offset vector
				FVector cameraLocation = GetActorLocation();
				cameraLocation.Z += zOffset;

				//Update camera position
				const FVector offsettedCameraLocation = FMath::VInterpTo(m_CameraPreviousLocation, cameraLocation, deltaTime, m_InterpSpeed);
				SetActorLocation(offsettedCameraLocation);

				//Set previous location to the current one for next time
				m_CameraPreviousLocation = GetActorLocation();
			}
		}
	}

	//Additional check for Y-axis offset
	if (m_UseYOffset)
	{
		float previousDistancePlayerToCamera{};
		for (int i = 0; i < m_Players.Num(); i++)
		{
			const float distancePlayerToCamera = FVector::Distance(m_Players[i].Location, GetActorLocation());
			if (m_MaximumDistance > distancePlayerToCamera)
			{
				if (previousDistancePlayerToCamera < distancePlayerToCamera)
				{
					//Give extra offset on the Y-axis
					previousDistancePlayerToCamera = distancePlayerToCamera;

					//Determine the offset to add to the current camera location
					FVector cameraLocation = GetActorLocation();
					float yOffset = (m_MaximumDistance - distancePlayerToCamera) / 4.f;

					//Clamp it to a maximum value
					if (yOffset > m_MaximumYOffset)
					{
						yOffset = m_MaximumYOffset;
					}
					cameraLocation.Y += yOffset;

					//Set new camera location
					const FVector offsettedCameraLocation = FMath::VInterpTo(m_CameraPreviousLocation, cameraLocation, deltaTime, m_InterpSpeed);
					SetActorLocation(offsettedCameraLocation);

					//Set previous location to the current one for next time
					m_CameraPreviousLocation = GetActorLocation();
				}
			}
		}
	}
}